def test_neighbours_origin(self):
maze = Maze()
length = randint(1, 10)
maze.set_board([[Cell(i, j, False) for i in range(length)]
for j in range(length)])
neighbours_to_origin = maze.get_cell_neighbours(0, 0)
self.assertEqual(2, len(neighbours_to_origin))
def generate(self, dim):
maze = Maze(dim)
x = randrange(dim)
y = randrange(dim)
logging.debug("Chose (%s, %s) as initial cell", x, y)
stack = [(x, y)]
maze.get(x, y).visited = True
self.initbar(dim*dim)
i = 0
while len(stack) > 0:
cursearch = stack[-1]
randdirs = Direction.randdirs()
foundnext = False
for dir in randdirs: # search for a new cell to explore
candidate = maze.getbydir(cursearch[0], cursearch[1], dir)
if candidate is not None and not candidate.visited: # new explorable cell found
maze.connect(cursearch[0], cursearch[1], dir) # create path between current and new cell
candidate.visited = True # set new node as visited
stack.append((candidate.x, candidate.y))# set new cell as next explorable node
foundnext = True
i += 1
self.updatebar(i)
break
if not foundnext:
stack.pop()
# set all cells as unvisited
for x in range(dim):
for y in range(dim):
maze.get(x, y).visited = False
self.finishbar()
return maze
def test_neighbours_center(self):
maze = Maze()
length = randint(1, 10)
maze.set_board([[Cell(i, j, False) for i in range(length)]
for j in range(length)])
neighbours_to_center = maze.get_cell_neighbours(1, 1)
self.assertEqual(4, len(neighbours_to_center))
def test_get_status_READY(self):
maze = Maze()
length = randint(1, 10)
maze.set_board([[Cell(i, j, True) for i in range(length)]
for j in range(length)])
maze.set_track({maze.get_cell(0, 0): []})
self.assertEqual(MazeStatus.READY, maze.get_status())
def test_get_status_GENERATING(self):
maze = Maze()
length = randint(1, 10)
maze.set_board([[Cell(i, j, False) for i in range(length)]
for j in range(length)])
maze.set_track({maze.get_cell(0, 0): []})
maze.set_cell_value(0, 0, True)
self.assertEqual(MazeStatus.GENERATING, maze.get_status())
def main():
print("URL:{}".format(url))
with grpc.insecure_channel(url) as channel:
stub = maze_pb2_grpc.MazeStub(channel)
response = stub.Gen(maze_pb2.GenRequest(w=97, h=45))
print(response.field)
m = Maze(response.field)
m.renderMaze('maze.svg')
def test_break_wall(self):
maze = Maze(width=2, height=1)
self.assertSetEqual(maze.paths(0, 0), set())
self.assertSetEqual(maze.paths(1, 0), set())
maze.break_wall(0, 0, Compass.EAST)
self.assertSetEqual(maze.paths(0, 0), {Compass.EAST})
print(maze.paths(1, 0))
self.assertSetEqual(maze.paths(1, 0), {Compass.WEST})
def create_maze(self):
allPoints = [(x, y) for x in range(self.size)
for y in range(self.size)]
sampled = random.sample(allPoints, self.num_of_obstacles + 2)
start = sampled[0]
destination = sampled[1]
obstacles = sampled[2:]
self.maze = Maze(size=self.size,
start=start,
destination=destination,
obstacles=obstacles)
def path_finder(maze):
maze = maze.split('\n')
maze = Maze(maze)
G = maze.get_graph_from_maze()
color = {i: "white" for i in G.keys()}
pred = {i: None for i in G.keys()}
cc = {i: None for i in G.keys()}
cc_num = [0]
dfs(G, color, pred, cc, cc_num)
start_idx = 0
exit_idx = maze.n * maze.m - 1
if start_idx not in G.keys() or exit_idx not in G.keys():
return False
elif cc[start_idx] != cc[exit_idx]:
return False
else:
return True
def generate(self, dim):
maze = Maze(dim)
x = randrange(dim)
y = randrange(dim)
logging.debug("Chose (%s, %s) as initial cell", x, y)
explorablenodes =[(x, y)]
maze.get(x, y).visited = True
self.initbar(dim*dim)
i = 0
while len(explorablenodes) > 0:
cursearch = explorablenodes[randrange(len(explorablenodes))]
randdirs = Direction.randdirs()
foundNext = False
for dir in randdirs: # search for a new cell to explore
candidate = maze.getbydir(cursearch[0], cursearch[1], dir)
if candidate is not None and not candidate.visited:
maze.connect(cursearch[0], cursearch[1], dir)
candidate.visited = True
if maze.explorables(candidate.x, candidate.y) > 0:
explorablenodes.append((candidate.x, candidate.y))
foundNext = True
i += 1
self.updatebar(i)
break
if not foundNext:
explorablenodes.remove(cursearch)
# set all cells as unvisited
for x in range(dim):
for y in range(dim):
maze.get(x, y).visited = False
self.finishbar()
return maze
def __init__(self):
pygame.init()
self.is_dog = False
self.screen = pygame.display.set_mode(self.size)
self.screen.fill(BACKGROUND_COLOR)
self.clock = Clock()
self.tiles = Tiles()
self.generator = MazeGenerator(MAZE_WIDTH, MAZE_HEIGHT)
self.maze = Maze(self.tiles)
self.mouse_tile, *self.mouse_recs = self.tiles.mice
self.game_state = GameState(self.tiles)
self.clear_tiles = list()
self.mouse = None
self.cats = None
self.dog = None
self.cheese = None
self.bones = None
self.level = 0
def __init__(self):
self._maze = Maze()
def test_maze_dimensions(self):
maze = Maze(width=3, height=2)
self.assertEqual(len(maze._grid), 2)
self.assertEqual(len(maze._grid[0]), 3)
def test_maze_paths(self):
maze = Maze(width=1, height=1)
maze._grid[0][0] = Compass.NORTH | Compass.WEST
self.assertEqual(maze.paths(0, 0), {Compass.SOUTH, Compass.EAST})
def test_maze_has_2x2_center(self):
maze = Maze(width=6, height=6)
self.assertSetEqual(maze.paths(2, 2), {Compass.SOUTH, Compass.EAST})
self.assertSetEqual(maze.paths(3, 2), {Compass.SOUTH, Compass.WEST})
self.assertSetEqual(maze.paths(3, 3), {Compass.NORTH, Compass.WEST})
self.assertSetEqual(maze.paths(2, 3), {Compass.NORTH, Compass.EAST})
def test_init(self):
maze = Maze(2)
self.assertEqual(maze.dim, 2)
self.assertEqual(maze.grid.shape, (3, 3))
def test_get_status_INIT(self):
maze = Maze()
length = randint(1, 10)
maze.set_board([[Cell(i, j, False) for i in range(length)]
for j in range(length)])
self.assertEqual(MazeStatus.INIT, maze.get_status())
def test_connect_south(self):
maze = Maze(2)
maze.connect(0, 0, Direction.SOUTH)
self.assertEqual(maze.get(0, 0).walls[Direction.SOUTH], False)
self.assertEqual(maze.get(0, 1).walls[Direction.NORTH], False)
def test_connect_east(self):
maze = Maze(2)
maze.connect(0, 0, Direction.EAST)
self.assertEqual(maze.get(0, 0).walls[Direction.EAST], False)
self.assertEqual(maze.get(1, 0).walls[Direction.WEST], False)
def test_get(self):
maze = Maze(2)
maze.grid[1, 0].visited = True
self.assertEqual(maze.get(0, 0).visited, False)
self.assertEqual(maze.get(1, 0).visited, True)
def setUp(self) -> None:
grid = np.array([[], []])
self.maze = Maze(grid, (0, 0), (10, 12))
self.solver = MazeSolver(self.maze)
pass
import os
from maze.maze import Maze
if __name__ == "__main__":
os.system('cls')
maze = Maze(25, 10, 6)
