def test_isub_tuple(self):
dmg_1 = Damage(phys_dmg=10, magic_dmg=10)
dmg_2 = (5, 5)
expected_result = Damage(phys_dmg=5, magic_dmg=5)
dmg_1 -= dmg_2
self.assertEqual(dmg_1, expected_result)
def test_sub_with_damage(self):
""" __sub__ works by adding the phys/magic damage and removing the other from it"""
dmg_1 = Damage(phys_dmg=5, magic_dmg=5)
dmg_2 = Damage(phys_dmg=2, magic_dmg=2)
expected_result = (5 + 5) - (2 + 2)
self.assertEqual(dmg_1 - dmg_2, expected_result)
def test_iadd_damage(self):
dmg_1 = Damage(phys_dmg=10, magic_dmg=10)
dmg_2 = Damage(phys_dmg=5, magic_dmg=6)
expected_result = Damage(phys_dmg=15, magic_dmg=16)
dmg_1 += dmg_2
self.assertEqual(dmg_1, expected_result)
def test_isub_negative_damage(self):
""" It should reset the damage to 0, rather than making it negative"""
dmg_1 = Damage(phys_dmg=10, magic_dmg=10)
dmg_2 = Damage(phys_dmg=15, magic_dmg=117)
expected_result = Damage(phys_dmg=0, magic_dmg=0)
dmg_1 -= dmg_2
self.assertEqual(dmg_1, expected_result)
def test_handle_absorption_bigger_than_magic(self):
absorption_shield = 7
dmg = Damage(phys_dmg=10, magic_dmg=6)
dmg.handle_absorption(absorption_shield)
expected_dmg = Damage(phys_dmg=9, magic_dmg=0)
expected_dmg.magic_absorbed = 6
expected_dmg.phys_absorbed = 1
self.assertEqual(dmg, expected_dmg)
def test_eq(self):
""" Two Damage classes should be equal if their magic/phys dmg and absorbed are equal"""
dmg_1 = Damage(1, 1)
dmg_2 = Damage(1, 1)
self.assertEqual(dmg_1, dmg_2)
dmg_1.phys_absorbed += 0.1
self.assertNotEqual(dmg_1, dmg_2)
dmg_1.phys_absorbed = dmg_2.phys_absorbed
self.assertEqual(dmg_1, dmg_2)
dmg_1.magic_dmg += 1
self.assertNotEqual(dmg_1, dmg_2)
def test_handle_absorption(self):
""" The handle_absorption function subtracts the absorbed damage from the damage.
Magical damage always gets absorbed first """
absorption_shield = 5
dmg = Damage(phys_dmg=10, magic_dmg=6)
dmg.handle_absorption(absorption_shield)
expected_dmg = Damage(phys_dmg=10, magic_dmg=1)
expected_dmg.magic_absorbed = 5
self.assertEqual(dmg, expected_dmg)
def test_handle_absorption_bigger_than_both_dmg(self):
absorption_shield = 17
dmg = Damage(phys_dmg=10, magic_dmg=6)
left_shield = dmg.handle_absorption(absorption_shield)
expected_dmg = Damage(phys_dmg=0, magic_dmg=0)
expected_dmg.magic_absorbed = 6
expected_dmg.phys_absorbed = 10
expected_shield = 1
self.assertEqual(dmg, expected_dmg)
self.assertEqual(left_shield, expected_shield)
def test_str_with_phys_and_magic_dmg(self):
expected_phys = 10.2
expected_magic = 10.10
dmg = Damage(phys_dmg=10.199, magic_dmg=10.111)
expected_str = f'{expected_phys:.2f} physical damage and {expected_magic:.2f} magical damage'
self.assertEqual(str(dmg), expected_str)
def get_auto_attack_damage(self, target_level: int):
# get the base auto attack damage
damage_to_deal = random.randint(self.min_damage, self.max_damage)
# factor in the level difference
damage_to_deal = self._calculate_level_difference_damage(
damage_to_deal, target_level)
return Damage(phys_dmg=damage_to_deal)
def setUp(self):
self.name = 'Audi'
self.damage_tick = Damage(phys_dmg=3)
self.duration = 5
self.caster_level = 10
self.dot_dummy = DoT(self.name, self.damage_tick, self.duration,
self.caster_level)
def test_str_only_phys_dmg_with_absorbed(self):
expected_phys = 10.10
expected_absorbed = 10
dmg = Damage(phys_dmg=10.111)
dmg.phys_absorbed = expected_absorbed
expected_str = f'{expected_phys:.2f} physical damage ({expected_absorbed:.2f} absorbed)'
self.assertEqual(str(dmg), expected_str)
def test_str_only_mag_dmg_with_absorbed(self):
expected_magic = 10.10
expected_absorbed = 10
dmg = Damage(magic_dmg=10.111)
dmg.magic_absorbed = expected_absorbed
expected_str = f'{expected_magic:.2f} magical damage ({expected_absorbed:.2f} absorbed)'
self.assertEqual(str(dmg), expected_str)
def test_str_with_magic_dmg_phys_absorbed(self):
expected_magic = 10.2
expected_phys_absorbed = 5.5
dmg = Damage(magic_dmg=10.199)
dmg.phys_absorbed = expected_phys_absorbed
expected_str = f'0.00 physical damage ({expected_phys_absorbed:.2f} absorbed) and {expected_magic:.2f} magical damage'
self.assertEqual(str(dmg), expected_str)
def test_str_with_phys_and_magic_phys_absorb(self):
expected_phys = 10.2
expected_magic = 10.10
expected_phys_absorbed = 5.5
dmg = Damage(phys_dmg=10.199, magic_dmg=10.111)
dmg.phys_absorbed = expected_phys_absorbed
expected_str = f'{expected_phys:.2f} physical damage ({expected_phys_absorbed:.2f} absorbed) and {expected_magic:.2f} magical damage'
self.assertEqual(str(dmg), expected_str)
def test_str_with_phys_dmg_magic_absorbed(self):
expected_phys = 10.2
expected_magic = 0
expected_magic_absorbed = 5.5
dmg = Damage(phys_dmg=10.199)
dmg.magic_absorbed = expected_magic_absorbed
expected_str = f'{expected_phys:.2f} physical damage and {expected_magic:.2f} magical damage ({expected_magic_absorbed:.2f} absorbed)'
self.assertEqual(str(dmg), expected_str)
def test_str_with_absorbed_only(self):
expected_magic_absorbed = 5.5
expected_phys_absorbed = 5.4
dmg = Damage()
dmg.magic_absorbed = expected_magic_absorbed
dmg.phys_absorbed = expected_phys_absorbed
expected_str = f'0.00 physical damage ({expected_phys_absorbed:.2f} absorbed) and 0.00 magical damage ({expected_magic_absorbed:.2f} absorbed)'
self.assertEqual(str(dmg), expected_str)
def convert_to_dot_object(self, caster_lvl) -> DoT:
"""
Convert the Dot schema object to a DoT object
"""
dot_name: str = self.name
dot_damage_per_tick: int = self.damage_per_tick
dot_damage_school: str = self.damage_school
dot_duration: int = self.duration
if dot_damage_school == "magic":
dot_damage: Damage = Damage(magic_dmg=dot_damage_per_tick)
elif dot_damage_school == "physical":
dot_damage: Damage = Damage(phys_dmg=dot_damage_per_tick)
else:
raise Exception('Unsupported Damage type!')
return DoT(name=dot_name,
damage_tick=dot_damage,
duration=dot_duration,
caster_lvl=caster_lvl)
def setUp(self):
"""
Test that the values in the Schema are as expected
And that the convert_to_paladin_spell_object function works
"""
self.spell_entry = 4
self.spell_name = 'Melting Strike'
self.dot = DoT(name='Melting', damage_tick=Damage(magic_dmg=2), duration=2, caster_lvl=0)
self.expected_spell = PaladinSpell(name=self.spell_name, rank=1, damage1=3, damage2=0, damage3=0,
heal1=0, heal2=0, heal3=0, mana_cost=6, cooldown=3,
beneficial_effect=None, harmful_effect=self.dot)
def test_init(self):
dmg = Damage(phys_dmg=1.34, magic_dmg=1.49391)
expected_phys_dmg = 1.3
expected_m_dmg = 1.5
expected_absorbed = 0
# it should round the magic/phys dmg to 1 point after the decimal
self.assertEqual(dmg.phys_dmg, expected_phys_dmg)
self.assertEqual(dmg.magic_dmg, expected_m_dmg)
self.assertEqual(dmg.phys_absorbed, expected_absorbed)
self.assertEqual(dmg.magic_absorbed, expected_absorbed)
def setUp(self):
"""
Test that the DotSchema attributes are as expected
Test the convert_to_dot_object function
"""
self.entry = 1
self.name = 'Melting'
self.damage = Damage(magic_dmg=2)
self.duration = 2
self.caster_level = 5
self.expected_dot = DoT(name=self.name,
damage_tick=self.damage,
duration=self.duration,
caster_lvl=self.caster_level)
def _apply_armor_reduction(self, damage: Damage,
attacker_level: int) -> Damage:
"""
This method applies the armor reduction to a blow, the formula is as follows:
Percentage to Reduce = Armor / (Armor + 400 + 85 * Attacker_Level)
:param damage: the raw damage
:return: the damage with the applied reduction
"""
armor = self.attributes[KEY_ARMOR_ATTRIBUTE]
reduction_percentage = armor / (armor + 400 + 85 * attacker_level)
damage_to_deduct = damage.phys_dmg * reduction_percentage
reduced_damage = damage.phys_dmg - damage_to_deduct
return Damage(phys_dmg=reduced_damage, magic_dmg=damage.magic_dmg)
def spell_melting_strike(self, spell: PaladinSpell, target: Monster):
""" Damages the enemy for DAMAGE_1 damage and puts a DoT effect, the index of which is EFFECT
:return successful cast or not"""
mana_cost: int = spell.mana_cost
damage: Damage = Damage(phys_dmg=spell.damage1)
dot: 'DoT' = spell.harmful_effect
dot.update_caster_level(self.level)
self.mana -= mana_cost
# damage the target and add the DoT
print(f'{spell.name} damages {target.name} for {damage}!')
target.take_attack(damage, self.level)
target.add_buff(dot)
return True
def update(self, time):
if not self.timing:
inside = self.manager.space.castRadiuCircle(
self.center, self.radiu)
if len(inside) > 0:
self.timing = True
self.time = 0.4
self.manager.createEffection(
[19, (self.center.x, self.center.y)])
if self.timing:
self.time -= time
if self.time <= 0:
tragets = self.manager.space.castCircle(
self.center, self.exp_radiu)
for pair in tragets:
unit = self.manager.getUnit(pair.key.id)
newd = Damage(Damage.REAL_DAMAGE(), 20, None)
unit.takeDamage(newd)
self.delSelf()
def get_auto_attack_damage(self, target_level: int) -> (Damage, int):
level_difference = self.level - target_level
percentage_mod = (
abs(level_difference) * 0.1
) # calculates by how many % we're going to increase/decrease dmg
sor_damage = 0
damage_to_deal = random.randint(int(self.min_damage),
int(self.max_damage))
if self.SOR_ACTIVE:
sor_damage = self._spell_seal_of_righteousness_attack()
# 10% more or less damage for each level that differs
if level_difference < 0: # monster is bigger level
damage_to_deal -= damage_to_deal * percentage_mod # -X%
sor_damage -= sor_damage * percentage_mod
elif level_difference > 0: # character is bigger level
damage_to_deal += damage_to_deal * percentage_mod # +X%
sor_damage += sor_damage * percentage_mod
return Damage(phys_dmg=damage_to_deal,
magic_dmg=sor_damage), sor_damage
def test_sub_with_int(self):
dmg_1 = Damage(phys_dmg=5, magic_dmg=5)
dmg_2 = 4
expected_result = (5 + 5) - 4
self.assertEqual(dmg_1 - dmg_2, expected_result)
def test_mul(self):
dmg_1 = Damage(phys_dmg=2, magic_dmg=3)
multiplier = 2
expected = Damage(phys_dmg=2 * 2, magic_dmg=3 * 2)
self.assertEqual(dmg_1 * multiplier, expected)
def test_str_only_phys_dmg(self):
expected_phys = 10.10
dmg = Damage(phys_dmg=10.111)
expected_str = f'{expected_phys:.2f} physical damage'
self.assertEqual(str(dmg), expected_str)
def create_damage(self, x, y):
damage = Damage(x, y)
self.damages.append(damage)
self.objects.append(damage)
def test_str_only_mag_dmg(self):
expected_magic = 10.10
dmg = Damage(magic_dmg=10.111)
expected_str = f'{expected_magic:.2f} magical damage'
self.assertEqual(str(dmg), expected_str)