def test_not_enough_score_space(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
grid = self._generate_grid(1)
grid = [[MockCell(avatar='avatar')]]
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.score_cells())), 0)
def test_not_enough_pickup_space(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid(1)
grid = [[MockCell(avatar='avatar')]]
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.pickup_cells())), 0)
def test_pickup_spawn_chance(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 5
world_map.PICKUP_SPAWN_CHANCE = 0
grid = self._generate_grid()
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.pickup_cells())), 0)
def test_scores_removed(self):
world_map.SCORE_DESPAWN_CHANCE = 1
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.score_cells())), 0)
def test_no_score_cells_generated_if_no_suitable_cells(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
grid = self._generate_grid(1, 1)
grid[Location(0, 0)].avatar = 'avatar'
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.score_cells())), 0)
def test_scores_removed(self):
self.settings['SCORE_DESPAWN_CHANCE'] = 1
grid = self._generate_grid()
grid[Location(0, 1)].generates_score = True
world_map = WorldMap(grid, self.settings)
world_map.update(1)
self.assertEqual(len(list(world_map.score_cells())), 0)
def test_get_valid_cell(self):
world_map = WorldMap(self._generate_grid(), self.settings)
for x in (0, 1):
for y in (0, 1):
location = Location(x, y)
self.assertEqual(
world_map.get_cell(location).location, location)
def test_not_enough_score_space(self):
self.settings['TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR'] = 1
grid = self._generate_grid(1, 1)
grid[Location(0, 0)].avatar = 'avatar'
world_map = WorldMap(grid, self.settings)
world_map.update(1)
self.assertEqual(len(list(world_map.score_cells())), 0)
def test_pickup_cells(self):
cells = self._generate_cells()
cells[0]['pickup'] = {'health_restored': 5}
cells[8]['pickup'] = {'health_restored': 2}
map = WorldMap(cells)
self.assertLocationsEqual(map.pickup_cells(),
(Location(-1, -1), Location(1, 1)))
def test_score_cells(self):
cells = self._generate_cells()
cells[0]['generates_score'] = True
cells[5]['generates_score'] = True
map = WorldMap(cells)
self.assertLocationsEqual(map.score_cells(),
(Location(-1, -1), Location(0, 1)))
def test_pickup_spawn_chance(self):
self.settings['TARGET_NUM_PICKUPS_PER_AVATAR'] = 5
self.settings['PICKUP_SPAWN_CHANCE'] = 0
grid = self._generate_grid()
world_map = WorldMap(grid, self.settings)
world_map.update(1)
self.assertEqual(len(list(world_map.pickup_cells())), 0)
def test_scores_removed(self):
world_map.SCORE_DESPAWN_CHANCE = 1
grid = self._generate_grid()
grid[Location(0, 1)].generates_score = True
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.score_cells())), 0)
def test_not_enough_pickup_space(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid(1)
grid = [[MockCell(avatar='avatar')]]
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.pickup_cells())), 0)
def test_scores_removed(self):
world_map.SCORE_DESPAWN_CHANCE = 1
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.score_cells())), 0)
def test_get_y_off_map(self):
map = WorldMap(self._generate_grid())
for x in (0, 1):
with self.assertRaises(ValueError):
map.get_cell(Location(x, -1))
with self.assertRaises(ValueError):
map.get_cell(Location(x, 2))
def test_get_x_off_map(self):
map = WorldMap(self._generate_grid())
for y in (0, 1):
with self.assertRaises(ValueError):
map.get_cell(Location(-1, y))
with self.assertRaises(ValueError):
map.get_cell(Location(2, y))
def test_not_enough_pickup_space(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid(1, 1)
grid[Location(0, 0)].generates_score = True
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.pickup_cells())), 0)
def test_interactable_cells(self):
cells = self._generate_cells()
cells[0]["interactable"] = {"type": "health"}
cells[8]["interactable"] = {"type": "damage_boost"}
map = WorldMap(cells)
self.assertLocationsEqual(map.interactable_cells(),
(Location(-1, -1), Location(1, 1)))
def test_score_cells(self):
cells = self._generate_cells()
cells[0]["interactable"] = {"type": "score"}
cells[8]["interactable"] = {"type": "score"}
map = WorldMap(cells)
self.assertLocationsEqual(map.score_cells(),
(Location(-1, -1), Location(1, 1)))
def test_pickups_not_added_when_at_target(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid()
grid[Location(0, 1)].pickup = MockPickup()
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.pickup_cells())), 1)
self.assertIn(grid[Location(0, 1)], map.pickup_cells())
def test_pickups_not_added_when_at_target(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid()
grid[0][1].pickup = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.pickup_cells())), 1)
self.assertIn(grid[0][1], map.pickup_cells())
def test_scores_not_added_when_at_target(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.score_cells())), 1)
self.assertIn(grid[0][1], map.score_cells())
def test_score_despawn_chance(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 0
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertIn(grid[0][1], map.score_cells())
self.assertEqual(len(list(map.score_cells())), 1)
def test_grid_expand(self):
world_map.TARGET_NUM_CELLS_PER_AVATAR = 5
map = WorldMap(self._generate_grid())
map.reconstruct_interactive_state(1)
self.assertGridSize(map, 3)
map.reconstruct_interactive_state(2)
self.assertGridSize(map, 4)
def test_interactable_cells(self):
cells = self._generate_cells()
cells[0]["interactable"] = {"health_restored": 5}
cells[8]["interactable"] = {"health_restored": 2}
map = WorldMap(cells)
self.assertLocationsEqual(
map.interactable_cells(), (Location(-1, -1), Location(1, 1))
)
def test_scores_not_added_when_at_target(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.score_cells())), 1)
self.assertIn(grid[0][1], map.score_cells())
def test_pickups_not_added_when_at_target(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
grid = self._generate_grid()
grid[0][1].pickup = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertEqual(len(list(map.pickup_cells())), 1)
self.assertIn(grid[0][1], map.pickup_cells())
def test_all_cells(self):
world_map = WorldMap(self._generate_grid(), self.settings)
cell_names = [c.name for c in world_map.all_cells()]
self.assertIn("A", cell_names)
self.assertIn("B", cell_names)
self.assertIn("C", cell_names)
self.assertIn("D", cell_names)
self.assertEqual(len(cell_names), 4)
def test_score_despawn_chance(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 0
grid = self._generate_grid()
grid[0][1].generates_score = True
map = WorldMap(grid)
map.reconstruct_interactive_state(1)
self.assertIn(grid[0][1], map.score_cells())
self.assertEqual(len(list(map.score_cells())), 1)
def test_grid_expand(self):
world_map.TARGET_NUM_CELLS_PER_AVATAR = 5
map = WorldMap(self._generate_grid())
map.update(1)
self.assertGridSize(map, 3)
map.update(2)
self.assertGridSize(map, 4)
def test_location_on_map(self):
world_map = WorldMap(self._generate_grid(), self.settings)
for x in (0, 1):
for y in (0, 1):
self.assertTrue(world_map.is_on_map(Location(x, y)))
self.assertFalse(world_map.is_on_map(Location(2, 2)))
self.assertFalse(world_map.is_on_map(Location(-1, 1)))
def test_score_despawn_chance(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 0
grid = self._generate_grid()
grid[Location(0, 1)].generates_score = True
map = WorldMap(grid)
map.update(1)
self.assertIn(grid[Location(0, 1)], map.score_cells())
self.assertEqual(len(list(map.score_cells())), 1)
def test_all_cells(self):
map = WorldMap(self._generate_grid())
cell_names = [c.name for c in map.all_cells()]
self.assertIn('A', cell_names)
self.assertIn('B', cell_names)
self.assertIn('C', cell_names)
self.assertIn('D', cell_names)
self.assertEqual(len(cell_names), 4)
def test_scores_not_added_when_at_target(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
grid = self._generate_grid()
grid[Location(0, 1)].generates_score = True
map = WorldMap(grid)
map.update(1)
self.assertEqual(len(list(map.score_cells())), 1)
self.assertIn(grid[Location(0, 1)], map.score_cells())
def test_pickup_cells(self):
pickup_cell1 = MockCell(pickup=MockPickup())
pickup_cell2 = MockCell(pickup=MockPickup())
no_pickup_cell = MockCell()
grid = self._grid_from_list([[pickup_cell1, no_pickup_cell], [no_pickup_cell, pickup_cell2]])
map = WorldMap(grid)
cells = list(map.pickup_cells())
self.assertIn(pickup_cell1, cells)
self.assertIn(pickup_cell2, cells)
self.assertEqual(len(cells), 2, "Non-pickup cells present")
def test_score_cells(self):
score_cell1 = MockCell(generates_score=True)
score_cell2 = MockCell(generates_score=True)
no_score_cell = MockCell()
grid = self._grid_from_list([[score_cell1, no_score_cell], [no_score_cell, score_cell2]])
map = WorldMap(grid)
cells = list(map.score_cells())
self.assertIn(score_cell1, cells)
self.assertIn(score_cell2, cells)
self.assertEqual(len(cells), 2, "Non-scoring cells present")
def test_get_all_pickup_locations(self):
pickup_cell = MockCell()
pickup_cell.interactable = HealthPickup(pickup_cell)
grid = self._grid_from_list([[pickup_cell, MockCell()],
[MockCell(), MockCell()]])
world_map = WorldMap(grid, self.settings)
pickup_list = list(world_map.pickup_cells())
self.assertEqual(len(pickup_list), 1)
self.assertTrue(isinstance(pickup_list[0].interactable, ALL_PICKUPS))
def test_get_all_score_locations(self):
score_cell = MockCell()
score_cell.interactable = ScoreLocation(score_cell)
grid = self._grid_from_list([[score_cell, MockCell()],
[MockCell(), MockCell()]])
world_map = WorldMap(grid, self.settings)
score_list = list(world_map.score_cells())
self.assertEqual(len(score_list), 1)
self.assertTrue(isinstance(score_list[0].interactable, ScoreLocation))
def test_pickup_cells(self):
pickup_cell1 = MockCell(pickup='pickup1')
pickup_cell2 = MockCell(pickup='pickup')
no_pickup_cell = MockCell()
grid = [[pickup_cell1, no_pickup_cell], [no_pickup_cell, pickup_cell2]]
map = WorldMap(grid)
cells = list(map.pickup_cells())
self.assertIn(pickup_cell1, cells)
self.assertIn(pickup_cell2, cells)
self.assertEqual(len(cells), 2, "Non-pickup cells present")
def test_pickup_cells(self):
pickup_cell1 = MockCell(pickup='pickup1')
pickup_cell2 = MockCell(pickup='pickup')
no_pickup_cell = MockCell()
grid = [[pickup_cell1, no_pickup_cell], [no_pickup_cell, pickup_cell2]]
map = WorldMap(grid)
cells = list(map.pickup_cells())
self.assertIn(pickup_cell1, cells)
self.assertIn(pickup_cell2, cells)
self.assertEqual(len(cells), 2, "Non-pickup cells present")
def test_interactable_cells(self):
pickup_cell1 = MockCell(interactable=MockPickup())
pickup_cell2 = MockCell(interactable=MockPickup())
no_pickup_cell = MockCell()
grid = self._grid_from_list([[pickup_cell1, no_pickup_cell],
[no_pickup_cell, pickup_cell2]])
world_map = WorldMap(grid, self.settings)
cells = list(world_map.interactable_cells())
self.assertIn(pickup_cell1, cells)
self.assertIn(pickup_cell2, cells)
self.assertEqual(len(cells), 2, "Non-pickup cells present")
def test_score_cells(self):
score_cell1 = MockCell()
score_cell1.interactable = ScoreLocation(score_cell1)
score_cell2 = MockCell()
score_cell2.interactable = ScoreLocation(score_cell2)
no_score_cell = MockCell()
grid = self._grid_from_list([[score_cell1, no_score_cell],
[no_score_cell, score_cell2]])
world_map = WorldMap(grid, self.settings)
cells = list(world_map.score_cells())
self.assertIn(score_cell1, cells)
self.assertIn(score_cell2, cells)
self.assertEqual(len(cells), 2, "Non-scoring cells present")
def test_scores_added(self):
world_map.TARGET_NUM_SCORE_LOCATIONS_PER_AVATAR = 1
map = WorldMap(self._generate_grid())
map.update(1)
self.assertEqual(len(list(map.score_cells())), 1)
map.update(2)
self.assertEqual(len(list(map.score_cells())), 2)
def test_potential_spawns(self):
spawnable1 = MockCell()
spawnable2 = MockCell()
score_cell = MockCell(generates_score=True)
unhabitable = MockCell(habitable=False)
filled = MockCell(avatar='avatar')
grid = self._grid_from_list([[spawnable1, score_cell, unhabitable], [unhabitable, spawnable2, filled]])
map = WorldMap(grid)
cells = list(map.potential_spawn_locations())
self.assertIn(spawnable1, cells)
self.assertIn(spawnable2, cells)
self.assertNotIn(score_cell, cells, "Score cells should not be spawns")
self.assertNotIn(unhabitable, cells, "Unhabitable cells should not be spawns")
self.assertNotIn(filled, cells, "Cells with avatars should not be spawns")
self.assertEqual(len(cells), 2)
def test_out_of_bounds_random_edge(self):
map = WorldMap.generate_empty_map(3, 4, {})
with self.assertRaisesRegexp(ValueError, 'Beyond range'):
get_random_edge_index(map, rng=ConstantRng(-1))
with self.assertRaisesRegexp(ValueError, 'Beyond range'):
get_random_edge_index(map, rng=ConstantRng(6))
def test_pickups_added(self):
world_map.TARGET_NUM_PICKUPS_PER_AVATAR = 1
world_map.PICKUP_SPAWN_CHANCE = 1
map = WorldMap(self._generate_grid())
map.update(1)
self.assertEqual(len(list(map.pickup_cells())), 1)
map.update(2)
self.assertEqual(len(list(map.pickup_cells())), 2)
def test_get_random_edge_index_can_give_all_possible(self):
map = WorldMap.generate_empty_map(3, 4, {})
get_random_edge_index(map, rng=ConstantRng(1))
expected = frozenset((
(0, 1), (1, 1),
(-1, 0), (2, 0),
(0, -1), (1, -1),
))
actual = frozenset(get_random_edge_index(map, rng=ConstantRng(i))
for i in xrange(6))
self.assertEqual(expected, actual)
def generate_map(height, width, obstacle_ratio=0.1):
world_map = WorldMap.generate_empty_map(height, width)
# We designate one non-corner edge cell as empty, to ensure that the map can be expanded
always_empty_edge_x, always_empty_edge_y = get_random_edge_index(world_map)
always_empty_location = Location(always_empty_edge_x, always_empty_edge_y)
for cell in shuffled(world_map.all_cells()):
if cell.location != always_empty_location and random.random() < obstacle_ratio:
cell.habitable = False
# So long as all habitable neighbours can still reach each other,
# then the map cannot get bisected
if not _all_habitable_neighbours_can_reach_each_other(cell, world_map):
cell.habitable = True
return world_map
def get_map(self):
height = self.settings['START_HEIGHT']
width = self.settings['START_WIDTH']
world_map = WorldMap.generate_empty_map(height, width, self.settings)
# We designate one non-corner edge cell as empty, to ensure that the map can be expanded
always_empty_edge_x, always_empty_edge_y = get_random_edge_index(world_map)
always_empty_location = Location(always_empty_edge_x, always_empty_edge_y)
for cell in shuffled(world_map.all_cells()):
if cell.location != always_empty_location and random.random() < self.settings['OBSTACLE_RATIO']:
cell.habitable = False
# So long as all habitable neighbours can still reach each other,
# then the map cannot get bisected
if not _all_habitable_neighbours_can_reach_each_other(cell, world_map):
cell.habitable = True
return world_map
def test_get_random_edge_index(self):
map = WorldMap.generate_empty_map(3, 4, {})
self.assertEqual(
(0, -1), get_random_edge_index(map, rng=ConstantRng(0)))
self.assertEqual(
(1, -1), get_random_edge_index(map, rng=ConstantRng(1)))
self.assertEqual(
(0, 1), get_random_edge_index(map, rng=ConstantRng(2)))
self.assertEqual(
(1, 1), get_random_edge_index(map, rng=ConstantRng(3)))
self.assertEqual(
(-1, 0), get_random_edge_index(map, rng=ConstantRng(4)))
self.assertEqual(
(2, 0), get_random_edge_index(map, rng=ConstantRng(5)))
# Verify no out of bounds
with self.assertRaisesRegexp(ValueError, 'Beyond range'):
get_random_edge_index(map, rng=ConstantRng(-1))
with self.assertRaisesRegexp(ValueError, 'Beyond range'):
get_random_edge_index(map, rng=ConstantRng(6))
def test_retrieve_negative(self):
map = WorldMap(self._generate_grid(3, 3))
self.assertTrue(map.is_on_map(Location(-1, -1)))
