apollo/maze-solver
1
0
Fork 0
Code Pull requests Projects Releases Packages Activity Actions
maze-solver/maze.py

291 lines
9.4 KiB
Python
Raw Normal View History

feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
from typing import List, Dict
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
from time import sleep
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
import random
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
from enum import Enum
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
from graphics import Window
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
from cell import Cell, CellWallLabels
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
class MazeDirections(Enum):
"""
MazeDirection represents the directions you can
take in the maze.
"""
ABOVE = 0
BELOW = 1
LEFT = 2
RIGHT = 3
class MazePosition:
"""
MazePosition represents a position on the maze grid.
"""
def __init__(self, i: int, j: int, max_i: int, max_j: int):
self.i = i
self.j = j
self.max_i = max_i
self.max_j = max_j
def __eq__(self, other) -> bool:
if (self.i == other.i) and (self.j == other.j) and (self.max_i == other.max_i) and (self.max_j == other.max_j):
return True
return False
def get_adjacent_position(
self,
direction: MazeDirections
) -> 'MazePosition':
if direction not in MazeDirections:
raise TypeError(
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
"The argument does not appear to be a valid maze direction."
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
)
if direction is MazeDirections.ABOVE and (self.i-1 >= 0):
return MazePosition(
i=self.i-1,
j=self.j,
max_i=self.max_i,
max_j=self.max_j,
)
if direction is MazeDirections.BELOW and (self.i+1 <= self.max_i):
return MazePosition(
i=self.i+1,
j=self.j,
max_i=self.max_i,
max_j=self.max_j,
)
if direction is MazeDirections.LEFT and (self.j-1 >= 0):
return MazePosition(
i=self.i,
j=self.j-1,
max_i=self.max_i,
max_j=self.max_j,
)
if direction is MazeDirections.RIGHT and (self.j+1 <= self.max_j):
return MazePosition(
i=self.i,
j=self.j+1,
max_i=self.max_i,
max_j=self.max_j,
)
return None
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
class Maze:
"""
Maze represents a two-dimensional grid of Cells.
"""
def __init__(
self,
x_position: int,
y_position: int,
test: add tests for the Maze class Add some tests to test the Maze constructor.
2024-02-13 14:21:35 +00:00
num_cell_rows: int,
num_cells_per_row: int,
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
cell_size_x: int,
cell_size_y: int,
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
window: Window = None,
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
seed=None,
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
) -> None:
self._x_position = x_position
self._y_position = y_position
test: add tests for the Maze class Add some tests to test the Maze constructor.
2024-02-13 14:21:35 +00:00
self._num_cell_rows = num_cell_rows
self._num_cells_per_row = num_cells_per_row
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
self._cell_size_x = cell_size_x
self._cell_size_y = cell_size_y
self._window = window
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
# initialise the random number generator
random.seed(seed)
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
# Create the Maze's cells
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
self._cells: List[List[Cell]] = [
None for i in range(self._num_cell_rows)]
self._create_cell_grid()
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
# Open up the maze's entrance and exit.
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
self._open_entrance_and_exit()
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
start_position = MazePosition(
i=0,
j=0,
max_i=self._num_cell_rows-1,
max_j=self._num_cells_per_row-1,
)
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
# Generate the maze.
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
self._break_walls_r(start_position)
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
def _create_cell_grid(self) -> None:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
"""
creates all the cells and draws them.
"""
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
cursor_x = self._x_position
cursor_y = self._y_position
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
test: add tests for the Maze class Add some tests to test the Maze constructor.
2024-02-13 14:21:35 +00:00
for i in range(self._num_cell_rows):
cells: List[Cell] = [None for j in range(self._num_cells_per_row)]
for j in range(self._num_cells_per_row):
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
cell = Cell(
cursor_x,
cursor_y,
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
(cursor_x + self._cell_size_x),
(cursor_y + self._cell_size_y),
self._window
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
)
test: add tests for the Maze class Add some tests to test the Maze constructor.
2024-02-13 14:21:35 +00:00
cells[j] = cell
if j == self._num_cells_per_row - 1:
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
cursor_x = self._x_position
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
else:
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
cursor_x += self._cell_size_x
test: add tests for the Maze class Add some tests to test the Maze constructor.
2024-02-13 14:21:35 +00:00
self._cells[i] = cells
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
cursor_y += self._cell_size_y
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
if self._window:
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
self._draw_cell_grid()
def _draw_cell_grid(self) -> None:
"""
draws all the cells on the maze with a short pause between each cell
for animation purposes.
"""
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
for i in range(self._num_cell_rows):
for j in range(self._num_cells_per_row):
self._draw_cell(i=i, j=j)
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
def _open_entrance_and_exit(self) -> None:
"""
opens the maze's entrance and exit cells by breaking their respective
walls. The entrance is located at the top left and the exit is located
at the bottom right of the maze.
"""
feat: add entrance, exit to the maze. - Add an entrance and exit to the maze. The entrance will always be on the top left and the exit will always be on the bottom right. - Add a simple GitHub actions workflow to run the Python tests.
2024-02-13 15:52:28 +00:00
self._cells[0][0].configure_walls(top=False)
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
self._cells[self._num_cell_rows -
1][self._num_cells_per_row-1].configure_walls(bottom=False)
feat: add entrance, exit to the maze. - Add an entrance and exit to the maze. The entrance will always be on the top left and the exit will always be on the bottom right. - Add a simple GitHub actions workflow to run the Python tests.
2024-02-13 15:52:28 +00:00
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
if self._window:
self._draw_cell(0, 0)
self._draw_cell(
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
i=self._num_cell_rows-1,
j=self._num_cells_per_row-1
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
)
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
def _break_walls_r(self, current_position: MazePosition) -> None:
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
"""
_break_walls_r generates a random maze by traversing through the
cells and randomly knocking down the walls to create the maze's paths.
"""
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
current_cell = self._cells[current_position.i][current_position.j]
fix: create a separate visited variable for solver - Create a new visited variable for the Maze solver. - Rename the existing visited variable to visited_by_maze_generator for the generator.
2024-02-15 03:45:01 +00:00
current_cell.visited_by_maze_generator = True
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
while True:
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
possible_directions: List[MazeDirections] = []
for direction in MazeDirections:
adjacent_position = current_position.get_adjacent_position(
direction)
if adjacent_position is None:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
continue
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
adjacent_cell = self._cells[adjacent_position.i][adjacent_position.j]
if adjacent_cell.visited_by_maze_generator:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
continue
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
possible_directions.append(direction)
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
if len(possible_directions) == 0:
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
if self._window:
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
self._draw_cell(i=current_position.i, j=current_position.j)
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
break
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
chosen_direction = random.choice(possible_directions)
next_position = current_position.get_adjacent_position(
chosen_direction)
next_cell = self._cells[next_position.i][next_position.j]
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
if chosen_direction is MazeDirections.ABOVE:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
current_cell.configure_walls(top=False)
next_cell.configure_walls(bottom=False)
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
elif chosen_direction is MazeDirections.BELOW:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
current_cell.configure_walls(bottom=False)
next_cell.configure_walls(top=False)
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
elif chosen_direction is MazeDirections.LEFT:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
current_cell.configure_walls(left=False)
next_cell.configure_walls(right=False)
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
elif chosen_direction is MazeDirections.RIGHT:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
current_cell.configure_walls(right=False)
next_cell.configure_walls(left=False)
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
if self._window:
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
self._draw_cell(i=current_position.i, j=current_position.j)
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
refactor: use MazePosition as an argument - Use MazePosition as the argument for the _break_wall_r method - Generate small mazes for tests to avoid RecursionError exceptions.
2024-02-15 16:36:18 +00:00
self._break_walls_r(next_position)
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
def solve(self) -> bool:
"""
solve attempts to solve the generated maze.
"""
start_position = MazePosition(
i=0,
j=0,
max_i=self._num_cell_rows-1,
max_j=self._num_cells_per_row-1,
)
end_position = MazePosition(
i=self._num_cell_rows-1,
j=self._num_cells_per_row-1,
max_i=self._num_cell_rows-1,
max_j=self._num_cells_per_row-1,
)
return self._solve_r(start_position, end_position)
def _solve_r(
self,
current_position: MazePosition,
end_position: MazePosition,
) -> bool:
if current_position == end_position:
return True
current_cell = self._cells[current_position.i][current_position.j]
current_cell.visited_by_maze_solver = True
wall_map: Dict[MazeDirections, CellWallLabels] = {
MazeDirections.ABOVE: CellWallLabels.BOTTOM,
MazeDirections.BELOW: CellWallLabels.TOP,
MazeDirections.LEFT: CellWallLabels.RIGHT,
MazeDirections.RIGHT: CellWallLabels.LEFT,
}
for direction in MazeDirections:
adjacent_position = current_position.get_adjacent_position(
direction)
if adjacent_position is None:
continue
adjacent_cell = self._cells[adjacent_position.i][adjacent_position.j]
if adjacent_cell.visited_by_maze_solver or adjacent_cell.wall_exists(wall_map[direction]):
continue
self._draw_path(current_cell, adjacent_cell)
result = self._solve_r(adjacent_position, end_position)
if result is True:
return True
self._draw_path(current_cell, adjacent_cell, undo=True)
return False
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
def _draw_cell(self, i: int, j: int) -> None:
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
"""
fix: fixed issues with the maze generation - Fixed the issue where during the reconfiguration of the walls of a cell, those that weren't being reconfigured were reset to True regardless of their previous configuration. - During testing, don't run the _break_walls_r method because it will run into the RecursionError exception. - Simplify the code for drawing cells and fix the redrawing wasn't applied properly.
2024-02-15 03:30:30 +00:00
_draw_cell draws the cells in an animated way.
feat: add maze generation functionality Main feature: - Added functionality to randomly generate a maze before the solver solves it. Fixes: - Add a public method in the Cell class called wall_exists() that returns true if a given cell wall exists (false otherwise). Refactors: - Added an enum type called CellWallLabel for labelling the four cell walls. - Added a draw() function in the CellWall class to reduce repeated code. - Move the custom exceptions to errors.py Tests: - Add tests for the custom exceptions. CI: - Added a workflow for Forgejo Actions.
2024-02-14 22:50:46 +00:00
"""
refactor: add MazeDirections and MazePositions - Created a new enum type called MazeDirections to represent the directions you can make in the maze. - Created a class called MazePosition to represent the position on the maze grid. It has the functionality to calculate and return adjacent positions. - Used the above two additions to refactor the _break_walls_r method and make it a bit easier to read.
2024-02-15 14:58:51 +00:00
self._cells[i][j].draw()
fix: only draw the graphics if the window exists Optionally pass in the reference of the Window to the Maze and Cell classes, and only draw the graphics if the reference exists. Use a single underscore instead of the double underscore for private Class members.
2024-02-13 13:39:25 +00:00
self._window.redraw()
feat: add the Maze class The Maze class stored a 2-dimensional grid of Cells. When the Maze is initialised, the Cell's are created and drawn onto the canvas.
2024-02-13 12:18:47 +00:00
sleep(0.05)
feat: add the algorithm to solve the maze
2024-02-15 19:13:31 +00:00
def _draw_path(self, current_cell: Cell, next_cell: Cell, undo: bool = False) -> None:
current_cell.draw_move(next_cell, undo)
self._window.redraw()
sleep(0.05)
Copy permalink