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)