def test_attacked(self):
attacked_entity = random_movable_entity()
attacker_entity = random_movable_entity()
damage = rd.randint(attacked_entity.hp // 2, attacked_entity.hp)
hp_left = attacked_entity.attacked(attacker_entity, damage,
DamageKind['PHYSICAL'], [])
self.assertEqual(hp_left, attacked_entity.hp)
hp_expected = attacked_entity.hp_max - damage + attacked_entity.defense \
if hp_left < attacked_entity.hp_max \
else attacked_entity.hp_max
self.assertEqual(hp_expected, hp_left)
def test_alteration_boost_defense(self):
attacked_entity = random_movable_entity()
attacker_entity = random_movable_entity()
damage = rd.randint(attacked_entity.hp // 2, attacked_entity.hp)
boost_alteration = random_alteration(name="defense_up",
effects=["defense_up"])
attacked_entity.set_alteration(boost_alteration)
hp_left = attacked_entity.attacked(attacker_entity, damage,
DamageKind['PHYSICAL'], [])
self.assertEqual(hp_left, attacked_entity.hp)
hp_expected = attacked_entity.hp_max - damage + attacked_entity.defense + boost_alteration.power \
if hp_left < attacked_entity.hp_max \
else attacked_entity.hp_max
self.assertEqual(hp_expected, hp_left)
def test_different_alterations(self):
movable_entity = random_movable_entity()
alteration = random_alteration(name="alt_test")
alteration_bis = random_alteration(name="alt_test_bis")
self.assertEqual(0, len(movable_entity.alterations))
self.assertEqual(
0, len(movable_entity.get_alterations_effect('alt_test')))
self.assertEqual(
0, len(movable_entity.get_alterations_effect('alt_test_bis')))
movable_entity.set_alteration(alteration)
self.assertEqual(
1, len(movable_entity.get_alterations_effect('alt_test')))
self.assertEqual(
0, len(movable_entity.get_alterations_effect('alt_test_bis')))
movable_entity.set_alteration(alteration_bis)
self.assertEqual(
1, len(movable_entity.get_alterations_effect('alt_test')))
self.assertEqual(
1, len(movable_entity.get_alterations_effect('alt_test_bis')))
# Test formatted alterations rendering
self.assertEqual(f"{alteration}, {alteration_bis}",
movable_entity.get_formatted_alterations())
self.assertEqual(
f"{alteration.abbreviated_name}, {alteration_bis.abbreviated_name}",
movable_entity.get_abbreviated_alterations())
def test_earn_xp(self):
movable_entity = random_movable_entity()
old_lvl = movable_entity.lvl
earned_xp = rd.randint(1, movable_entity.xp_next_lvl - 1)
self.assertEqual(0, movable_entity.xp)
self.assertFalse(movable_entity.earn_xp(earned_xp))
self.assertEqual(old_lvl, movable_entity.lvl)
self.assertEqual(earned_xp, movable_entity.xp)
def test_remove_item(self):
movable_entity = random_movable_entity()
item = random_item()
self.assertTrue(movable_entity.has_free_space())
self.assertEqual(0, len(movable_entity.items))
self.assertTrue(movable_entity.set_item(item))
self.assertEqual(item, movable_entity.remove_item(item))
self.assertEqual(0, len(movable_entity.items))
self.assertFalse(movable_entity.get_item(0))
def test_stat_down(self):
movable_entity = random_movable_entity()
stat = rd.choice(STATS)
stat_down_alteration = random_alteration(name=stat + "_down",
effects=[stat + '_down'])
movable_entity.set_alteration(stat_down_alteration)
# Test formatted stat change rendering
self.assertEqual(f' (-{stat_down_alteration.power})',
movable_entity.get_formatted_stat_change(stat))
def test_simple_move(self):
movable_entity = random_movable_entity()
new_pos = (movable_entity.pos[0] + rd.randint(1, 20),
movable_entity.pos[1] + rd.randint(1, 20))
movable_entity.set_move([new_pos])
movable_entity.timer = 0
movable_entity.move()
self.assertTrue(movable_entity.is_on_pos(new_pos))
def test_lvl_up(self):
movable_entity = random_movable_entity()
old_lvl = movable_entity.lvl
old_xp_required = movable_entity.xp_next_lvl
earned_xp = old_xp_required
self.assertEqual(0, movable_entity.xp)
self.assertTrue(movable_entity.earn_xp(earned_xp))
self.assertEqual(old_lvl + 1, movable_entity.lvl)
self.assertEqual(0, movable_entity.xp)
self.assertTrue(old_xp_required < movable_entity.xp_next_lvl)
def test_more_than_letal_damage(self):
destroyable = random_destroyable_entity()
attacker = random_movable_entity()
kind = DamageKind.PHYSICAL
allies = []
damage = destroyable.hp + destroyable.defense + rd.randint(1, 20)
returned_hp = destroyable.attacked(attacker, damage, kind, allies)
self.assertEqual(returned_hp, destroyable.hp)
self.assertEqual(destroyable.hp, 0)
def test_negative_damage(self):
destroyable = random_destroyable_entity()
attacker = random_movable_entity()
kind = DamageKind.PHYSICAL
allies = []
damage = rd.randint(-10, -1)
returned_hp = destroyable.attacked(attacker, damage, kind, allies)
self.assertEqual(returned_hp, destroyable.hp)
self.assertEqual(destroyable.hp, destroyable.hp_max)
def test_more_xp_than_needed(self):
movable_entity = random_movable_entity()
old_lvl = movable_entity.lvl
old_xp_required = movable_entity.xp_next_lvl
sup_xp_amount = rd.randint(1, 30)
earned_xp = old_xp_required + sup_xp_amount
self.assertEqual(0, movable_entity.xp)
self.assertTrue(movable_entity.earn_xp(earned_xp))
self.assertEqual(old_lvl + 1, movable_entity.lvl)
self.assertEqual(sup_xp_amount, movable_entity.xp)
self.assertTrue(old_xp_required < movable_entity.xp_next_lvl)
def test_add_multiple_items(self):
movable_entity = random_movable_entity()
item = random_item()
other_item = random_item()
self.assertTrue(movable_entity.has_free_space())
self.assertEqual(0, len(movable_entity.items))
self.assertTrue(movable_entity.set_item(item))
self.assertTrue(movable_entity.set_item(other_item))
self.assertEqual(2, len(movable_entity.items))
self.assertEqual(item, movable_entity.get_item(0))
self.assertEqual(other_item, movable_entity.get_item(1))
def test_earn_multiple_times_xp(self):
movable_entity = random_movable_entity()
old_lvl = movable_entity.lvl
earned_xp = rd.randint(1, (movable_entity.xp_next_lvl // 2) - 1)
earned_xp_bis = rd.randint(1, (movable_entity.xp_next_lvl // 2) - 1)
self.assertEqual(0, movable_entity.xp)
self.assertFalse(movable_entity.earn_xp(earned_xp))
self.assertEqual(old_lvl, movable_entity.lvl)
self.assertEqual(earned_xp, movable_entity.xp)
self.assertFalse(movable_entity.earn_xp(earned_xp_bis))
self.assertEqual(old_lvl, movable_entity.lvl)
self.assertEqual(earned_xp + earned_xp_bis, movable_entity.xp)
def test_new_alteration(self):
movable_entity = random_movable_entity()
alteration = random_alteration(name='alt_test')
self.assertEqual(0, len(movable_entity.alterations))
self.assertEqual(
0, len(movable_entity.get_alterations_effect('alt_test')))
movable_entity.set_alteration(alteration)
self.assertEqual(1, len(movable_entity.alterations))
self.assertEqual(
1, len(movable_entity.get_alterations_effect('alt_test')))
self.assertEqual(
0, len(movable_entity.get_alterations_effect(random_string())))
def test_stat_up(self):
movable_entity = random_movable_entity()
stat = rd.choice(STATS)
other_stat = rd.choice(tuple(filter(lambda s: s != stat, STATS)))
stat_up_alteration = random_alteration(name=stat + "_up",
effects=[stat + '_up'])
self.assertEqual(0, movable_entity.get_stat_change(stat))
self.assertEqual(0, movable_entity.get_stat_change(other_stat))
movable_entity.set_alteration(stat_up_alteration)
self.assertEqual(stat_up_alteration.power,
movable_entity.get_stat_change(stat))
self.assertEqual(0, movable_entity.get_stat_change(other_stat))
# Test formatted stat change rendering
self.assertEqual(f' (+{stat_up_alteration.power})',
movable_entity.get_formatted_stat_change(stat))
def test_physical_and_spiritual_damage(self):
destroyable = random_destroyable_entity(min_hp=30, max_defense=10, max_res=10)
attacker = random_movable_entity()
kind = DamageKind.PHYSICAL
allies = []
damage = rd.randint(10, 15)
returned_hp = destroyable.attacked(attacker, damage, kind, allies)
self.assertEqual(returned_hp, destroyable.hp)
self.assertEqual(destroyable.hp_max, destroyable.hp + damage - destroyable.defense)
# Destroyable entity is healed before next attack for simplify test
destroyable.hp = destroyable.hp_max
kind = DamageKind.SPIRITUAL
returned_hp = destroyable.attacked(attacker, damage, kind, allies)
self.assertEqual(returned_hp, destroyable.hp)
self.assertEqual(destroyable.hp_max, destroyable.hp + damage - destroyable.res)
def test_end_turn(self):
movable_entity = random_movable_entity()
self.assertFalse(movable_entity.turn_is_finished())
movable_entity.end_turn()
self.assertTrue(movable_entity.turn_is_finished())
