class Test_Player(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0, 1],
[0, 2, 0, 0]]
ctypes = [('Floor',), ('Wall',), ('SentryButton',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 1))
self.sentry = self.level.add_sprite('Sentry', (0, 0), 3)
# time to move 1 cell
self.playertime = 1000 / self.player.speed
self.sentrytime = 1000 / self.sentry.speed
def test_sentry_turns_when_button_triggered(self):
self.player.attempt_move(1)
self.level.update_level(self.playertime)
self.assertEqual(self.sentry.rotate, 1)
def test_sentry_moves_forward_when_possible(self):
self.sentry.rotate = 1
self.level.update_level(self.sentrytime)
self.assertEqual(self.sentry.pos, (1, 0))
self.level.update_level(self.sentrytime)
self.assertEqual(self.sentry.pos, (2, 0))
self.level.update_level(self.sentrytime)
self.assertEqual(self.sentry.pos, (2, 0)) # stopped by wall
def setUp(self):
cells = [[0, 0, 0, 1, 0], [0, 0, 0, 0, 0]]
ctypes = [("Floor",), ("Wall",)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite("Player", (1, 0))
self.level.add_sprite("Shooter", (0, 0), 1)
class Test_Toggle(unittest.TestCase):
def setUp(self):
cells = [[0, 1, 0]]
ctypes = [('Floor',), ('ToggleButton',)]
self.level = Level(MockDataFile(cells, ctypes))
self.toggle = self.level.add_sprite('Toggle', (2, 0), True)
def test_player_stepping_on_button_reverses_toggle(self):
self.assertTrue(self.toggle.is_solid)
player = self.level.add_sprite('Player', (0, 0))
player.attempt_move(1)
self.level.update_level(1000 / player.speed)
self.assertFalse(self.toggle.is_solid)
def setUp(self):
cells = [[0, 0, 1]]
ctypes = [('Floor',), ('Water',)]
self.level = Level(MockDataFile(cells, ctypes))
self.dirt = self.level.add_sprite('Dirt', (1, 0))
self.player = self.level.add_sprite('Player', (0, 0))
def setUp(self):
cells = [[1, 0, 0],
[1, 0, 0],
[1, 0, 0]]
ctypes = [('Floor',), ('Wall',)]
levelfile = MockDataFile(cells, ctypes)
config.animation = True
self.level = Level(levelfile)
self.sprite = self.level.add_sprite('Sprite', (1, 2))
self.celltime = 1000 / self.sprite.speed # time to move 1 cell
config.animation = False
self.level_noanim = Level(levelfile)
self.sprite_noanim = self.level_noanim.add_sprite('Sprite', (1, 2))
self.celltime_noanim = 1000 / self.sprite.speed # time to move 1 cell
def setUp(self):
cells = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.laser = self.level.add_sprite('Laser', (0, 1), 1)
def setUp(self):
cells = [[1, 1],
[1, 4]
]
ctypes = [('Water', 0), ('Water', 1), ('Water', 2), ('Water', 3), ('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.crate = self.level.add_sprite('Crate', (0, 0))
class Test_Movable(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 1, 0]]
ctypes = [('Floor',), ('Fire',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.movable = MockMovable(self.level, (1, 0))
self.level.sprites.add(self.movable)
self.celltime = 1000 / self.player.speed # time to move 1 cell
def test_movable_item_has_movable_attribute(self):
self.assertTrue(self.movable.is_movable)
def test_movable_item_moves_over_fire(self):
self.player.attempt_move(1)
self.level.update_level(self.celltime * 2)
self.assertEqual(self.movable.pos, (3, 0))
def test_movable_item_doesnt_move_over_fire_if_blocked(self):
self.level.add_sprite('Crate', (3, 0))
self.player.attempt_move(1)
self.level.update_level(self.celltime * 2)
self.assertEqual(self.movable.pos, (2, 0))
def setUp(self):
cells = [[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.keydoor = self.level.add_sprite('KeyDoor', (1, 0))
self.key = self.level.add_sprite('Key', (0, 0))
self.player.carrying.add(self.key)
def setUp(self):
self.level = Level(MockDataFile([], []))
self.player = self.level.add_sprite('Player', (0, 0))
self.rover = self.level.add_sprite('Rover', (1, 1))
self.crate = self.level.add_sprite('Crate', (0.1, 0.1))
self.crate2 = self.level.add_sprite('Crate', (1.75, 1.75))
self.sprites = self.level.sprites
def setUp(self):
cells = [[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.rover = self.level.add_sprite('Rover', (2, 0))
self.celltime = 1000 / self.player.speed # time to move 1 cell
def setUp(self):
cells = [[0, 0, 1, 0]]
ctypes = [('Floor',), ('Fire',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.movable = MockMovable(self.level, (1, 0))
self.level.sprites.add(self.movable)
self.celltime = 1000 / self.player.speed # time to move 1 cell
def setUp(self):
cells = [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.robot = self.level.add_sprite('Robot', (1, 1))
self.celltime = 1000 / self.robot.speed
class Test_KeyDoor(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.keydoor = self.level.add_sprite('KeyDoor', (1, 0))
self.key = self.level.add_sprite('Key', (0, 0))
self.player.carrying.add(self.key)
def test_keydoor_opens_when_player_walks_through_with_key(self):
self.player.attempt_move(1)
self.assertFalse(self.keydoor.is_solid)
def test_key_disappears_after_use(self):
self.player.attempt_move(1)
self.assertNotIn(self.key, self.level.sprites)
def test_keydoors_use_only_one_key_if_multiple_carried(self):
key2 = self.level.add_sprite('Key', (0, 0))
self.player.carrying.add(key2)
self.player.attempt_move(1)
self.assertEqual(len(self.player.carrying), 1)
def test_keydoors_use_correct_key_if_multiple_colours_carried(self):
key2 = self.level.add_sprite('Key', (0, 0), 1)
self.player.carrying.add(key2)
self.player.attempt_move(1)
self.assertItemsEqual(self.player.carrying, [key2])
def test_keydoor_doesnt_open_and_key_doesnt_disappear_if_colours_dont_match(self):
self.key.colour = 1
self.player.attempt_move(1)
self.assertTrue(self.keydoor.is_solid)
self.assertIn(self.key, self.level.sprites)
def setUp(self):
cells = [[0, 0, 0, 1],
[0, 2, 0, 0]]
ctypes = [('Floor',), ('Wall',), ('SentryButton',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 1))
self.sentry = self.level.add_sprite('Sentry', (0, 0), 3)
# time to move 1 cell
self.playertime = 1000 / self.player.speed
self.sentrytime = 1000 / self.sentry.speed
def setUp(self):
cells = [[1, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 0]
]
ctypes = [('Floor',),
('Grate',)
]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (1, 2))
self.crate = self.level.add_sprite('Crate', (1, 1))
def setUp(self):
cells = [[1, 1, 1],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
ctypes = [('Floor',), ('Wall',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 1))
self.crate = self.level.add_sprite('Crate', (1, 1))
self.celltime = 1000 / self.player.speed # time to move 1 cell
class Test_Crate(unittest.TestCase):
def setUp(self):
cells = [[1, 1],
[1, 4]
]
ctypes = [('Water', 0), ('Water', 1), ('Water', 2), ('Water', 3), ('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.crate = self.level.add_sprite('Crate', (0, 0))
def test_crate_moves_if_in_flowing_water_with_water_beyond(self):
self.crate.start_turn()
self.assertEqual(self.crate.to_move, 1)
def test_crate_moves_in_flow_direction(self):
self.crate.start_turn()
self.assertEqual(self.crate.move_dir, 1)
def test_crate_doesnt_move_if_non_water_cell_beyond(self):
self.crate.pos = (0, 1)
self.crate.start_turn()
self.assertEqual(self.crate.to_move, 0)
def test_crate_doesnt_move_if_level_edge_beyond(self):
self.crate.pos = (1, 0)
self.crate.start_turn()
self.assertEqual(self.crate.to_move, 0)
def test_player_can_enter_crate_cell_when_in_water(self):
self.assertFalse(self.level.player_can_enter((0, 0)))
self.crate.start_turn()
self.assertTrue(self.level.player_can_enter((0, 0)))
class Test_Rover(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 0))
self.rover = self.level.add_sprite('Rover', (2, 0))
self.celltime = 1000 / self.player.speed # time to move 1 cell
def test_rover_follows_player_after_player_moves_adjacent(self):
self.player.start_move(1)
self.level.update_level(self.celltime)
self.assertIn(self.rover, self.player.followers)
def test_rover_faces_toward_players_last_position(self):
self.player.pos = 1, 0
self.player.followers.add(self.rover)
self.player.start_move(3)
self.level.update_level(self.celltime)
self.assertEqual(self.rover.rotate, 3)
class Test_Player(unittest.TestCase):
def setUp(self):
cells = [[1, 1, 1],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
ctypes = [('Floor',), ('Wall',)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (0, 1))
self.crate = self.level.add_sprite('Crate', (1, 1))
self.celltime = 1000 / self.player.speed # time to move 1 cell
def test_player_enters_cells_with_movables(self):
self.player.attempt_move(1)
self.assertEqual(self.player.to_move, 1)
def test_player_pushes_movable_objects(self):
self.player.attempt_move(1)
self.assertIn(self.crate, self.player.pushing)
def test_player_moves_pushed_objects(self):
self.level.update_level(self.celltime, [('move', 1)])
self.assertEqual(self.crate.pos, (2, 1))
def test_player_doesnt_push_movable_with_solid_in_cell_behind(self):
self.level.add_sprite('Robot', (2, 1.5))
self.player.attempt_move(1)
self.assertEqual(self.player.to_move, 0)
def test_player_doesnt_push_movable_with_level_edge_behind(self):
self.level.add_sprite('Crate', (0, 0))
self.player.attempt_move(0)
self.assertEqual(self.player.to_move, 0)
def test_player_doesnt_push_without_passable_cell_behind_on_key_event(self):
self.level.add_sprite('Crate', (0, 0))
self.level.update_level(self.celltime, [('move', 0)])
self.assertEqual(self.player.pos, (0, 1))
def test_followers_move_when_player_moves(self):
self.player.followers.add(self.crate)
self.player.attempt_move(2)
self.assertEqual(self.crate.to_move, 1)
def test_followers_move_toward_players_last_position(self):
self.player.followers.add(self.crate)
self.player.attempt_move(2)
self.assertEqual(self.crate.move_dir, 3)
def test_player_picks_up_items_when_arriving_in_their_cell(self):
key = self.level.add_sprite('Key', (0, 2))
self.player.attempt_move(2)
self.level.update_level(self.celltime)
self.assertIn(key, self.player.carrying)
def test_carried_items_move_with_player(self):
key = self.level.add_sprite('Key', (0, 1))
self.player.carrying.add(key)
self.player.attempt_move(2)
self.level.update_level(self.celltime)
self.assertEqual(key.pos, (0, 2))
def test_player_starts_moving_after_move_event(self):
self.player.handle_action('move', 2)
self.player.start_turn()
self.assertEqual(self.player.to_move, 1)
def test_player_moves_after_move_event(self):
self.level.update_level(self.celltime, [('move', 2)])
self.assertEqual(self.player.pos, (0, 2))
def test_player_keeps_moving_until_key_released(self):
self.level.update_level(self.celltime, [('move', 2)])
self.level.update_level(self.celltime)
self.assertEqual(self.player.pos, (0, 3))
def test_player_stops_moving_when_key_released(self):
self.level.update_level(self.celltime, [('move', 2)])
self.level.update_level(self.celltime)
self.level.update_level(self.celltime, [('move', 2, False)])
self.assertEqual(self.player.pos, (0, 3))
def test_player_keeps_moving_in_1st_direction_when_2nd_key_pressed(self):
self.level.update_level(self.celltime, [('move', 2)])
self.level.update_level(self.celltime, [('move', 1)])
self.assertEqual(self.player.pos, (0, 3))
def test_player_starts_moving_in_2nd_direction_when_1st_key_released(self):
self.level.update_level(self.celltime, [('move', 2)])
self.level.update_level(self.celltime, [('move', 1)])
self.level.update_level(self.celltime, [('move', 2, False)])
self.assertEqual(self.player.pos, (1, 3))
class Test_Sprite(unittest.TestCase):
def setUp(self):
cells = [[1, 0, 0],
[1, 0, 0],
[1, 0, 0]]
ctypes = [('Floor',), ('Wall',)]
levelfile = MockDataFile(cells, ctypes)
config.animation = True
self.level = Level(levelfile)
self.sprite = self.level.add_sprite('Sprite', (1, 2))
self.celltime = 1000 / self.sprite.speed # time to move 1 cell
config.animation = False
self.level_noanim = Level(levelfile)
self.sprite_noanim = self.level_noanim.add_sprite('Sprite', (1, 2))
self.celltime_noanim = 1000 / self.sprite.speed # time to move 1 cell
def test_sprite_has_correct_pos(self):
self.assertEqual(self.sprite.pos, (1, 2))
def test_sprite_saves_move_distance(self):
self.sprite.start_move(1)
self.assertEqual(self.sprite.to_move, 1)
def test_sprite_saves_move_dir(self):
self.sprite.start_move(1)
self.assertEqual(self.sprite.move_dir, 1)
def test_sprite_subtracts_movement(self):
self.sprite.start_move(1)
self.sprite.do_move(self.celltime / 2)
self.assertEqual(self.sprite.to_move, 0.5)
def test_sprite_moves_correct_distance_and_direction(self):
self.sprite.start_move(1)
self.sprite.do_move(self.celltime / 2)
self.assertEqual(self.sprite.pos, (1.5, 2))
def test_sprite_moves_up_to_remaining(self):
self.sprite.to_move = 0.5
self.sprite.move_dir = 1
self.sprite.do_move(self.celltime)
self.assertEqual(self.sprite.pos, (1.5, 2))
def test_rotating_sprite_rotates_when_moving(self):
self.sprite.tile_rotates = True
self.sprite.start_move(1)
self.assertEqual(self.sprite.rotate, 1)
def test_non_rotating_sprite_doesnt_rotate_when_moving(self):
self.sprite.tile_rotates = False
self.sprite.start_move(1)
self.assertEqual(self.sprite.rotate, 0)
def test_non_animated_sprite_moves_full_square_immediately(self):
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(1)
self.assertEqual(self.sprite_noanim.pos, (1, 1))
def test_non_animated_sprite_waits_its_speed_before_moving(self):
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(self.celltime / 2)
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(self.celltime / 2)
self.assertEqual(self.sprite_noanim.pos, (1, 1))
def test_non_animated_sprite_moves_again_after_waiting(self):
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(self.celltime / 2)
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(self.celltime / 2 + 1)
self.assertEqual(self.sprite_noanim.pos, (1, 0))
def test_non_animated_sprite_moves_again_after_moving_and_waiting(self):
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(1)
self.sprite_noanim.do_move(self.celltime - 1)
self.sprite_noanim.start_move(0)
self.sprite_noanim.do_move(1)
self.assertEqual(self.sprite_noanim.pos, (1, 0))
class Test_Robot(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.robot = self.level.add_sprite('Robot', (1, 1))
self.celltime = 1000 / self.robot.speed
def test_robot_rotates_left_if_follow_dir_is_zero(self):
self.robot.start_turn()
self.assertEqual(self.robot.rotate, 3)
def test_robot_rotates_right_if_follow_dir_is_one(self):
self.robot.follow_dir = 1
self.robot.start_turn()
self.assertEqual(self.robot.rotate, 1)
def test_robot_move_dir_matches_rotate_dir(self):
self.robot.start_turn()
self.assertEqual(self.robot.move_dir, 3)
def test_robot_moves_if_unobstructed(self):
self.robot.start_turn()
self.assertEqual(self.robot.to_move, 1)
def test_robot_moves_straight_if_edge_in_follow_dir(self):
self.robot.pos = (0, 1)
self.robot.start_turn()
self.assertEqual(self.robot.move_dir, 0)
def test_robot_moves_straight_if_object_in_follow_dir(self):
self.level.add_sprite('Crate', (0, 1))
self.robot.start_turn()
self.assertEqual(self.robot.move_dir, 0)
def test_robot_rotates_opposite_way_if_obstructed_in_follow_dir_and_ahead(self):
self.level.add_sprite('Crate', (0, 1))
self.level.add_sprite('Crate', (1, 0))
self.robot.start_turn()
self.assertEqual(self.robot.move_dir, 1)
def test_robot_does_180_if_obstructed_ahead_and_on_both_sides(self):
self.robot.pos = (0, 0)
self.level.add_sprite('Crate', (1, 0))
self.robot.start_turn()
self.assertEqual(self.robot.move_dir, 2)
def test_robot_kills_player_on_entering_players_cell(self):
player = self.level.add_sprite('Player', (0, 1))
self.level.update_level(1)
self.assertNotIn(player, self.level.sprites)
class Test_Level(unittest.TestCase):
def setUp(self):
cells = [[1, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 0]
]
ctypes = [('Floor',),
('Grate',)
]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite('Player', (1, 2))
self.crate = self.level.add_sprite('Crate', (1, 1))
def test_level_has_correct_cell_types(self):
for (x, y), celltype in [((0, 0), 'Grate'),
((1, 1), 'Floor')
]:
self.assertEqual(self.level.cells[x, y].type, celltype)
def test_level_has_correct_sprite_types(self):
classes = [sprite.type for sprite in self.level.sprites]
self.assertItemsEqual(classes, ['Player', 'Crate'])
def test_level_returns_sprites_at_cell(self):
self.assertItemsEqual(self.level.sprites.at((1, 2)), [self.player])
self.assertItemsEqual(self.level.sprites.at((1, 1)), [self.crate])
self.assertItemsEqual(self.level.sprites.at((1, 0)), [])
def test_level_returns_sprites_partially_in_cell(self):
crate = self.level.add_sprite('Crate', (2.5, 2))
self.assertItemsEqual(self.level.sprites.on((2, 1)), [])
self.assertItemsEqual(self.level.sprites.on((2, 2)), [crate])
self.assertItemsEqual(self.level.sprites.on((3, 2)), [crate])
def test_level_returns_sprites_by_type(self):
self.assertItemsEqual(self.level.sprites['Player'], [self.player])
self.assertItemsEqual(self.level.sprites['Crate'], [self.crate])
self.assertItemsEqual(self.level.sprites['Random'], [])
def test_sprites_cant_enter_cells_out_of_bounds(self):
self.assertTrue(self.level.sprite_can_enter((0, 0)))
self.assertTrue(self.level.sprite_can_enter((3, 2)))
self.assertFalse(self.level.sprite_can_enter((0, 3)))
self.assertFalse(self.level.sprite_can_enter((-1, -1)))
def test_sprites_cant_enter_cells_with_movables(self):
self.assertFalse(self.level.sprite_can_enter((1, 1)))
def test_robots_cant_enter_no_robot_cells_even_if_empty(self):
self.assertFalse(self.level.enemy_can_enter((1, 0)))
def test_player_can_enter_cells_with_movables(self):
self.assertTrue(self.level.player_can_enter((1, 1)))
def test_player_cant_enter_cells_with_robot(self):
self.level.add_sprite('Robot', (2.5, 2))
self.assertFalse(self.level.player_can_enter((2, 2)))
def test_player_can_enter_cells_with_rover(self):
self.level.add_sprite('Rover', (2.5, 2))
self.assertTrue(self.level.player_can_enter((2, 2)))
class Test_SpriteGroup(unittest.TestCase):
def setUp(self):
self.level = Level(MockDataFile([], []))
self.player = self.level.add_sprite('Player', (0, 0))
self.rover = self.level.add_sprite('Rover', (1, 1))
self.crate = self.level.add_sprite('Crate', (0.1, 0.1))
self.crate2 = self.level.add_sprite('Crate', (1.75, 1.75))
self.sprites = self.level.sprites
def test_flag_attribute_returns_sprites_for_which_flag_is_true(self):
self.assertItemsEqual(self.sprites.solid, [self.rover, self.crate, self.crate2])
def test_not_flag_attribute_returns_sprites_for_which_flag_is_false(self):
self.assertItemsEqual(self.sprites.not_solid, [self.player])
def test_get_item_syntax_returns_sprites_by_type(self):
self.assertItemsEqual(self.sprites['Crate'], [self.crate, self.crate2])
self.assertItemsEqual(self.sprites['Rover', 'Player'], [self.rover, self.player])
def test_get_item_syntax_returns_sprites_by_mixin(self):
keydoor = self.level.add_sprite('KeyDoor', (0, 0))
chipdoor = self.level.add_sprite('ChipDoor', (0, 0))
self.assertItemsEqual(self.sprites['Door'], [keydoor, chipdoor])
def test_get_item_syntax_doesnt_filter_if_passed_none(self):
self.assertItemsEqual(self.sprites[None], self.sprites)
def test_methods_can_be_chained(self):
self.assertItemsEqual(self.sprites['Player', 'Rover'].solid, [self.rover])
self.assertItemsEqual(self.sprites.solid['Player', 'Rover'], [self.rover])
def test_at_method_filters_sprites_by_position(self):
self.assertItemsEqual(self.sprites.at((1, 1)), [self.rover])
def test_at_method_filters_by_multiple_positions(self):
self.assertItemsEqual(self.sprites.at((0, 0), (1.75, 1.75)), [self.player, self.crate2])
def test_on_method_filters_sprites_by_overlapping_position(self):
self.assertItemsEqual(self.sprites.on((1, 1)), [self.rover, self.crate, self.crate2])
def test_on_method_filters_by_multiple_positions(self):
self.assertItemsEqual(self.sprites.on((0.5, -0.5), (0.5, 1.5)),
[self.player, self.crate, self.rover])
def test_group_returns_list_sorted_by_decreasing_priority(self):
self.rover.priority = 2
self.crate2.priority = -1
self.assertEqual(self.sprites.by_priority(),
[self.rover, self.player, self.crate, self.crate2])
def test_sprite_subgroup_returns_only_sprites_in_parent(self):
subgroup = self.sprites.subset([self.player, self.rover])
self.sprites.discard(self.rover)
self.assertItemsEqual(subgroup, [self.player])
self.assertNotIn(self.rover, subgroup)
def setUp(self):
cells = [[0, 1, 0]]
ctypes = [('Floor',), ('ToggleButton',)]
self.level = Level(MockDataFile(cells, ctypes))
self.toggle = self.level.add_sprite('Toggle', (2, 0), True)
def __init__(self, levelfile):
Level.__init__(self, levelfile)
# set the # of chips required to pass, defaulting to # of chips in level
self.chipquota = levelfile.properties.get('chipquota', len(self.sprites['Chip']))
class Test_Laser(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
ctypes = [('Floor',)]
self.level = Level(MockDataFile(cells, ctypes))
self.laser = self.level.add_sprite('Laser', (0, 1), 1)
def test_laser_creates_laserbeams(self):
self.level.update_level()
self.assertItemsEqual([beam.pos for beam in self.level.sprites['Laserbeam']],
[(1, 1), (2, 1), (3, 1)])
def test_solid_object_blocks_laserbeams(self):
self.level.add_sprite('Crate', (2, 1), 2)
self.level.update_level()
self.assertItemsEqual([beam.pos for beam in self.level.sprites['Laserbeam']],
[(1, 1)])
def test_mirror_bounces_laserbeams(self):
self.level.add_sprite('Mirror', (2, 1), 2)
self.level.update_level()
self.assertItemsEqual([beam.pos for beam in self.level.sprites['Laserbeam']],
[(1, 1), (2, 1), (2, 2)])
def test_laserbeam_kills_destructible_sprites(self):
player = self.level.add_sprite('Player', (1, 1))
rover = self.level.add_sprite('Rover', (2, 1))
robot = self.level.add_sprite('Robot', (3, 1))
self.level.update_level()
self.assertNotIn(player, self.level.sprites)
self.assertNotIn(rover, self.level.sprites)
self.assertNotIn(robot, self.level.sprites)
class Test_Shooter(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 0, 1, 0], [0, 0, 0, 0, 0]]
ctypes = [("Floor",), ("Wall",)]
self.level = Level(MockDataFile(cells, ctypes))
self.player = self.level.add_sprite("Player", (1, 0))
self.level.add_sprite("Shooter", (0, 0), 1)
def test_shooter_kills_player_in_front(self):
self.level.update_level()
self.assertNotIn(self.player, self.level.sprites)
def test_shooter_kills_rover_in_front(self):
self.player.pos = (2, 0)
rover = self.level.add_sprite("Rover", (1, 0))
self.level.update_level()
self.assertNotIn(rover, self.level.sprites)
def test_shooter_kills_player_farther_in_front(self):
self.player.pos = (2, 0)
self.level.update_level()
self.assertNotIn(self.player, self.level.sprites)
def test_shooter_doesnt_kill_player_beside(self):
self.player.pos = (0, 1)
self.level.update_level()
self.assertIn(self.player, self.level.sprites)
def test_shooter_doesnt_kill_player_behind_wall(self):
self.player.pos = (4, 0)
self.level.update_level()
self.assertIn(self.player, self.level.sprites)
def test_shooter_doesnt_kill_player_behind_crate(self):
self.player.pos = (2, 0)
self.level.add_sprite("Crate", (1, 0))
self.level.update_level()
self.assertIn(self.player, self.level.sprites)
class Test_Dirt(unittest.TestCase):
def setUp(self):
cells = [[0, 0, 1]]
ctypes = [('Floor',), ('Water',)]
self.level = Level(MockDataFile(cells, ctypes))
self.dirt = self.level.add_sprite('Dirt', (1, 0))
self.player = self.level.add_sprite('Player', (0, 0))
def test_dirt_becomes_bridge_when_in_water(self):
self.assertFalse(self.dirt.is_bridge)
self.dirt.pos = 2, 0
self.level.update_level()
self.assertTrue(self.dirt.is_bridge)
def test_dirt_doesnt_become_bridge_when_bridge_already_in_water(self):
self.level.add_sprite('Dirt', (2, 0))
self.level.update_level()
self.dirt.pos = 2, 0
self.level.update_level()
self.assertFalse(self.dirt.is_bridge)
def test_dirt_no_longer_solid_once_player_has_walked_on_it(self):
self.dirt.pos = 2, 0
self.level.update_level()
self.assertTrue(self.dirt.is_solid)
self.player.pos = 2, 0
self.level.update_level()
self.assertFalse(self.dirt.is_solid)
