def test_player_move_to_mouse(self) -> None:
def normalize(pos: Tuple[float, float]) \
-> Tuple[float, float]:
x, y = pos
length = math.sqrt(x**2 + y**2)
if length == 0:
return (0.0, 0.0)
return (x / length, y / length)
player = make_player()
# test that the player moves in the same direction as mouse
possible_positions = [[0, 100, -100]] * 2
for x, y in product(*possible_positions):
player.pos = (0, 0)
player.motion.rot = 0
player.set_mouse_pos((x, y))
player.move_towards_mouse()
player.update()
# player direction
p_hat = normalize(player.pos)
# mouse direction
m_hat = normalize((x, y))
self.assertAlmostEqual(p_hat[0], m_hat[0], 8)
self.assertAlmostEqual(p_hat[1], m_hat[1], 8)
def test_add_weapons(self) -> None:
player = make_player()
shotgun = make_item('shotgun')
player.inventory.attempt_pickup(shotgun)
# nothing installed at arms location -> install shotgun
backpack = player.inventory.backpack
self.assertNotIn(shotgun.mod, backpack)
active_mods = player.inventory.active_mods
arm_mod = active_mods[mods.ModLocation.ARMS]
self.assertIs(arm_mod, shotgun.mod)
# adding a second arm mod goes into the backpack
pistol = make_item('pistol')
player.inventory.attempt_pickup(pistol)
self.assertIn(pistol.mod, backpack)
arm_mod = active_mods[mods.ModLocation.ARMS]
self.assertIs(arm_mod, shotgun.mod)
self.assertIn(pistol.mod, backpack)
# make sure we can swap the pistol with the shotgun
player.inventory.equip(pistol.mod)
arm_mod = active_mods[mods.ModLocation.ARMS]
self.assertEqual(arm_mod, pistol.mod)
self.assertIn(shotgun.mod, backpack)
def test_player_move(self) -> None:
player = make_player()
original_pos = Vector2(0, 0)
self.assertEqual(player.pos, original_pos)
player.translate_down()
player.translate_left()
player.update()
player.translate_down()
player.translate_left()
player.update()
speed = 56
expected = Vector2(-speed, speed)
self.assertEqual(player.pos, expected)
# velocity set to zero after each update
player.update()
self.assertEqual(player.pos, expected)
# up movement is twice as fast as other moves, so we only do it once.
player.translate_up()
player.translate_right()
player.update()
player.translate_right()
player.translate_up()
player.update()
self.assertEqual(player.pos, original_pos)
def test_player_turn(self) -> None:
player = make_player()
# start player at origin facing right
player.pos = (0, 0)
player.motion.rot = 0
# +x is to the right of player - no rotation
player.set_mouse_pos((100, 0))
player._rotate_towards_cursor()
self.assertAlmostEqual(player.motion.rot, 0, 1)
# -y is above player - faces top of screen
player.set_mouse_pos((0, -100))
player._rotate_towards_cursor()
self.assertAlmostEqual(player.motion.rot, 90, 1)
# +y is above below - faces bottom of screen
player.set_mouse_pos((0, 100))
player._rotate_towards_cursor()
self.assertAlmostEqual(player.motion.rot, 270, 1)
# -x is left of player
player.set_mouse_pos((-100, 0))
player._rotate_towards_cursor()
self.assertAlmostEqual(player.motion.rot, 180, 1)
def test_regenerate_player_energy_correct_amount(self) -> None:
player = make_player()
recharge_amount = 15
data = AbilityData(cool_down_time=300,
finite_uses=True,
uses_left=2,
recharge_amount=recharge_amount)
recharge = GenericAbility(data)
source = player.energy_source
starting_energy = source.max_energy
energy_expended = 20
source.expend_energy(energy_expended)
self.assertEqual(source.energy_available,
starting_energy - energy_expended)
recharge.use(player)
self.assertEqual(source.energy_available,
starting_energy - energy_expended + recharge_amount)
self.assertEqual(recharge.uses_left, 1)
recharge.use(player)
self.assertEqual(source.energy_available, starting_energy)
self.assertEqual(recharge.uses_left, 0)
def test_fireprojectile_use_ignores_can_use(self) -> None:
player = make_player()
fire_pistol = GenericAbility(self.projectile_ability_data)
self.assertEqual(len(self.groups.bullets), 0)
self.assertFalse(fire_pistol.can_use('dummy_arg'))
fire_pistol.use(player)
self.assertEqual(len(self.groups.bullets), 1)
def test_use_ability_at_empty_slot_no_effect(self) -> None:
player = make_player()
self.assertEqual(len(self.groups.all_sprites), 1)
arms_ability_caller = player.ability_caller(ModLocation.ARMS)
arms_ability_caller()
self.assertEqual(len(self.groups.all_sprites), 1)
def _player_with_ready_healthpack(self) -> Tuple[items.ItemObject, Player]:
player = make_player()
hp = make_item('healthpack')
player.inventory.attempt_pickup(hp)
while hp.mod.ability.cooldown_fraction < 1:
self.timer.current_time += 100
self.timer.current_time += 1
return hp, player
def _player_with_ready_laser(self) -> Tuple[items.ItemObject, Player]:
player = make_player()
laser_gun = make_item('laser')
player.inventory.attempt_pickup(laser_gun)
fire_ability = laser_gun.mod.ability
while fire_ability.cooldown_fraction < 1:
self.timer.current_time += 10
self.timer.current_time += 1
return laser_gun, player
def test_mob_move_to_player(self) -> None:
player = make_player()
mob = make_zombie(player)
initial_dist = _dist(player.pos, mob.pos)
mob.update()
final_dist = _dist(player.pos, mob.pos)
self.assertLess(final_dist, initial_dist)
def test_pickup_stackable_adds_to_active_mods(self) -> None:
player = make_player()
player.inventory.attempt_pickup(build_map_object('rock', player.pos))
self.assertFalse(player.inventory.backpack.slot_occupied(0))
player.inventory.attempt_pickup(build_map_object('rock', player.pos))
self.assertFalse(player.inventory.backpack.slot_occupied(0))
def test_fireprojectile_cannot_use_after_firing(self) -> None:
player = make_player()
fire_pistol = GenericAbility(self.projectile_ability_data)
self.timer.current_time += \
self.projectile_ability_data.cool_down_time + 1
self.assertTrue(fire_pistol.can_use('dummy_arg'))
fire_pistol.use(player)
self.assertFalse(fire_pistol.can_use('dummy_arg'))
def test_collide_hit_rect_with_rect(self) -> None:
player = make_player()
pos = player.pos
x = pos.x
y = pos.y
wall_sprite = Sprite([self.groups.walls])
wall_sprite.rect = Rect(x, y, 30, 30)
self.assertTrue(collide_hit_rect_with_rect(player, wall_sprite))
def test_fire_many_bullets(self) -> None:
player = make_player()
projectile_count = 15
ability_data = self.projectile_ability_data._replace(
projectile_count=projectile_count)
fire_many = GenericAbility(ability_data)
self.assertEqual(len(self.groups.bullets), 0)
fire_many.use(player)
self.assertEqual(len(self.groups.bullets), projectile_count)
def test_player_shoot_kickback(self) -> None:
player = make_player()
fire_pistol = GenericAbility(self.projectile_ability_data)
old_vel = (player.motion.vel.x, player.motion.vel.y)
fire_pistol.use(player)
new_vel = (player.motion.vel.x, player.motion.vel.y)
kickback = self.projectile_ability_data.kickback
expected_vel = (-kickback + old_vel[0], old_vel[1])
self.assertEqual(new_vel, expected_vel)
def test_humanoid_increment_health(self) -> None:
player = make_player()
max_health = player.status.max_health
player.status.increment_health(-1)
self.assertEqual(player.status.health, max_health - 1)
player.status.increment_health(100)
self.assertEqual(player.status.health, max_health)
player.status.increment_health(-max_health - 2)
self.assertEqual(player.status.health, 0)
self.assertTrue(player.status.is_dead)
def test_mouse_too_close(self) -> None:
# stop moving when you get close to the mouse
player = make_player()
player.pos = (0, 0)
player.motion.rot = 0
player.set_mouse_pos((1, 1))
player.move_towards_mouse()
player.update()
self.assertEqual(player.pos[0], 0)
self.assertEqual(player.pos[1], 0)
def test_heal_player_damaged_correct_amount(self) -> None:
player = make_player()
heal_amount = 10
data = AbilityData(cool_down_time=300,
finite_uses=True,
uses_left=3,
heal_amount=heal_amount)
heal = GenericAbility(data)
max_health = player.status.max_health
player.status.increment_health(-heal_amount - 2)
heal.use(player)
self.assertEqual(player.status.health, max_health - 2)
self.assertEqual(heal.uses_left, 2)
def test_y_wall_collisions(self) -> None:
player = make_player()
hit_rect = player.motion.hit_rect
wall_sprite = Sprite([self.groups.walls])
x = player.pos.x
y = player.pos.x + hit_rect.height / 2 + 1
wall_sprite.rect = Rect(x, y, 30, 30)
self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite))
player.motion.vel.y = 10
player.update()
self.assertFalse(collide_hit_rect_with_rect(player, wall_sprite))
self.assertEqual(player.motion.vel.y, 0)
def test_player_fire_laser_available_after_cooldown_time(self) -> None:
player = make_player()
laser_gun = make_item('laser')
player.inventory.attempt_pickup(laser_gun)
fire_ability = laser_gun.mod.ability
self.assertFalse(fire_ability.can_use(player))
# Initially player can't fire the gun because the cooldown time has
# not been waited.
while fire_ability.cooldown_fraction < 1:
self.timer.current_time += 1
self.assertFalse(fire_ability.can_use(player))
self.timer.current_time += 1
self.assertTrue(fire_ability.can_use(player))
def test_creation_of_usable_items_from_data(self) -> None:
player = make_player()
item_data = items.ItemData(**load_item_data_kwargs('pistol'))
pistol_ability = AbilityData(**load_ability_data_kwargs('pistol'))
pistol = items.ItemFromData(item_data, Vector2(0, 0))
player.inventory.attempt_pickup(pistol)
self.assertIs(pistol.mod, player.inventory.active_mods[pistol.mod.loc])
use_pistol = player.ability_caller(mods.ModLocation.ARMS)
self.timer.current_time += pistol_ability.cool_down_time + 1
use_pistol()
self.assertEqual(len(self.groups.bullets), 1)
def test_set_player_data(self) -> None:
ctrl = make_dungeon_controller()
player = make_player()
pos = Vector2(0, 0)
pistol = build_map_object('pistol', pos)
shotgun = build_map_object('shotgun', pos)
player.inventory.attempt_pickup(pistol)
player.inventory.attempt_pickup(
shotgun) # shotgun mod goes to slot 0 in backpack
player.status.increment_health(-10)
ctrl.set_player_data(player.data)
self.assertEqual(ctrl._dungeon.player.data, player.data)
def test_heal_player_not_damaged(self) -> None:
player = make_player()
heal_amount = 10
data = AbilityData(cool_down_time=300,
finite_uses=True,
uses_left=3,
heal_amount=heal_amount)
heal = GenericAbility(data)
max_health = player.status.max_health
self.assertEqual(player.status.health, max_health)
self.assertFalse(heal.can_use(player))
# use implements a heal anyway
heal.use(player)
self.assertEqual(player.status.health, max_health)
self.assertEqual(heal.uses_left, 2)
def test_backpack_full(self) -> None:
player = make_player()
pistol = make_item('pistol')
backpack = player.inventory.backpack
self.assertEqual(len(backpack), backpack.size)
# TODO (dvirk): You should not be able to add the same object to the
# backpack more than once.
for i in range(backpack.size + 1):
self.assertFalse(backpack.is_full)
player.inventory.attempt_pickup(pistol)
self.assertTrue(backpack.is_full)
# Item not gained since backpack full
player.inventory.attempt_pickup(pistol)
self.assertEqual(len(backpack), backpack.size)
def test_pickup_healthpacks(self) -> None:
player = make_player()
hp = make_item('healthpack')
backpack = player.inventory.backpack
player.inventory.attempt_pickup(hp)
# healthpack goes straight to active mods.
self.assertNotIn(hp.mod, backpack) # healthpack added to stack.
active_mods = player.inventory.active_mods
self.assertIn(hp.mod, active_mods.values())
self.assertEqual(active_mods[hp.mod.loc].ability.uses_left, 1)
hp_2 = make_item('healthpack')
player.inventory.attempt_pickup(hp_2)
self.assertNotIn(hp_2.mod, backpack)
self.assertEqual(active_mods[hp.mod.loc].ability.uses_left, 2)
def test_items_do_not_move_in_backpack_after_equip(self) -> None:
player = make_player()
pos = Vector2(0, 0)
shotgun = build_map_object('shotgun', pos)
inventory = player.inventory
inventory.attempt_pickup(build_map_object('pistol', pos))
inventory.attempt_pickup(
shotgun) # shotgun mod goes to slot 0 in backpack
inventory.attempt_pickup(build_map_object('healthpack', pos))
shotgun_2 = build_map_object('shotgun', pos)
inventory.attempt_pickup(shotgun_2)
self.assertIs(inventory.backpack[1], shotgun_2.mod)
inventory.equip(shotgun.mod)
self.assertIs(inventory.backpack[1], shotgun_2.mod)
def test_player_stop(self) -> None:
player = make_player()
original_pos = Vector2(0, 0)
self.assertEqual(player.pos, original_pos)
player.translate_down()
player.translate_left()
player.motion.stop_x()
player.update()
expected = Vector2(0, 28)
self.assertEqual(player.pos, expected)
player.translate_down()
player.translate_left()
player.motion.stop_y()
player.update()
expected = Vector2(-28, 28)
self.assertEqual(player.pos, expected)
def test_mod_stacking_in_active_mods(self) -> None:
player = make_player()
pos = Vector2(0, 0)
hp = build_map_object('healthpack', pos)
self.assertNotIn(hp.mod.loc, player.inventory.active_mods)
player.inventory.attempt_pickup(hp)
player_mod = player.inventory.active_mods[hp.mod.loc]
self.assertIs(player_mod, hp.mod)
self.assertEqual(player_mod.ability.uses_left, 1)
player.inventory.attempt_pickup(build_map_object('healthpack', pos))
player_mod = player.inventory.active_mods[hp.mod.loc]
self.assertEqual(player_mod.ability.uses_left, 2)
player.inventory.attempt_pickup(build_map_object('healthpack', pos))
player_mod = player.inventory.active_mods[hp.mod.loc]
self.assertEqual(player_mod.ability.uses_left, 3)
def test_mod_stacking_in_backpack(self) -> None:
player = make_player()
pos = Vector2(0, 0)
player.inventory.attempt_pickup(build_map_object('pistol', pos))
self.assertFalse(player.inventory.backpack.slot_occupied(0))
player.inventory.attempt_pickup(build_map_object('rock', pos))
self.assertTrue(player.inventory.backpack.slot_occupied(0))
self.assertEqual(player.inventory.backpack[0].ability.uses_left, 1)
player.inventory.attempt_pickup(build_map_object('rock', pos))
self.assertEqual(player.inventory.backpack[0].ability.uses_left, 2)
player.inventory.attempt_pickup(build_map_object('rock', pos))
self.assertEqual(player.inventory.backpack[0].ability.uses_left, 3)
player.inventory.attempt_pickup(build_map_object('rock', pos))
self.assertEqual(player.inventory.backpack[0].ability.uses_left, 4)
def test_pickup_several_items(self) -> None:
player = make_player()
pos = Vector2(0, 0)
laser_gun = build_map_object('laser', pos)
battery = build_map_object('battery', pos)
pistol = build_map_object('pistol', pos)
medpack = build_map_object('healthpack', pos)
player.inventory.attempt_pickup(laser_gun)
self.assertIs(laser_gun.mod,
player.inventory.active_mods[mods.ModLocation.ARMS])
player.inventory.attempt_pickup(battery)
self.assertIs(battery.mod,
player.inventory.active_mods[mods.ModLocation.CHEST])
player.inventory.attempt_pickup(pistol)
self.assertIn(pistol.mod, player.inventory.backpack)
self.assertTrue(player.inventory.backpack.slot_occupied(0))
player.inventory.attempt_pickup(medpack)
self.assertIn(medpack.mod, player.inventory.backpack)
self.assertTrue(player.inventory.backpack.slot_occupied(1))
