def main():
hero = Hero('Matt', 10, 5)
goblin = Goblin('Goblin', 6, 2)
while goblin.alive() and hero.alive():
print()
print("What do you want to do?")
print("1. fight %s" % (goblin.name))
print("2. do nothing")
print("3. flee")
print("> ", )
user_input = input()
if user_input == "1":
# Hero attacks enemy
hero.attack(goblin)
print("You do %d damage to the %s." % (hero.power, goblin.name))
if goblin.health <= 0:
print("The %s is dead." % (goblin.name))
elif user_input == "2":
goblin.attack(hero)
hero.print_status()
elif user_input == "3":
print("Goodbye.")
else:
print("Invalid input %r" % user_input)
if hero.health <= 0:
print("You are dead.")
def test_hero_attack_ability():
big_strength = Ability("Overwhelming Strength", 30000)
athena = Hero("Athena")
assert athena.attack() == 0
athena.add_ability(big_strength)
attack = athena.attack()
assert attack <= 30000 and attack >= 0
def main():
hero = Hero()
goblin = Goblin()
while hero.alive() and goblin.alive():
hero.print_status()
goblin.print_status()
print()
print("What do you want to do?")
print("1. fight goblin")
print("2. do nothing")
print("3. flee")
print("> ", )
user_input = input()
if user_input == "1":
# Hero attacks goblin
hero.attack(goblin)
elif user_input == "2":
pass
elif user_input == "3":
print("Goodbye.")
break
else:
print("Invalid input %r. Enter 1, 2 or 3." % user_input)
if goblin.health > 0:
# Goblin attacks hero
goblin.attack(hero)
def test_hero_attack():
flash = Hero("The Flash")
assert flash.attack() == 0
pesto = Ability("Pesto Sauce", 8000)
flash.add_ability(pesto)
attack = flash.attack()
assert attack <= 8000 and attack >= 4000
def main():
enemy = Goblin()
hero = Hero()
while enemy.alive() and hero.alive():
hero.print_status()
enemy.print_status()
print()
print("What do you want to do?")
print("1. fight enemy")
print("2. do nothing")
print("3. flee")
print("> ", )
response = input()
if response == "1":
# Hero attacks enemy
hero.attack(enemy)
elif response == "2":
pass
elif response == "3":
print("Goodbye.")
break
else:
print("Invalid input %r" % input)
if enemy.alive():
# enemy attacks hero
enemy.attack(hero)
def test_attack(self):
new_hero = Hero("Ico", 100, "old man")
new_weapon = Weapon("Axe", 25, 0.2)
self.assertFalse(new_hero.has_weapon())
self.assertEqual(new_hero.attack(), 0)
new_hero.equip_weapon(new_weapon)
self.assertTrue(new_hero.has_weapon())
self.assertEqual(new_hero.attack(), 25)
def main():
h = Hero(name="Bron", title="Dragonslayer",
health=100, mana=40, mana_regeneration_rate=2)
print(h.known_as())
print(h.health)
h.take_damage(30)
print('after damage')
print(h.health)
print(h.is_alive())
print('after healing')
print(h.take_healing(40))
print(h.health)
print('mana before taking potion')
print(h.mana)
w1 = Weapon("rifle", 50)
s1 = Spell("invisibility", 20, 50, 2)
h.equip(w1)
w2 = Weapon("knife", 30)
s2 = Spell("strength", 40, 20, 2)
h.equip(w2)
h.learn(s1)
h.learn(s2)
print('weapon damage:', h.current_weapon.damage)
print('weapon damage:', h.damage_of_weapon())
print('weapon damage:', h.attack("weapon"))
print('spell damage:', h.attack("spell"))
print('mana after an attack using spell which has 20 mana cost')
print(h.mana)
mp = ManaPotion("magic liquid", 20)
h.take_mana(mp._mana)
print('mana after taking potion that gives 20 mana')
print(h.mana)
print(h.take_mana(mp._mana))
e = Enemy(health=100, mana=100, damage=20)
e.equip(w1)
e.learn(s1)
print('enemy attack: ', e.attack())
print('enemy attack with a weapon: ', e.attack("weapon"))
print('enemy mana befor attack',e.mana)
print('enemy attack with a spell: ', e.attack("spell"))
print('enemy\'s mana after an attack using spell which has 20 mana cost')
print('enemy mana after attack',e.mana)
print('take_mana: ',e.take_mana(60))
print('----------ATTACK--------')
print(h.attack())
print('----------FIGHT------------')
f=Fight(h,e)
print(f.log)
print(f.won)
print("============================")
pick_treasure()
def test_mana_after_consuming_mana_potion(self):
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
s1 = Spell("invisibility", 20, 50, 2)
h.learn(s1)
h.attack()
mp = ManaPotion("Natural mana potion", 20)
mp.consume(h)
expected_result = 70
self.assertEqual(h.mana, expected_result)
def test_mana_after_consuming_mana_potion_with_more_mana_than_max_mana(
self):
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
s1 = Spell("invisibility", 20, 20, 2)
h.learn(s1)
h.attack()
mp = ManaPotion("Potion of supreme healing", 50)
mp.consume(h)
expected_result = 100
self.assertEqual(h.mana, expected_result)
def test_hero_weapon_attack_mean_value():
kkrunch = Hero("Kaptain Krunch")
strength = random.randint(10, 30000)
min_attack = strength // 2
big_strength = Weapon("Sword of Whimsy", strength)
kkrunch.add_ability(big_strength)
calculated_mean = (strength - min_attack) // 2 + min_attack
accepted_window = 400
iterations = 6000
sum_of_sqr = 0
total_attack = 0
for _ in range(iterations):
attack_value = kkrunch.attack()
assert attack_value >= min_attack and attack_value <= strength
total_attack += attack_value
deviation = attack_value - calculated_mean
sum_of_sqr += deviation * deviation
actual_mean = total_attack / iterations
print("Max Allowed Damage: {}".format(strength))
print("Attacks Tested: {}".format(iterations))
print("Mean -- calculated: {} | actual: {}".format(calculated_mean, actual_mean))
print("Acceptable Min: {} | Acceptable Max: {}".format(actual_mean - accepted_window, actual_mean + accepted_window))
print("Tested Result: {}".format(actual_mean))
assert actual_mean <= calculated_mean + accepted_window
assert actual_mean >= calculated_mean - accepted_window
def test_hero_ability_attack_mean_value():
athena = Hero("Athena")
strength = random.randint(10, 30000)
big_strength = Ability("Overwhelming Strength", strength)
athena.add_ability(big_strength)
calculated_mean = strength // 2
iterations = 6000
accepted_window = 400
total_attack = 0
for _ in range(iterations):
attack_value = athena.attack()
assert attack_value >= 0 and attack_value <= strength
total_attack += attack_value
actual_mean = total_attack / iterations
print("Max Allowed Damage: {}".format(strength))
print("Attacks Tested: {}".format(iterations))
print("Mean -- calculated: {} | actual: {}".format(calculated_mean,
actual_mean))
print("Acceptable Distance from Mean: {} | Average distance from mean: {}".
format(accepted_window, abs(calculated_mean - actual_mean)))
print("Acceptable min attack: {} | Acceptable max attack: {}".format(
actual_mean - accepted_window, actual_mean + accepted_window))
assert actual_mean <= calculated_mean + accepted_window and actual_mean >= calculated_mean - accepted_window
def test_with_given_hero_and_invalid_by_as_argument_should_raise_exception(
self):
name = 'Bron'
title = 'Dragonslayer'
health = 100
mana = 100
mana_regeneration_rate = 2
h = Hero(name, title, health, mana, mana_regeneration_rate)
by = None
exc = None
try:
h.attack(by=by)
except Exception as e:
exc = e
self.assertIsNotNone(exc)
self.assertEqual(str(exc), 'Invalid item for attack given')
class WeaphonTest(unittest.TestCase):
def setUp(self):
self.sniper = Weaphon("Gun", 85, 0.10)
self.hammer = Weaphon("One-Hand", 30, 0)
self.bron_orc = Orc("Pesho", 100, 1.50)
self.bron_hero = Hero("Ivan", 100, "Magician")
def test_weaphon_initialization(self):
self.assertEquals("Gun", self.sniper.type)
self.assertEquals(85, self.sniper.damage)
self.assertEquals(0.10, self.sniper.critical_strike_percent)
def test_crit_hit_sniper(self):
temp = False
for i in range(100):
if temp:
break
else:
temp = self.sniper.critical_hit()
self.assertTrue(temp)
def test_crit_hit_hammer(self):
temp = False
for i in range(100):
if temp:
break
else:
temp = self.hammer.critical_hit()
self.assertFalse(temp)
def test_entity_has_weaphon(self):
self.bron_orc.equip_weapon(self.hammer)
self.assertTrue(self.bron_orc.has_weaphon())
def test_entity_do_not_has_wep(self):
self.assertFalse(self.bron_orc.has_weaphon())
def test_entity_equip_weaphon_first_time(self):
self.bron_orc.equip_weapon(self.hammer)
self.assertEqual("One-Hand", self.bron_orc.weaphon.type)
def test_equip_weaphon_when_the_entity_allready_has_one(self):
self.bron_orc.equip_weapon(self.hammer)
self.bron_orc.equip_weapon(self.sniper)
self.assertEqual("Gun", self.bron_orc.weaphon.type)
def test_attack_no_weaphon(self):
self.assertEqual(0, self.bron_orc.attack())
def test_atack_hero(self):
self.bron_hero.equip_weapon(self.hammer)
self.assertEqual(30, self.bron_hero.attack())
def test_atack_orc(self):
self.bron_orc.equip_weapon(self.hammer)
self.assertEqual(45, self.bron_orc.attack())
def main():
hero = Hero(10, 5)
goblin = Goblin(6, 2)
# hero_health = 10
# hero_power = 5
# goblin_health = 6
# goblin_power = 2
while goblin.alive() and hero.alive():
#print("You have %d health and %d power." % (hero.health, hero.power))
hero.print_status()
#print("The goblin has %d health and %d power." % (goblin.health, goblin.power))
goblin.print_status()
print()
print("What do you want to do?")
print("1. fight goblin")
print("2. do nothing")
print("3. flee")
print("> ", )
user_input = input()
if user_input == "1":
# Hero attacks goblin
# goblin_health -= hero_power
# print("You do %d damage to the goblin." % hero_power)
hero.attack(goblin)
if not goblin.alive():
print("The goblin is dead.")
elif user_input == "2":
pass
elif user_input == "3":
print("Goodbye.")
break
else:
print("Invalid input %r" % user_input)
if goblin.alive():
# Goblin attacks hero
# hero_health -= goblin_power
# print("The goblin does %d damage to you." % goblin_power)
goblin.attack(hero)
if not hero.alive():
print("You are dead.")
def test_with_given_hero_and_no_item_for_attack_should_return_zero(self):
name = 'Bron'
title = 'Dragonslayer'
health = 100
mana = 100
mana_regeneration_rate = 2
h = Hero(name, title, health, mana, mana_regeneration_rate)
result = h.attack()
self.assertEqual(0, result)
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")
def test_hero_multi_weapon_attack():
strength = Weapon("Overwhelming Strength", 200)
sword_of_truth = Weapon("Sword of Truth", 700)
Athena = Hero("Athena")
Athena.add_ability(strength)
Athena.add_ability(sword_of_truth)
assert len(Athena.abilities) == 2
test_runs = 100
for _ in range(0, test_runs):
attack = Athena.attack()
assert attack <= 900 and attack >= 0
def test_with_given_hero_with_no_spell_and_spell_as_argument_should_return_zero(
self):
name = 'Bron'
title = 'Dragonslayer'
health = 100
mana = 100
mana_regeneration_rate = 2
h = Hero(name, title, health, mana, mana_regeneration_rate)
by = PLAYER_ATTACK_BY_SPELL_STRING
result = h.attack(by=by)
self.assertEqual(0, result)
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")
def main():
my_hero = Hero()
goblin = Goblin()
zombie = Zombie()
medic = Medic()
shadow = Shadow()
while (goblin.alive() or zombie.alive()) and my_hero.alive():
my_hero.print_status()
print()
print("What do you want to do?")
print("1. fight goblin")
print("2. fight zombie")
print("3. fight medic")
print("4. fight shadow")
print("5. do nothing")
print("6. flee")
print("> ",)
user_input = input()
if user_input == "1":
goblin.print_status()
# my_hero attacks goblin
my_hero.attack(goblin)
if goblin.health > 0:
# Goblin attacks my_hero
goblin.attack(my_hero)
elif user_input == "2":
zombie.print_status()
my_hero.attack(zombie)
zombie.attack(my_hero)
zombie.alive()
elif user_input == "3":
medic.print_status()
my_hero.attack(medic)
medic.attack(my_hero)
medic.alive()
elif user_input == "4":
shadow.print_status()
shadow.attack(my_hero)
my_hero.attack(shadow)
shadow.alive()
elif user_input == "5":
pass
elif user_input == "6":
print("Goodbye.")
break
else:
print("Invalid input %r" % user_input)
class HeroTest(unittest.TestCase):
def setUp(self):
self.hero = Hero("Arthas", 1000, "Lich King")
self.hero.weapon = Weapon("Frostmourne", 35, 0.7)
def test_init(self):
self.assertEqual(self.hero.name, "Arthas")
self.assertEqual(self.hero.health, 1000)
self.assertEqual(self.hero.nickname, "Lich King")
def test_known_as(self):
self.assertEqual(self.hero.known_as(), "Arthas the Lich King")
def test_has_weapon_when_present(self):
self.assertEqual(self.hero.has_weapon(), True)
def test_has_weapon_when_not_present(self):
self.hero.weapon = None
self.assertEqual(self.hero.has_weapon(), False)
def test_equip_stronger_weapon(self):
test_weapon = Weapon("Stick", 500, 0.1)
self.hero.equip_weapon(test_weapon)
self.assertEqual(self.hero.weapon, test_weapon)
def test_equip_weaker_weapon(self):
test_weapon = Weapon("Stick", 5, 0.1)
self.hero.equip_weapon(test_weapon)
self.assertNotEqual(self.hero.weapon, test_weapon)
def test_attack_when_no_weapon_is_equipped(self):
self.hero.weapon = None
self.assertEqual(self.hero.attack(), 0)
def test_attack_when_weapon_is_equipped(self):
self.assertIn(self.hero.attack(), [35, 70])
def test_with_given_hero_with_weapon_and_weapon_as_argument_should_return_damage_of_weapon(
self):
name = 'Bron'
title = 'Dragonslayer'
health = 100
mana = 100
mana_regeneration_rate = 2
h = Hero(name, title, health, mana, mana_regeneration_rate)
weapon = Weapon(name='Fireball', damage=30)
h.equip(weapon)
by = PLAYER_ATTACK_BY_WEAPON_STRING
result = h.attack(by=by)
self.assertEqual(30, result)
def test_with_given_hero_with_non_castable_spell_and_spell_as_argument_should_return_zerol(
self):
name = 'Bron'
title = 'Dragonslayer'
health = 100
mana = 20
mana_regeneration_rate = 2
h = Hero(name, title, health, mana, mana_regeneration_rate)
spell = Spell(name='Fireball', damage=30, mana_cost=50, cast_range=2)
h.learn(spell)
by = PLAYER_ATTACK_BY_SPELL_STRING
result = h.attack(by=by)
self.assertEqual(0, result)
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 TestHero(unittest.TestCase):
def setUp(self):
self.hero = Hero("Martin", "Manqk", 200, 300, 3)
def test_hero_init_(self):
self.assertEqual(self.hero.health, 200)
self.assertEqual(self.hero.mana, 300)
self.assertEqual(self.hero.damage, 0)
self.assertEqual(self.hero.name, "Martin")
self.assertEqual(self.hero.title, "Manqk")
self.assertEqual(self.hero.mana_regen, 3)
def test_hero_known_as(self):
self.assertEqual(self.hero.known_as(), "Martin the Manqk")
def test_hero_equip(self):
w = Weapon('noj', 20)
self.hero.equip(w)
self.assertEqual(self.hero.damage,
self.hero.phisical_damage + w.damage)
self.assertEqual(self.hero.max_equiped_weapons, 1)
self.assertFalse(self.hero.equip(w))
def test_hero_learn(self):
s = Spell("BatkaAttack", 30, 50, 2)
self.hero.learn(s)
self.assertEqual(self.hero.magic_damage, s.damage)
self.assertEqual(self.hero.max_learned_spells, 1)
self.assertFalse(self.hero.learn(s))
def test_hero_attack(self):
w = Weapon('noj', 20)
self.hero.equip(w)
self.hero.attack(by='weapon')
self.assertTrue(self.hero.can_attack())
self.assertEqual(self.hero.damage,
self.hero.phisical_damage + self.hero.damage)
s = Spell("BatkaAttack", 30, 50, 2)
self.hero.learn(s)
self.hero.attack(by='magic')
self.assertEqual(self.hero.damage, self.hero.magic_damage)
self.hero.attack(by='RKO')
self.assertRaises(Exception)
def test_hero_ability_attack_standard_deviation():
willow_waffle = Hero("Willow Waffle")
strength = random.randint(400, 30000)
willow = Ability("Willowness", strength)
willow_waffle.add_ability(willow)
attacks = list()
total_attack = 0
number_tests = 1000
for _ in range(number_tests):
cur_attack = willow_waffle.attack()
attacks.append(cur_attack)
total_attack += cur_attack
mean = total_attack / number_tests
# Get Square Deviations
for index, value in enumerate(attacks):
attacks[index] = math.pow(value - mean, 2)
standard_dev = math.sqrt(sum(attacks) / len(attacks))
print("Standard Deviation Cannot be 0.\nRandom Numbers not generated for attack.")
assert standard_dev != 0.0
def test_hero_attack_standard_deviation():
willow_waffle = Hero("Willow Waffle")
strength = random.randint(400, 30000)
travel_agent = Weapon("Travel Agents", strength)
willow_waffle.add_ability(travel_agent)
attacks = list()
total_attack = 0
number_tests = 1000
for _ in range(number_tests):
cur_attack = willow_waffle.attack()
attacks.append(cur_attack)
total_attack += cur_attack
mean = total_attack / number_tests
# Get Square Deviations
for index, value in enumerate(attacks):
attacks[index] = math.pow(value - mean, 2)
standard_dev = math.sqrt(sum(attacks) / len(attacks))
print("Random values not given. Please make sure you're not returning the same value every time.")
assert standard_dev != 0.0
class TestHero(unittest.TestCase):
def setUp(self):
self.hero = Hero("Martin", "Manqk", 200, 300, 3)
def test_hero_init_(self):
self.assertEqual(self.hero.health, 200)
self.assertEqual(self.hero.mana, 300)
self.assertEqual(self.hero.damage, 0)
self.assertEqual(self.hero.name, "Martin")
self.assertEqual(self.hero.title, "Manqk")
self.assertEqual(self.hero.mana_regen, 3)
def test_hero_known_as(self):
self.assertEqual(self.hero.known_as(), "Martin the Manqk")
def test_hero_equip(self):
w = Weapon('noj', 20)
self.hero.equip(w)
self.assertEqual(self.hero.damage, self.hero.phisical_damage + w.damage)
self.assertEqual(self.hero.max_equiped_weapons, 1)
self.assertFalse(self.hero.equip(w))
def test_hero_learn(self):
s = Spell("BatkaAttack", 30, 50, 2)
self.hero.learn(s)
self.assertEqual(self.hero.magic_damage, s.damage)
self.assertEqual(self.hero.max_learned_spells, 1)
self.assertFalse(self.hero.learn(s))
def test_hero_attack(self):
w = Weapon('noj', 20)
self.hero.equip(w)
self.hero.attack(by='weapon')
self.assertTrue(self.hero.can_attack())
self.assertEqual(self.hero.damage, self.hero.phisical_damage + self.hero.damage)
s = Spell("BatkaAttack", 30, 50, 2)
self.hero.learn(s)
self.hero.attack(by='magic')
self.assertEqual(self.hero.damage, self.hero.magic_damage)
self.hero.attack(by='RKO')
self.assertRaises(Exception)
class HeroTests(unittest.TestCase):
def setUp(self):
self.h = Hero("Blah", 100, "the Blah")
def test_hero_name(self):
self.assertEqual(self.h.name, "Blah")
def test_known_as(self):
self.assertEqual("Blah the Blah", self.h.known_as())
def test_get_health(self):
self.assertEqual(100, self.h.get_health())
def test_is_alive_full_health(self):
self.assertEqual(True, self.h.is_alive())
def test_take_healing(self):
self.h.take_damage(50)
self.assertEqual(True, self.h.take_healing(30))
self.assertEqual(80, self.h.get_health())
def test_take_more_healing_than_needed(self):
self.h.take_damage(50)
self.assertEqual(50, self.h.get_health())
self.assertEqual(False, self.h.take_healing(70))
self.assertEqual(100, self.h.get_health())
def test_damage_hero(self):
self.assertEqual(True, self.h.take_damage(50))
self.assertEqual(50, self.h.get_health())
def test_damage_hero_with_more_points_than_he_has_in_health(self):
self.assertEqual(False, self.h.take_damage(200))
self.assertEqual(0, self.h.get_health())
self.assertEqual(False, self.h.is_alive())
def test_healing(self):
self.h.take_damage(50)
self.assertEqual(50, self.h.get_health())
self.assertEqual(True, self.h.take_healing(50))
self.assertEqual(100, self.h.get_health())
def test_healing_with_more_points_than_are_needed(self):
self.h.take_damage(50)
self.assertEqual(50, self.h.get_health())
self.assertEqual(False, self.h.take_healing(150))
self.assertEqual(100, self.h.get_health())
def test_heal_dead_hero(self):
self.h.take_damage(100)
self.assertEqual(False, self.h.is_alive())
self.assertEqual(False, self.h.take_healing(30))
self.assertEqual(0, self.h.get_health())
def test_equip_weapon(self):
w = Weapon("sword", 50, 0.7)
self.assertEqual(True, self.h.equip_weapon(w))
self.assertEqual(w, self.h.weapon)
def test_attack(self):
self.assertEqual(10, self.h.attack())
w = Weapon("sword", 50, 0)
self.assertEqual(True, self.h.equip_weapon(w))
self.assertEqual(50, self.h.attack())
def test_fail_equipment(self):
self.assertEqual(False, self.h.equip_weapon("not a weapon"))
def test_equipment(self):
w = Weapon("grandma's cake", 99, 0.5)
self.h.equip_weapon(w)
self.assertEqual(w.type, self.h.weapon.type)
w_second = Weapon("grandpa's tong", 100, 1.0)
self.h.equip_weapon(w_second)
self.assertEqual(w_second.type, self.h.weapon.type)
class EntityTest(unittest.TestCase):
def setUp(self):
self.shosh_hero = Hero('Shosh', 100, 'GraveRobber')
self.zaithan_orc = Orc('Zaithan', 150, 0.5)
self.destroyer_weapon = Weapon('Destroyer Axe', 30, 0.7)
self.crystal_weapon = Weapon('Crystal Dagger', 15, 0.2)
self.molten_weapon = Weapon('Molten Sword', 27, 0.4)
def test_init(self):
self.assertEqual(self.shosh_hero.name, 'Shosh')
self.assertEqual(self.shosh_hero.health, 100)
self.assertEqual(self.shosh_hero.nickname, 'GraveRobber')
def test_get_health(self):
self.assertEqual(self.shosh_hero.get_health(), 100)
def test_is_alive(self):
self.assertTrue(self.shosh_hero.is_alive())
def test_is_dead(self):
self.shosh_hero.health = 0
self.assertFalse(self.shosh_hero.is_alive())
def test_take_damage_integer_value(self):
self.shosh_hero.take_damage(25)
self.assertEqual(self.shosh_hero.get_health(), 75)
def test_take_damage_decimal_value(self):
self.shosh_hero.take_damage(0.5)
self.assertEqual(self.shosh_hero.get_health(), 99.5)
def test_take_huge_amount_of_damage(self):
self.shosh_hero.take_damage(150)
self.assertEqual(self.shosh_hero.get_health(), 0)
def test_take_huge_amount_of_damage_decimal(self):
self.shosh_hero.take_damage(120.5)
self.assertEqual(self.shosh_hero.get_health(), 0)
def test_take_healing_when_dead(self):
self.shosh_hero.health = 0
self.assertFalse(self.shosh_hero.take_healing(30))
def test_take_hiper_super_big_healing(self):
self.shosh_hero.health = 70
self.assertTrue(self.shosh_hero.take_healing(200))
self.assertEqual(self.shosh_hero.health, self.shosh_hero.get_health())
def test_take_healing(self):
self.shosh_hero.health = 20
self.assertTrue(self.shosh_hero.take_healing(50))
self.assertEqual(self.shosh_hero.health, 70)
def test_has_weapon(self):
self.zaithan_orc.weapon = None
self.shosh_hero.weapon = self.crystal_weapon
self.assertTrue(self.shosh_hero.has_weapon())
self.assertFalse(self.zaithan_orc.has_weapon())
def test_equip_weapon(self):
self.shosh_hero.equip_weapon(self.destroyer_weapon)
self.assertTrue(self.shosh_hero.has_weapon())
self.assertEqual(self.shosh_hero.weapon.type, 'Destroyer Axe')
def test_equip_weapon_and_discard_the_old_one(self):
self.assertFalse(self.zaithan_orc.has_weapon())
self.zaithan_orc.equip_weapon(self.crystal_weapon)
self.assertTrue(self.zaithan_orc.has_weapon())
self.assertEqual(self.zaithan_orc.weapon.type, 'Crystal Dagger')
self.zaithan_orc.equip_weapon(self.molten_weapon)
self.assertTrue(self.zaithan_orc.has_weapon())
self.assertNotEqual(self.zaithan_orc.weapon.type, 'Crystal Dagger')
self.assertEqual(self.zaithan_orc.weapon.type, 'Molten Sword')
def test_attack_without_weapon(self):
self.assertEqual(self.shosh_hero.attack(), 0)
def test_attack_with_weapon(self):
self.shosh_hero.equip_weapon(self.destroyer_weapon)
self.assertIn(self.shosh_hero.attack(), [30, 60])
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()
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 Battle:
def __init__(self):
self.hero = Hero()
self.villain = Villain()
def battle(self):
self.battle_beginner()
for x in range(21):
if self.hero.health <= 0 or self.villain.health <= 0:
print('Game Completed')
self.winner()
break
else:
if x == 20:
self.winner()
else:
if Hero.attacker:
print('Battle number ', x)
self.hero.attack(self.villain)
else:
print('Battle number ', x)
self.villain.attack(self.hero)
def battle_beginner(self):
if self.hero.speed > self.villain.speed:
print(
"hero.speed is: %s, hero.health is: %s , villain.speed is %s, villain.health is %s"
% (self.hero.speed, self.hero.health, self.villain.speed,
self.villain.health))
Hero.attacker = True
if self.hero.speed < self.villain.speed:
print(
"hero.speed is: %s, hero.health is: %s , villain.speed is %s, villain.health is %s"
% (self.hero.speed, self.hero.health, self.villain.speed,
self.villain.health))
Hero.attacker = False
if self.hero.speed == self.villain.speed:
print(
"hero.speed is: %s, hero.health is: %s , villain.speed is %s, villain.health is %s"
% (self.hero.speed, self.hero.health, self.villain.speed,
self.villain.health))
if self.hero.luck > self.villain.luck:
print(
"hero.luck is: %s, hero.health is: %s ,villain.luck is: %s, villain.health is: %s"
% (self.hero.luck, self.hero.health, self.villain.luck,
self.villain.health))
Hero.attacker = True
else:
print(
"hero.luck is: %s, hero.health is: %s ,villain.luck is: %s, villain.health is: %s"
% (self.hero.luck, self.hero.health, self.villain.luck,
self.villain.health))
Hero.attacker = False
def winner(self):
if self.hero.health <= 0 and self.villain.health > 0:
print(
"villain is the winner, where villain.health is %s, and hero.health is %s"
% (self.villain.health, self.hero.health))
if self.hero.health > 0 and self.villain.health <= 0:
print(
"hero is the winner, where hero.health is %s, and villain.health is %s"
% (self.hero.health, self.villain.health))
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 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 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.hero = Hero(
name="Bron",
title="Dragonslayer",
health=100,
mana=100,
regeneration_rate=2
)
def test_known_as(self):
self.assertEqual(self.hero.known_as(), "Bron the Dragonslayer")
def test_dead_hero(self):
self.hero.take_damage(120)
self.assertFalse(self.hero.is_alive())
def test_regenerate(self):
self.hero.regenerate()
self.assertEqual(self.hero.health, 102)
self.assertEqual(self.hero.mana, 102)
def test_regenerate_dead_hero(self):
self.hero.take_damage(120)
with self.assertRaises(Exception):
self.hero.regenerate()
def test_string_representation(self):
expected_string = """Bron the Dragonslayer: \
health 100, mana 100\n"""
self.assertEqual(str(self.hero), expected_string)
def test_string_representation_with_weapon(self):
from weapon import Weapon
self.hero.equip_weapon(Weapon("Sword", 20))
expected_string = """Bron the Dragonslayer: \
health 100, mana 100\nweapon: Sword: damage 20\n"""
self.assertEqual(str(self.hero), expected_string)
def test_string_representation_with_spell(self):
from spell import Spell
self.hero.learn_spell(Spell("Fire", 20, 4, 2))
expected_string = """Bron the Dragonslayer: \
health 100, mana 100\nspell: Fire: damage 20, mana 4, range 2\n"""
self.assertEqual(str(self.hero), expected_string)
def test_string_representation_with_weapon_and_spell(self):
from weapon import Weapon
from spell import Spell
self.hero.equip_weapon(Weapon("Sword", 20))
self.hero.learn_spell(Spell("Fire", 20, 4, 2))
expected_string = """Bron the Dragonslayer: \
health 100, mana 100\nweapon: Sword: damage 20\n\
spell: Fire: damage 20, mana 4, range 2\n"""
self.assertEqual(str(self.hero), expected_string)
def test_atack_enemy_with_none(self):
from enemy import Enemy
enemy = Enemy(health=100, mana=100, damage=20, mana_cost=2)
self.assertIsNone(self.hero.attack(enemy, 'weapon'))
self.assertIsNone(self.hero.attack(enemy, 'spell'))
self.assertEqual(enemy.health, 100)
def test_atack_enemy_with_weapon(self):
from enemy import Enemy
enemy = Enemy(health=100, mana=100, damage=20, mana_cost=2)
from weapon import Weapon
self.hero.equip_weapon(Weapon("Sword", 20))
self.hero.attack(enemy, 'weapon')
self.assertEqual(enemy.health, 80)
def test_atack_enemy_with_spell(self):
from enemy import Enemy
enemy = Enemy(health=100, mana=100, damage=20, mana_cost=2)
from spell import Spell
self.hero.learn_spell(Spell("Fire", 20, 4, 2))
self.hero.attack(enemy, 'spell')
self.assertEqual(enemy.health, 80)
self.assertEqual(self.hero.mana, 96)
def test_atack_enemy_with_random(self):
from enemy import Enemy
enemy = Enemy(health=100, mana=100, damage=20, mana_cost=2)
from weapon import Weapon
from spell import Spell
self.hero.equip_weapon(Weapon("Sword", 20))
self.hero.learn_spell(Spell("Fire", 20, 4, 2))
self.hero.attack(enemy)
self.assertEqual(enemy.health, 80)
self.assertEqual(self.hero.mana, 100)
def test_atack_dead_enemy(self):
from enemy import Enemy
enemy = Enemy(health=100, mana=100, damage=20, mana_cost=2)
enemy.take_damage(120)
with self.assertRaises(ValueError):
self.hero.attack(enemy)
def test_attack_not_enemy(self):
from character import Character
character = Character(health=100, mana=100)
with self.assertRaises(TypeError):
self.hero.attack(character)
class Game(object):
def __init__(self, canvas):
self.canvas = canvas
self.hero = Hero()
self.map = Map(self.hero, self.canvas)
self.font_status = font.Font(size=11)
self.font_game_over = font.Font(size=25)
def is_hero_dead(self):
return self.hero.current_hp <= 0
def is_monster_dead(self, monster):
return monster.hp <= 0
def is_boss_dead(self, monster):
if monster.position == self.map.boss_position()[0].position:
return self.is_monster_dead(monster)
def combat(self):
if self.is_hero_dead():
self.canvas.delete('all')
self.draw_end_screen()
monster = self.map.get_monster()[0]
self.hero.attack(monster)
if self.is_boss_dead(monster):
self.hero.level_up()
self.new_level_buff()
self.map.generate_level()
self.hero.position = {'x': 0, 'y': 0}
self.draw_map()
if type(monster) == Skeleton:
self.map.map_texture.remove(monster)
self.hero.level_up()
def random_chance(self):
return random.randrange(0, 100)
def new_level_buff(self):
if self.random_chance() >= 90:
self.hero.current_hp = self.hero.hp
elif self.random_chance() >= 60:
self.hero.current_hp += self.hero.current_hp // 3
if self.hero.current_hp > self.hero.hp:
self.hero.current_hp = self.hero.hp
else:
self.hero.current_hp += self.hero.current_hp // 10
if self.hero.current_hp > self.hero.hp:
self.hero.current_hp = self.hero.hp
def move_route(self, key):
# if self.hero.move_count == 2:
# print("move")
# self.map.move_monsters()
# self.draw_map()
# self.hero.move_count = 0
pressed_key = key.keysym
if pressed_key == 'Up':
self.hero.move_up()
if not self.map.is_valid_move():
self.hero.move_down()
elif pressed_key == 'Down':
self.hero.move_down()
if not self.map.is_valid_move():
self.hero.move_up()
elif pressed_key == 'Right':
self.hero.move_right()
if not self.map.is_valid_move():
self.hero.move_left()
elif pressed_key == 'Left':
self.hero.move_left()
if not self.map.is_valid_move():
self.hero.move_right()
elif pressed_key == 'space':
if self.map.is_valid_move():
self.combat()
def draw_map(self):
if self.is_hero_dead():
self.draw_end_screen()
for i in self.map.map_texture:
i.draw()
self.draw_hero(self.hero.position['x'], self.hero.position['y'])
self.draw_hero_status_bar()
if self.map.is_valid_attack():
self.draw_monster_status_bar(self.map.get_monster()[0])
def draw_hero(self, x, y):
self.canvas.create_image(x * 72, y * 72, image=self.hero.current_img, anchor=NW)
def draw_hero_status_bar(self):
self.canvas.delete("status")
self.canvas.create_text(5, 722, text=self.hero, justify=CENTER, tags="status", anchor=NW, font=self.font_status)
def draw_monster_status_bar(self, monster):
self.canvas.create_text(400, 722, text=monster, tags="status", anchor=NW, font=self.font_status, fill="red")
def draw_end_screen(self):
self.canvas.delete('all')
self.canvas.create_text(300, 350, text="You died", anchor=NW, font=self.font_game_over, fill="red")
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.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 Game:
def __init__(self, levels):
self.hero = None
self.levels = levels
self.dungeon = None
self.finished = False
def __narrator(self):
welcome = f"""----Hello, my little friend----\n\
Welcome to our world of adventures. You will have to pass {self.levels} \
to end this game. Follow my instructions:\n"""
print(welcome)
name = input("Enter your character's name: >>")
title = input("Enter your character's title: >>")
self.hero = Hero(name=name,
title=title,
health=100,
mana=100,
regeneration_rate=5)
directions = f"""Hello, {self.hero.known_as()}, nice to meet you!\n
Soon you will see the first map you have to pass. To move through it you can use:\n\
d - down\nu - up\nr - right\nl - left\n"""
symbols = """Also, there is some special symbols in your way:\n\
# - walls\n. - free space\n\
H - you are here\nE - there is an enemy here\nT - there is a treasure here\nG - this is a gate \
to the next level\n"""
battle_instructions = """In your journey through this land you will meen some enemies. \
In the battles with them you will have to choose your action:\n\
r - regenerate health and mana\nw - attack with a weapon\ns - attack with a spell\n- - don't attack at all\n
Wish you luck!"""
print(directions)
print(symbols)
print(battle_instructions)
def __enter_direction(self):
direction = input(">>")
direction_list = {"d": "down", "u": "up", "l": "left", "r": "right"}
return direction_list[direction]
def __enter_attack_weapon(self):
weapon = input("attack by (r/w/s/-) >>")
while weapon == "r":
self.hero.regenerate()
print("health:", self.hero.health, "mana:", self.hero.mana)
weapon = input("attack by (r/w/s/-) >>")
weapon_list = {"w": "weapon", "s": "spell", "-": None}
return weapon_type[weapon]
def __fight(self):
print("----in fight----")
print(str(self.hero), "vs\n", str(self.dungeon.enemy))
while self.hero.is_alive() and self.dungeon.enemy.is_alive():
try:
self.hero.attack(self.dungeon.enemy,
self.__enter_attack_weapon())
self.dungeon.enemy.attack(self.hero)
except Exception:
pass
print(str(self.hero), str(self.dungeon.enemy))
if self.hero.is_alive():
print("You win!")
else:
print("You are dead!")
self.dungeon.finished = True
self.game.finished = True
self.dungeon.enemy = None
self.dungeon.battle = False
def __play(self):
while self.dungeon.finished is False:
self.dungeon.print_map()
try:
self.dungeon.move(self.__enter_direction())
except Exception:
print("You can't move in this direction!")
if self.dungeon.battle is True:
self.__fight()
def __next_level(self, level):
self.dungeon = Dungeon(level=level, hero=self.hero)
self.dungeon.load()
self.__play()
def start(self):
self.__narrator()
for level in range(1, self.levels + 1):
self.__next_level(level)
if self.finished:
print("You lost! Try again!")
return None
self.finished = True
print("Congratulations! You beat the game!")
