def hero_attack(self, by):
if by == "spell":
if Spell.in_range():
if Hero.can_cast() == True and self.fattack == True:
self.fattack = False # след боя трябва да стане пак True
print(self.msg1)
Enemies(take_damege())
# Трябва да се добави боя
elif Hero.can_cast():
# Трябва да се добави боя
else:
return self.hero_attack("weapon") # Май така беше да се испълни функцията
else:
print("Nothing in casting range {}".format(self.cast_range))
if by == "weapon":
# Трябва да се добави боя
pass
class TestHero(unittest.TestCase):
def setUp(self):
self.h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
self.w = Weapon(name="The Axe of Destiny", damage=20)
self.s = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)
def test_init(self):
self.assertEqual(self.h.name, "Bron")
self.assertEqual(self.h.title, "Dragonslayer")
self.assertEqual(self.h.health, 100)
self.assertEqual(self.h.mana, 100)
self.assertEqual(self.h.mana_regeneration_rate, 2)
self.assertEqual(self.h.start_mana, 100)
self.assertEqual(self.h.damage, 0)
def test_known_as(self):
result = "Bron the Dragonslayer"
self.assertEqual(self.h.known_as(), result)
def test_is_alive(self):
self.assertTrue(self.h.is_alive() is True)
def test_take_damage(self):
damage = self.h.take_damage(40)
self.assertTrue(self.h.health is 60)
def test_can_cast(self):
self.assertTrue(self.h.can_cast() is True)
def test_take_healing(self):
self.h.take_damage(100)
self.new_health = self.h.take_healing(30)
self.assertTrue(self.h.health is 0)
def test_take_mana(self):
self.h.learn(self.s)
self.h.attack(by="spell")
self.h.take_mana(10)
self.assertEqual(self.h.mana, 60)
def test_attack(self):
self.h.equip(self.w)
self.assertEqual(self.h.attack(by="weapon"), 20)
self.h.learn(self.s)
self.assertEqual(self.h.attack(by="spell"), 30)
def test_exception(self):
self.h.learn(self.s)
self.assertEqual(self.h.attack(by="spell"), 30)
with self.assertRaises(NotEnaughMana):
self.s.mana_cost = 50
self.h.attack(by="spell")
class TestHero(unittest.TestCase):
def setUp(self):
self.h = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2)
self.w = Weapon(name="The Axe of Destiny", damage=20)
self.s = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)
def test_init(self):
self.assertEqual(self.h.name, "Bron")
self.assertEqual(self.h.title, "Dragonslayer")
self.assertEqual(self.h.health, 100)
self.assertEqual(self.h.mana, 100)
self.assertEqual(self.h.mana_regeneration_rate, 2)
self.assertEqual(self.h.start_mana, 100)
self.assertEqual(self.h.damage, 0)
def test_known_as(self):
result = "Bron the Dragonslayer"
self.assertEqual(self.h.known_as(), result)
def test_is_alive(self):
self.assertTrue(self.h.is_alive() is True)
def test_take_damage(self):
damage = self.h.take_damage(40)
self.assertTrue(self.h.health is 60)
def test_can_cast(self):
self.assertTrue(self.h.can_cast() is True)
def test_take_healing(self):
self.h.take_damage(100)
self.new_health = self.h.take_healing(30)
self.assertTrue(self.h.health is 0)
def test_take_mana(self):
self.h.learn(self.s)
self.h.attack(by="spell")
self.h.take_mana(10)
self.assertEqual(self.h.mana, 60)
def test_attack(self):
self.h.equip(self.w)
self.assertEqual(self.h.attack(by="weapon"), 20)
self.h.learn(self.s)
self.assertEqual(self.h.attack(by="spell"), 30)
def test_exception(self):
self.h.learn(self.s)
self.assertEqual(self.h.attack(by="spell"), 30)
with self.assertRaises(NotEnaughMana):
self.s.mana_cost = 50
self.h.attack(by="spell")
class Test(unittest.TestCase):
def setUp(self):
self.w = Weapon("axe", 20)
self.spell = Spell("love spell", 70, 2, 4)
self.h = Hero("Arthur", "great", 100, 100, 100, 2, self.w, self.spell)
def test_hero_init(self):
self.assertEqual(self.h.get_name(), "Arthur")
self.assertEqual(self.h.get_title(), "great")
self.assertEqual(self.h.get_health(), 100)
self.assertEqual(self.h.get_start_health(), 100)
self.assertEqual(self.h.get_mana(), 100)
self.assertEqual(self.h.get_mana_rate(), 2)
self.assertEqual(self.h.get_weapon(), "axe")
def test_hero_init(self):
self.assertEqual(str(self.h), "Arthur great 100 100 2")
def test_hero_known_as(self):
self.assertEqual(self.h.known_as(), "Arthur the great")
def test_hero_is_alive(self):
self.assertTrue(self.h.is_alive())
def test_hero_is_dead(self):
self.assertFalse(self.h.is_dead())
def test_hero_can_cast(self):
self.assertTrue(self.h.can_cast())
def test_hero_take_damage(self):
self.assertEqual(self.h.take_damage(70), 30)
def test_hero_take_healing(self):
self.h.take_damage(70)
self.assertEqual(self.h.take_healing(20), 50)
def test_hero_equip(self):
self.assertEqual(self.h.equip(self.w), "Equipped with axe, damage: 20")
def test_hero_attack(self):
self.assertEqual(self.h.attack("weapon"), 20)
class TestsHero(unittest.TestCase):
def setUp(self):
self.hero1 = Hero(
name='Toni',
title='Pythonslayer',
health=250,
mana=1000,
mana_regeneration_rate=25,
)
self.hero2 = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
self.spell = Spell(name="Fireball",
damage=30,
mana_cost=110,
cast_range=2)
self.weapon = Weapon(name="The Axe of Destiny", damage=20)
def test_init_working_correctly(self):
with self.subTest('hero1'):
self.assertEqual(self.hero1._name, 'Toni')
self.assertEqual(self.hero1._title, 'Pythonslayer')
self.assertEqual(self.hero1._health, 250)
self.assertEqual(self.hero1._max_health, 250)
self.assertEqual(self.hero1._mana, 1000)
self.assertEqual(self.hero1._max_mana, 1000)
self.assertEqual(self.hero1._mana_regeneration_rate, 25)
self.assertEqual(self.hero1._weapon, None)
self.assertEqual(self.hero1._spell, None)
def test_known_as(self):
with self.subTest('hero1'):
self.assertEqual(self.hero1.known_as(), 'Toni the Pythonslayer')
with self.subTest('hero2'):
self.assertEqual(self.hero2.known_as(), 'Bron the Dragonslayer')
def test_can_cast(self):
with self.subTest('spell is None'):
self.assertFalse(self.hero1.can_cast())
with self.subTest('when mana is not enough'):
self.hero2._spell = self.spell
self.assertFalse(self.hero2.can_cast())
with self.subTest('when mana is not enough'):
self.hero1._spell = self.spell
self.assertTrue(self.hero1.can_cast())
def test_attack_raises_exceptions_correctly(self):
with self.subTest('when by == weapon and hero\'s weapon is None'):
with self.assertRaises(NotEquippedError):
self.hero1.attack(by='weapon')
with self.subTest('when by == spell and hero\'s spell is None'):
with self.assertRaises(NotEquippedError):
self.hero1.attack(by='spell')
with self.subTest('when by is not \'weapon\' or \'spell\''):
with self.assertRaises(TypeError):
self.hero1.attack(by='foot')
with self.subTest('when spell costs more then current mana'):
with self.assertRaises(NotEnoughManaError):
self.hero1.learn(self.spell)
for x in range(0, 20):
self.hero1.attack(by='spell')
def test_attack_returns_correct_damage(self):
with self.subTest('\'by\' == \'spell\''):
self.hero1._spell = self.spell
damage = self.hero1.attack(by='spell')
self.assertEqual(damage, 30)
self.assertEqual(self.hero1._mana, 890)
with self.subTest('\'by\' == \'weapon\''):
self.hero2._weapon = self.weapon
damage = self.hero2.attack(by='weapon')
self.assertEqual(damage, 20)
def test_eq_returns_false_when_hero1_super_different_than_hero2_super(
self):
hero3 = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
hero3.learn(self.spell)
self.assertNotEqual(self.hero2, hero3)
def test_eq_returns_false_when_hero1_has_different_attr_than_hero2_super(
self):
hero3 = Hero(name="Toni",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
self.assertNotEqual(self.hero2, hero3)
def test_eq_returns_true_when_super_and_all_attrs_are_the_same(self):
hero3 = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
self.assertEqual(self.hero2, hero3)
def test_to_json(self):
self.hero1.learn(self.spell)
expected = {
'name': 'Toni',
'title': 'Pythonslayer',
'mana_regeneration_rate': 25,
'health': 250,
'mana': 1000,
'weapon': None,
'spell': self.spell.to_json()
}
self.assertDictEqual(self.hero1.to_json(), expected)
def test_from_json(self):
self.hero1.equip(self.weapon)
json_dict = {
'name': 'Toni',
'title': 'Pythonslayer',
'mana_regeneration_rate': 25,
'health': 250,
'mana': 1000,
'weapon': self.weapon.to_json(),
'spell': None
}
self.assertEqual(self.hero1, Hero.from_json(json_dict))
class HeroTest(unittest.TestCase):
def setUp(self):
self.hunter = Hero("Lagerta", "Arrow", 120, 120, 2)
def test_create_new_instance(self):
self.assertTrue(isinstance(self.hunter, Hero))
def test_valid_members(self):
self.assertEqual(self.hunter.name, "Lagerta")
self.assertEqual(self.hunter.title, "Arrow")
self.assertEqual(self.hunter.health, 120)
self.assertEqual(self.hunter.mana, 120)
self.assertEqual(self.hunter.mana_regeneration_rate, 2)
self.assertEqual(self.hunter.max_health, 120)
self.assertEqual(self.hunter.max_mana, 120)
def test_known_as(self):
self.assertEqual(self.hunter.known_as(), "Lagerta the Arrow")
def test_get_health(self):
self.assertEqual(self.hunter.get_health(), 120)
def test_get_mana(self):
self.assertEqual(self.hunter.get_mana(), 120)
def test_is_alive(self):
self.assertTrue(self.hunter.is_alive())
self.hunter.health = 0
self.assertFalse(self.hunter.is_alive())
def test_can_cast_without_spell(self):
self.assertFalse(self.hunter.can_cast())
def test_can_cast_with_more_mana(self):
self.hunter.spell = Spell("Chilling Poison", 20, 20, 2)
self.assertTrue(self.hunter.can_cast())
def test_can_cast_with_less_mana(self):
self.hunter.spell = Spell("Chilling Poison", 20, 20, 2)
self.hunter.mana = 0
self.assertFalse(self.hunter.can_cast())
def test_take_damage_more_than_health(self):
self.hunter.take_damage(150)
self.assertEqual(self.hunter.health, 0)
def test_take_damage_less_than_health(self):
self.hunter.take_damage(100)
self.assertEqual(self.hunter.health, 20)
def test_take_healing_dead_hero(self):
self.hunter.health = 0
self.assertFalse(self.hunter.take_healing(200))
def test_take_healing_with_more_points_than_max_health(self):
self.hunter.health = 80
self.assertTrue(self.hunter.take_healing(200))
self.assertEqual(self.hunter.health, 120)
def test_take_healing_with_less_points_than_max_health(self):
self.hunter.health = 90
self.assertTrue(self.hunter.take_healing(20))
self.assertEqual(self.hunter.health, 110)
def test_take_mana_with_more_points_than_max_mana(self):
self.hunter.mana = 80
self.hunter.take_mana(200)
self.assertEqual(self.hunter.mana, 120)
def test_take_mana_with_negative_mana(self):
self.hunter.mana = 50
self.hunter.take_mana(-60)
self.assertEqual(self.hunter.mana, 0)
def test_take_mana_with_less_points_than_max_mana(self):
self.hunter.mana = 65
self.hunter.take_mana(20)
self.assertEqual(self.hunter.mana, 85)
def test_equip(self):
knife = Weapon("Knife", 10)
self.hunter.equip(knife)
self.assertEqual(self.hunter.weapon, knife)
def test_learn(self):
mind_blast = Spell("Mind Blast", 20, 35, 5)
self.hunter.learn(mind_blast)
self.assertEqual(self.hunter.spell, mind_blast)
def test_attack_without_equiped_weapon(self):
self.assertEqual(self.hunter.attack(by="weapon"), 0)
def test_attack_with_equiped_weapon(self):
knife = Weapon("Sword", 30)
self.hunter.equip(knife)
self.assertEqual(self.hunter.attack(by="weapon"), 30)
def test_attack_without_learned_spell(self):
self.assertEqual(self.hunter.attack(by="spell"), 0)
def test_attack_with_learned_spell(self):
fire_blast = Spell("Fire Blast", 60, 40, 2)
self.hunter.learn(fire_blast)
self.assertEqual(self.hunter.attack(by="spell"), 60)
class TestHero(unittest.TestCase):
def setUp(self):
self._hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2)
def test_init(self):
self.assertTrue(isinstance(self._hero, Hero))
with self.assertRaises(ValueError):
Hero(name="Bron", title="Dragonslayer", health=-1, mana=100, mana_regeneration_rate=2)
with self.assertRaises(ValueError):
Hero(name="Bron", title="Dragonslayer", health=150, mana=100, mana_regeneration_rate=2)
with self.assertRaises(ValueError):
Hero(name="Bron", title="Dragonslayer", health=100, mana=-1, mana_regeneration_rate=2)
with self.assertRaises(ValueError):
Hero(name="Bron", title="Dragonslayer", health=100, mana=150, mana_regeneration_rate=2)
with self.assertRaises(ValueError):
Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=-1)
with self.assertRaises(TypeError):
Hero(name=0, title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2)
with self.assertRaises(TypeError):
Hero(name="Bron", title=0, health=100, mana=100, mana_regeneration_rate=2)
with self.assertRaises(TypeError):
Hero(name="Bron", title="Dragonslayer", health="str", mana=100, mana_regeneration_rate=2)
with self.assertRaises(TypeError):
Hero(name="Bron", title="Dragonslayer", health=100, mana="str", mana_regeneration_rate=2)
with self.assertRaises(TypeError):
Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate="str")
def test_known_as(self):
self.assertEqual(self._hero.known_as(), "Bron the Dragonslayer")
def test_get_health(self):
self.assertEqual(self._hero.get_health(), self._hero._health)
def test_get_mana(self):
self.assertEqual(self._hero.get_mana(), self._hero._mana)
def test_is_alive(self):
self.assertTrue(self._hero.is_alive())
def test_can_cast(self):
self.assertTrue(self._hero.can_cast())
def test_take_damage(self):
self._hero.take_damage(30)
self.assertEqual(self._hero._health, 70)
with self.assertRaises(ValueError):
self._hero.take_damage(-30)
def test_take_healing(self):
damaged_hero = Hero(name="Bron", title="Dragonslayer", health=50, mana=100, mana_regeneration_rate=2)
self.assertTrue(damaged_hero.take_healing(30))
def test_take_mana(self):
down_mana_hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=10, mana_regeneration_rate=2)
down_mana_hero.take_mana(30)
self.assertEqual(down_mana_hero._mana, 40)
def test_equip(self):
w1 = Weapon(name="The Axe of Destiny", damage=20)
w2 = Weapon(name="Crescent Scimitar", damage=132)
self._hero.equip(w2)
with self.assertRaises(HeroAlreadyHasAWeapon):
self._hero.equip(w1)
def test_learn(self):
s1 = Spell(name="Fireball", damage=30, mana_cost=20, cast_range=2)
s2 = Spell(name="Earth Pulse", damage=50, mana_cost=20, cast_range=2)
self._hero.learn(s1)
self._hero.learn(s2)
self.assertEqual(self._hero._spell, s2)
def test_attack(self):
weapon = Weapon(name="Crescent Scimitar", damage=20)
self.assertEqual(self._hero.attack(by="weapon"), 0)
self._hero.equip(weapon)
self.assertEqual(self._hero.attack(by="weapon"), weapon.damage)
class TestHero(unittest.TestCase):
def setUp(self):
self.h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
def test_known_as(self):
self.assertEqual(self.h.known_as(), "Bron the Dragonslayer")
def test_take_damage(self):
self.h.take_damage(20.5)
self.assertEqual(self.h.health, 79.5)
def test_take_mana(self):
self.h.take_mana(20)
self.assertEqual(self.h.mana, 100)
def test_can_cast(self):
s = Spell(name="s", damage=40, mana_cost=120, cast_range=2)
self.h.learn(s)
self.assertFalse(self.h.can_cast())
s1 = Spell(name="s1", damage=40, mana_cost=20, cast_range=2)
self.h.learn(s1)
self.assertTrue(self.h.can_cast())
def test_equip(self):
self.assertEqual(self.h.weapon, None)
w = Weapon(name="w", damage=20)
self.h.equip(w)
self.assertEqual(self.h.weapon.damage, 20)
self.assertEqual(self.h.weapon.name, "w")
w1 = Weapon(name="w1", damage=30)
self.h.equip(w1)
self.assertEqual(self.h.weapon.damage, 30)
self.assertEqual(self.h.weapon.name, "w1")
w2 = Weapon(name="w2", damage=10)
self.h.equip(w2)
self.assertEqual(self.h.weapon.damage, 30)
self.assertEqual(self.h.weapon.name, "w1")
def test_learn(self):
self.assertEqual(self.h.weapon, None)
s = Spell(name="s", damage=30, mana_cost=50, cast_range=2)
self.h.learn(s)
self.assertEqual(self.h.spell.damage, 30)
self.assertEqual(self.h.spell.name, "s")
s1 = Spell(name="s1", damage=40, mana_cost=50, cast_range=2)
self.h.learn(s1)
self.assertEqual(self.h.spell.damage, 40)
self.assertEqual(self.h.spell.name, "s1")
s2 = Spell(name="s1", damage=20, mana_cost=50, cast_range=2)
self.h.learn(s2)
self.assertEqual(self.h.spell.damage, 40)
self.assertEqual(self.h.spell.name, "s1")
def test_attack(self):
self.assertEqual(self.h.attack(by="weapon"), 0)
self.assertEqual(self.h.attack(by="spell"), 0)
w = Weapon(name="w", damage=20)
self.h.equip(w)
self.assertEqual(self.h.attack(by="weapon"), 20)
s = Spell(name="s", damage=30, mana_cost=10, cast_range=2)
self.h.learn(s)
self.assertEqual(self.h.attack(by="spell"), 30)
self.assertEqual(self.h.mana, 90)
s1 = Spell(name="s1", damage=30, mana_cost=110, cast_range=2)
self.h.learn(s1)
self.assertEqual(self.h.attack(by="spell"), 0)
self.assertEqual(self.h.mana, 90)
class TestHero(unittest.TestCase):
def setUp(self):
self.h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
self.w = Weapon(name="The Axe of Destiny", damage=20)
self.s = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)
def test_known_as(self):
self.assertTrue(self.h.known_as(),
'{} the {}'.format(self.h.name, self.h.title))
def test_is_alive(self):
self.assertTrue(self.h.is_alive())
self.h.health = 0
self.assertFalse(self.h.is_alive())
def test_get_health(self):
self.assertTrue(self.h.get_health(), self.h.health)
def test_get_mana(self):
self.assertTrue(self.h.get_mana(), self.h.mana)
def test_can_cast(self):
self.assertFalse(self.h.can_cast())
self.h.learn(self.s)
self.assertTrue(self.h.can_cast())
self.h.mana = 40
self.assertFalse(self.h.can_cast())
def test_take_damage(self):
self.assertEqual(self.h.take_damage(60), 40)
self.assertEqual(self.h.take_damage(60), 0)
def test_take_healing(self):
self.assertTrue(self.h.take_healing(10))
self.assertEqual(self.h.health, 100)
self.h.health = 50
self.assertTrue(self.h.take_healing(10))
self.assertEqual(self.h.health, 60)
self.h.health = 0
self.assertFalse(self.h.take_healing(10))
def test_take_mana(self):
self.h.take_mana(10)
self.assertEqual(self.h.mana, 100)
self.h.mana = 50
self.h.take_mana(10)
self.assertEqual(self.h.mana, 60)
self.h.take_mana()
self.assertEqual(self.h.mana, 60 + self.h.mana_regeneration_rate)
def test_weapon_equip_and_spell_learn(self):
self.h.learn(self.w)
self.h.equip(self.s)
self.assertEqual(self.h.current_spell, 'No spell')
self.assertEqual(self.h.current_weapon, 'No weapon')
self.h.learn(self.s)
self.h.equip(self.w)
self.assertEqual(self.h.current_spell, self.s)
self.assertEqual(self.h.current_weapon, self.w)
def test_attack_function(self):
self.assertEqual(self.h.attack(by='weapon'), 0)
self.assertEqual(self.h.attack(by='spell'), 0)
self.h.learn(self.s)
self.h.equip(self.w)
self.assertEqual(self.h.attack(by='weapon'), self.w.damage)
self.assertEqual(self.h.attack(by='spell'), self.s.damage)
self.h.mana = 20
self.assertEqual(self.h.attack(by='spell'), 0)
class HeroTest(unittest.TestCase):
def setUp(self):
self.hero = Hero(name="Bron",
title="Dragonslayer",
health=100, mana=100,
mana_regeneration_rate=2)
self.weapon = Weapon(name="The Axe of Destiny", damage=20)
self.spell = Spell(name="Fireball",
damage=30,
mana_cost=50,
cast_range=2)
def test_exists_class(self):
self.assertTrue(isinstance(self.hero, Hero))
def test_hero_known_as(self):
self.assertTrue(self.hero.known_as(), "Bron the DragonSlayer")
def test_hero_is_alive(self):
self.assertTrue(self.hero.is_alive(), True)
def test_is_hero_not_alive(self):
self.hero.reduce_health(100)
self.assertFalse(self.hero.is_alive())
def test_hero_can_cast(self):
self.assertTrue(self.hero.can_cast(), True)
def test_hero_can_cast_false(self):
self.hero.reduce_mana(100)
self.assertFalse(self.hero.can_cast())
def test_mana_regeneration_rate(self):
self.assertEqual(self.hero.mana_regeneration_rate(), 2)
def test_hero_take_damage(self):
damage_points = 20
self.hero.take_damage(damage_points)
self.assertEqual(self.hero.get_health(), 80)
def test_hero_take_healing(self):
healing_points = 20
damage_points = 90
self.hero.take_damage(damage_points)
self.hero.take_healing(healing_points)
self.assertTrue(self.hero.get_health(), 30)
def test_hero_take_mana(self):
damage_points = 50
mana_points = 40
new_mana_points = 20
self.hero.take_damage(damage_points)
self.hero.reduce_mana(mana_points)
self.assertTrue(self.hero.take_mana(new_mana_points), 80)
def test_hero_weapon(self):
weapon_equipment = []
weapon_equipment.append(self.weapon)
self.assertEqual(weapon_equipment[0], self.weapon)
def test_hero_can_equip_with_weapon(self):
self.hero.equip(self.weapon)
self.assertEqual(str(self.hero.weapon_equipment[0]),
self.weapon.get_name())
def test_hero_spell(self):
learned_spell = []
learned_spell.append(self.spell)
self.assertEqual(learned_spell[0], self.spell)
def test_hero_can_learn_new_spell(self):
self.hero.learn(self.spell)
self.assertEqual(str(self.hero.learned_spell[0]),
self.spell.get_name())
def test_hero_attack_with_spell(self):
self.hero.learn(self.spell)
self.assertEqual(self.hero.attack(by="spell"),
self.spell.get_damage())
def test_hero_attack_with_weapon(self):
self.hero.equip(self.weapon)
self.assertEqual(self.hero.attack(by="weapon"),
self.weapon.get_damage())
class HeroTests(unittest.TestCase):
def setUp(self):
self.hero = Hero("Ahri", "Kingslayer", 100, 100, 2)
self.enemy = Enemy(100, 100, 20)
self.dungeon = Dungeon("level1.txt")
self.weapon = Weapon("The Axe of Destiny", damage=20)
self.spell = Spell(
name="Fireball", damage=30, mana_cost=50, cast_range=1)
def test_known_as(self):
self.assertEqual(self.hero.known_as(), "Ahri the Kingslayer")
def test_take_damage(self):
self.hero.take_damage(150)
self.assertEqual(self.hero.get_health(), 0)
def test_take_healing(self):
self.hero.take_damage(50)
self.assertTrue(self.hero.take_healing(55))
self.assertEqual(self.hero.get_health(), 100)
def test_take_mana_with_potion(self):
pass
# Test enemy who can not regenerate mana
def test_mana_regeneration_while_moving(self):
pass
def test_can_cast(self):
self.hero.learn(self.spell)
self.assertTrue(self.hero.can_cast())
def test_can_cast_with_no_spells_learned(self):
self.assertFalse(self.hero.can_cast())
def test_attack_not_being_specified(self):
with self.assertRaises(ValueError):
self.hero.attack(by="gun")
def test_attack_without_weapon_or_spell(self):
self.assertEqual(self.hero.attack(by="weapon"), 0)
self.assertEqual(self.hero.attack(by="magic"), 0)
# Test for enemy (base damage= = 20)
self.assertEqual(self.enemy.attack(by="weapon"), 20)
self.assertEqual(self.enemy.attack(by="magic"), 20)
def test_attack(self):
self.hero.equip(self.weapon)
self.assertEqual(self.hero.attack(by="weapon"), 20)
self.hero.learn(self.spell)
self.assertEqual(self.hero.attack(by="magic"), 30)
def test_dungeon_map(self):
self.assertEqual(self.dungeon.map, [['S', '.', '#', '#', '.', '.', '.', '.', '.', 'T'], ['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'], ['#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'], ['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'], ['#', '#', '#', 'T', '#', '#', '#', '#', '#', 'G']])
# self.dungeon.print_map()
def test_spawn_hero(self):
self.dungeon.spawn(self.hero)
self.dungeon.spawn(self.hero)
self.dungeon.spawn(self.hero)
# self.dungeon.print_map()
def test_get_position(self):
self.dungeon.spawn(self.hero)
self.assertEqual(self.dungeon.get_position(), (0, 0))
def test_move_right(self):
self.dungeon.spawn(self.hero)
self.dungeon.move_hero("right")
# self.dungeon.print_map()
self.assertFalse(self.dungeon.move_hero("right"))
def test_move_left(self):
self.dungeon.spawn(self.hero)
self.dungeon.move_hero("right")
self.assertTrue(self.dungeon.move_hero("left"))
# self.dungeon.print_map()
def test_move_up(self):
self.dungeon.spawn(self.hero)
self.assertFalse(self.dungeon.move_hero("up"))
def test_move_down(self):
self.dungeon.spawn(self.hero)
self.assertFalse(self.dungeon.move_hero("down"))
def test_moving_around_the_map(self):
dungeon = Dungeon("level2.txt")
dungeon.spawn(self.hero)
dungeon.move_hero("right")
dungeon.move_hero("down")
self.assertFalse(dungeon.move_hero("right"))
dungeon.move_hero("down")
self.assertFalse(dungeon.move_hero("left"))
# dungeon.print_map()
self.assertTrue(dungeon.move_hero("down"))
def test_the_game(self):
h = Hero(name="Bron", title="Dragonslayer",
health=100, mana=100, mana_regeneration_rate=2)
w = Weapon(name="The Axe of Destiny", damage=20)
h.equip(w)
s = Spell(name="Lightning bolt", damage=30, mana_cost=50, cast_range=2)
h.learn(s)
dungeon = Dungeon("level1.txt")
dungeon.spawn(h)
dungeon.move_hero("right")
dungeon.move_hero("down")
dungeon.try_range_attack()
dungeon.move_hero("down")
dungeon.move_hero("down")
dungeon.try_range_attack()
# dungeon.move_hero("right")
# dungeon.move_hero("right")
dungeon.print_map()