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_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_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_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_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_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_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_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_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_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_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_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_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=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")