def testCuldeSacFiller(self): """ test against a maze with outer/inner entraces """ starts = [True, False] ends = [True, False] g = self._example_cul_de_sac_maze() for s in starts: for e in ends: m = Maze() m.generator = Prims(3, 3) m.grid = g if s and e: m.start = (1, 0) m.end = (5, 6) elif not s and not e: m.start = (1, 1) m.end = (5, 5) else: if s: m.start = (1, 1) m.end = (5, 5) else: m.start = (1, 1) m.end = (5, 6) m.solver = CuldeSacFiller() m.solve() for sol in m.solutions: self.assertFalse(self._duplicates_in_solution(sol)) self.assertTrue(self._one_away(m.start, sol[0])) self.assertTrue(self._one_away(m.end, sol[-1]))
def test_maze_to_string(self): """ test that the 'to string' functionality is sane """ m = Maze() m.generator = Prims(3, 3) # fake some maze results, to test against m.grid = np.array([[1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 0, 0, 1], [1, 0, 1, 0, 1, 1, 1], [1, 0, 1, 0, 0, 0, 1], [1, 1, 1, 0, 1, 1, 1], [1, 0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1]]) m.start = (5, 0) m.end = (3, 6) m.solutions = [[(5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (4, 5), (3, 5)]] s = str(m).split('\n') self.assertEqual(s[0].strip(), "#######") self.assertEqual(s[2].strip(), "# # ###") self.assertEqual(s[3].strip(), "# # +E") self.assertEqual(s[5].strip(), "S+++++#") self.assertEqual(s[6].strip(), "#######")
def handle(self, *args, **options): m = Maze() m.generator = Prims(10, 10) m.generate() m.generate_entrances() print() self.stdout.write(self.style.SUCCESS('Successfully generated'))
def test_invalid_inputs(self): """ There are several errors that should be thrown from the master Maze class, if the inputs given are invalid. Let's just verify some of those. """ m = Maze() # should not be able to generate or solve if neither algorithm was set self.assertRaises(AssertionError, m.generate) self.assertRaises(AssertionError, m.solve) # even if the generator algorithm is set, you have to run it m.generator = Prims(3, 3) self.assertRaises(AssertionError, m.solve) # the pretty-print, sring formats should fail gracefully m.start = (1, 1) m.end = (3, 3) self.assertEqual(str(m), '') self.assertEqual(repr(m), '') # the Monte Carlo method has a special zero-to-one input scalar self.assertRaises(AssertionError, m.generate_monte_carlo, True, 3, -1.0) self.assertRaises(AssertionError, m.generate_monte_carlo, True, 3, 10.0)
def test_prims(self): m = Maze() m.generator = Prims(4, 5) m.generate() self.assertTrue(boundary_is_solid(m.grid)) self.assertTrue(all_passages_open(m.grid)) self.assertTrue(all_corners_complete(m.grid))
def test_prims(self): """ test the Prims method generates a reasonably sane maze """ m = Maze() m.generator = Prims(4, 5) m.generate() assert boundary_is_solid(m.grid) assert all_passages_open(m.grid) assert all_corners_complete(m.grid)
def test_set_seed(self): """ Test the Maze.set_seed staticmethod, to make sure we can control the random seeding """ m = Maze(123) m.generator = Prims(7, 7) m.generate() grid0 = str(m) m = Maze(123) m.generator = Prims(7, 7) m.generate() grid1 = str(m) assert grid0 == grid1 m.generator = Prims(7, 7) m.generate() grid2 = str(m) assert grid0 != grid2
def generate_data(self): results = [] for i in range(self.count): m = Maze() m.generator = Prims(20, 20) m.generate() m.generate_entrances() results.append(toHTML(m.grid, m.start, m.end, 25)) self.data = results return self.data
def testInnerEntrances(self): h = 4 w = 5 m = Maze() m.generator = Prims(h, w) m.generate() m.generate_entrances(False, False) self.assertFalse(self._on_edge(m.grid, m.start)) self.assertFalse(self._on_edge(m.grid, m.end))
def testOuterEntrances(self): h = 4 w = 5 m = Maze() m.generator = Prims(h, w) m.generate() m.generate_entrances() self.assertTrue(self._on_edge(m.grid, m.start)) self.assertTrue(self._on_edge(m.grid, m.end))
def test_outer_entrances(self): """ Test that the entrances can be correctly generated on the edges of the map """ h = 4 w = 5 m = Maze() m.generator = Prims(h, w) m.generate() m.generate_entrances() assert self._on_edge(m.grid, m.start) assert self._on_edge(m.grid, m.end)
def testGridSize(self): h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.generate() self.assertEqual(m.grid.height, H) self.assertEqual(m.grid.width, W)
def testGridSize(self): h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.generate() self.assertEqual(m.grid.shape[0], H) self.assertEqual(m.grid.shape[1], W)
def test_abstract_constructor(self): """ test the MazeGenAlgo constructor """ # example 1 of maze dimension definitions m = Maze() m.generator = Prims(3, 3) self.assertEqual(m.generator.h, 3) self.assertEqual(m.generator.w, 3) self.assertEqual(m.generator.H, 7) self.assertEqual(m.generator.W, 7) # example 2 of maze dimension definitions m.generator = Prims(24, 12) self.assertEqual(m.generator.h, 24) self.assertEqual(m.generator.w, 12) self.assertEqual(m.generator.H, 49) self.assertEqual(m.generator.W, 25) # ensure assertions are failed when invalid maze dimensions are provided self.assertRaises(AssertionError, Prims, 2, 2) self.assertRaises(AssertionError, Prims, 0, 2) self.assertRaises(AssertionError, Prims, -2, 3) self.assertRaises(AssertionError, Prims, 224, -2)
def testGeneratorWipe(self): h = 4 w = 5 m = Maze() m.generator = Prims(h, w) m.generate() m.generate_entrances() m.generate() self.assertTrue(m.start is None) self.assertTrue(m.end is None) self.assertTrue(m.solutions is None)
def test_grid_size(self): """ Test that the array representation for the maze is the exact size we want it to be """ h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.generate() assert m.grid.shape[0] == H assert m.grid.shape[1] == W
def test_abstract_constructor(self): """ test the MazeGenAlgo constructor """ # example 1 of maze dimension definitions m = Maze() m.generator = Prims(3, 3) assert m.generator.h == 3 assert m.generator.w == 3 assert m.generator.H == 7 assert m.generator.W == 7 # example 2 of maze dimension definitions m.generator = Prims(24, 12) assert m.generator.h == 24 assert m.generator.w == 12 assert m.generator.H == 49 assert m.generator.W == 25 # ensure assertions are failed when invalid maze dimensions are provided self.assertRaises(AssertionError, Prims, 2, 2) self.assertRaises(AssertionError, Prims, 0, 2) self.assertRaises(AssertionError, Prims, -2, 3) self.assertRaises(AssertionError, Prims, 224, -2)
def test_generator_wipe(self): """ Test that the running the master generate() method twice correctly wipes the entrances and solutions """ h = 4 w = 5 m = Maze() m.generator = Prims(h, w) m.generate() m.generate_entrances() m.generate() assert m.start is None assert m.end is None assert m.solutions is None
def test_cul_de_sac_filler(self): """ Test the CuldeSacFiller leaves the maze in a solvable state """ m = Maze() m.generator = Prims(3, 3) m.generate() m.grid = self._example_cul_de_sac_maze() assert m.grid[(1, 5)] == 0 m.transmuters = [CuldeSacFiller()] m.transmute() assert m.grid[(1, 5)] == 1 assert boundary_is_solid(m.grid) assert all_corners_complete(m.grid)
def test_cul_de_sac_filler(self): m = Maze() m.generator = Prims(3, 3) m.generate() m.grid = self._example_cul_de_sac_maze() assert m.grid[(1, 5)] == 0 m.transmuters = [CuldeSacFiller()] m.transmute() assert m.grid[(1, 5)] == 1 self.assertTrue(boundary_is_solid(m.grid)) self.assertTrue(all_corners_complete(m.grid))
def generate(self,method = ["dungeon"],rooms = None,width = None,height = None): if width is None: width = self.width if height is None: width = self.height width = width // 2 height = height // 2 if method == "dungeon": self.maze.generator = DungeonRooms(width,height, rooms=rooms) elif method == "prims": self.maze.generator = Prims(width,height) else: raise Exception(f"Maze generation method must be in {self.options}") self.maze.generate()
def labyrinthe(carte, case_init, case_fin): lab = Maze() lab.start = case_init lab.end = case_fin lab.generator = Prims(6, 6) lab.generate() n = random.randint(0, 1) for i in range(11): for j in range(11): if lab.grid[i + 1][j + 1] == 1: if n == 0: carte[i][j] = "eau" else: carte[i][j] = "lave" else: carte[i][j] = "herbe"
def create_maze_with_varied_entrances(start_outer=True, end_outer=True): """ create a maze with entrances inside/outside """ m = Maze() m.generator = Prims(4, 5) m.generate() if start_outer and end_outer: m.generate_entrances() elif not start_outer and not end_outer: m.generate_entrances(False, False) elif start_outer: m.generate_entrances(True, False) else: m.generate_entrances(False, True) return m
def testMonteCarlo(self): h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.solver = WallFollower() m.generate_monte_carlo(3) # grid size self.assertEqual(m.grid.height, H) self.assertEqual(m.grid.width, W) # test entrances are outer self.assertTrue(self._on_edge(m.grid, m.start)) self.assertTrue(self._on_edge(m.grid, m.end))
def testMonteCarlo(self): h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.solver = Collision() m.generate_monte_carlo(3) # grid size self.assertEqual(m.grid.shape[0], H) self.assertEqual(m.grid.shape[1], W) # test entrances are outer self.assertTrue(self._on_edge(m.grid, m.start)) self.assertTrue(self._on_edge(m.grid, m.end))
def testMonteCarloReducer(self): h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.solver = WallFollower() m.generate_monte_carlo(3, reducer=self._num_turns) # grid size self.assertEqual(m.grid.shape[0], H) self.assertEqual(m.grid.shape[1], W) # test entrances are outer self.assertTrue(self._on_edge(m.grid, m.start)) self.assertTrue(self._on_edge(m.grid, m.end))
def test_monte_carlo(self): """ Test that the basic Monte Carlo maze generator """ h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.solver = Collision() m.generate_monte_carlo(3) # grid size assert m.grid.shape[0] == H assert m.grid.shape[1] == W # test entrances are outer assert self._on_edge(m.grid, m.start) assert self._on_edge(m.grid, m.end)
def test_monte_carlo_reducer(self): """ Test that the reducer functionality on the Monte Carlo maze generator """ h = 4 w = 5 H = 2 * h + 1 W = 2 * w + 1 m = Maze() m.generator = Prims(h, w) m.solver = Collision() m.generate_monte_carlo(3, reducer=self._num_turns) # grid size assert m.grid.shape[0] == H assert m.grid.shape[1] == W # test entrances are outer assert self._on_edge(m.grid, m.start) assert self._on_edge(m.grid, m.end)
def test_dead_end_filler(self): m = Maze() m.generator = Prims(3, 3) m.generate() m.start = (1, 0) m.end = (5, 6) m.grid = self._example_cul_de_sac_maze() assert m.grid[(1, 5)] == 0 assert m.grid[(1, 2)] == 0 assert m.grid[(3, 3)] == 0 m.transmuters = [CuldeSacFiller(), DeadEndFiller(99)] m.transmute() assert m.grid[(1, 5)] == 1 assert m.grid[(1, 2)] == 1 assert m.grid[(3, 3)] == 1 self.assertTrue(boundary_is_solid(m.grid)) self.assertTrue(all_corners_complete(m.grid))
def test_dead_end_filler(self): """ Test the CuldeSacFiller and DeadEndFiller leave the maze in a solvable state """ m = Maze() m.generator = Prims(3, 3) m.generate() m.start = (1, 0) m.end = (5, 6) m.grid = self._example_cul_de_sac_maze() assert m.grid[(1, 5)] == 0 assert m.grid[(1, 2)] == 0 assert m.grid[(3, 3)] == 0 m.transmuters = [CuldeSacFiller(), DeadEndFiller(99)] m.transmute() assert m.grid[(1, 5)] == 1 assert m.grid[(1, 2)] == 1 assert m.grid[(3, 3)] == 1 assert boundary_is_solid(m.grid) assert all_corners_complete(m.grid)