Python Hero.equip方法代码示例

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
class TestHero(unittest.TestCase):
    def setUp(self):
        self.hero1 = Hero("Arthur", "knight", 100, 100, 2)
        self.weapon1 = Weapon(name="The Axe of Destiny", damage=20)
        self.spell1 = Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2)

    def test_init(self):
        self.assertTrue(isinstance(self.hero1, Hero))

    def test_known_as(self):
        self.assertEqual(self.hero1.known_as(), "Arthur the knight")

    def test_is_alive_and_take_damage(self):
        self.assertTrue(self.hero1.is_alive())
        self.hero1.take_damage(70)
        self.assertTrue(self.hero1.is_alive())
        self.assertEqual(self.hero1.get_health(), 30)
        self.hero1.take_damage(40)
        self.assertFalse(self.hero1.is_alive())

    def test_take_healing(self):
        self.hero1.take_damage(50)
        self.hero1.take_healing(20)
        self.assertTrue(self.hero1.get_health() == 70)
        self.assertTrue(self.hero1.take_healing(10))
        self.hero1.take_damage(80)
        self.assertFalse(self.hero1.take_healing(20))

    def test_equip(self):
        self.hero1.equip(self.weapon1)
        self.assertIsInstance(self.hero1.weapon, Weapon)

    def test_learn(self):
        self.hero1.learn(self.spell1)
        self.assertIsInstance(self.hero1.spell, Spell)

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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")

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
def main():
    h = Hero("Bron", "Dragonslayer", 100, 100, 2)
    w = Weapon("The Axe of Destiny", 20)
    h.equip(w)
    s = Spell("Fireball", 20, 50, 2)
    h.learn(s) 
    dmap = Dungeon("map.txt")
    dmap.open_map()
    dmap.spawn(h)
    dmap.move_hero("right")
    dmap.move_hero("down")
    dmap.move_hero("down")
    dmap.get_map()
    dmap.hero_attack(by="spell")
    dmap.get_map()

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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)

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
    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()

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
def main():
    m = Dungeon('level1.txt')
    ana = Hero (name="Ana", title="Cloud", health=100, mana=330, mana_regeneration_rate=7)
    enemy = Enemy(health = 160, mana=100, damage=20)
    w = Weapon(name="The Axe of Destiny", damage=20)
    s = Spell(name="Fireball", damage=20, mana_cost=10, cast_range=3)
    ana.equip(w)
    ana.learn(s)
    m.spawn(ana)
    m.hero = ana
    m.enemy = enemy
    m.move_hero('right')

    m.print_map()
    m.move_hero('down')
    m.print_map()
    m.move_hero('down')
    m.print_map()
    m.move_hero('down')
    m.print_map()
    m.hero_attack(by='spell')

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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)

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
                    self.hero.take_damage(damage)
                    print(spell.format(self.hero.spell.name,
                                       self.hero.spell.damage, self.enemy.health))
                elif self.enemy.weapon is not None and self.hero_possition == self.enemy_possition:
                    weapon = "Enemy hits with {} for {} dmg. Hero health is {}"
                    damage = self.enemy.attack(by='weapon')
                    self.hero.take_damage(damage)
                    print(weapon.format(self.hero.weapon.name,
                                        self.hero.weapon.damage, self.enemy.health))
                elif self.hero_possition == self.enemy_possition:
                    hands = "Enemy hits hero for {} dmg. Hero health is {}."
                    damage = self.enemy.attack()
                    self.hero.take_damage(damage)
                    print(hands.format(self.enemy.damage, self.hero.health))
                else:
                    self._move_enemy()

        return self.hero if self.hero.is_alive() else self.enemy


if __name__ == '__main__':
    weapon = Weapon('WW', 2)
    spell = Spell('SS', 5, 40, 2)
    hero = Hero()
    hero.equip(weapon)
    hero.learn(spell)
    hero_possition = (3, 1)
    enemy_possition_direction = (3, 2)
    enemy = Enemy()
    Fight(hero, enemy, hero_possition, enemy_possition_direction).start()

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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):
#.........这里部分代码省略.........

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
                    else:
                        print('enemy is dead')
                        return True
        else:
            print('The hero can use only spell or weapon')





map = Dungeon('dungeon.txt')
hero = Hero(name = 'Django', title = 'The Unchained', health = 100, mana = 100, mana_regen  = 2)
enemy = Enemy(health = 80, mana = 100, damage = 20)
w = Weapon('Axe', 20)
s = Spell('Magic', 20, 50, 2)
hero.equip(w)
hero.learn(s)

print(hero.get_health())
print(enemy.get_health())

map._pick_treasure()


map._print_map()
map._spawn('Batman')
map._move_hero('right')
map._print_map()
map._move_hero('down')
map._print_map()
map._move_hero('down')

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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)

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
from hero import Hero
from dungeon import Dungeon
from weapons_and_spells import Weapon, Spell


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.print_map()
dungeon.move_hero("right")
dungeon.move_hero("down")
dungeon.print_map()
dungeon.try_range_attack()
dungeon.move_hero("down")
dungeon.move_hero("down")
dungeon.try_range_attack()
dungeon.print_map()
dungeon.move_hero("right")
dungeon.move_hero("right")
dungeon.move_hero("right")
dungeon.move_hero("right")
dungeon.move_hero("up")
dungeon.print_map()
dungeon.move_hero("down")

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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())

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]
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)
#.........这里部分代码省略.........

# 需要导入模块: from hero import Hero [as 别名]
# 或者: from hero.Hero import equip [as 别名]

#.........这里部分代码省略.........
                    curr_map[row][col] = random.choice(path_elems)
                else:
                    curr_map[row][col] = 'G'
                road_len -= 1
                to_choose_from = []
            else:
                curr_map[row][col] = '.'
                dungeon.set_map(curr_map)
                to_choose_from = dungeon.adj(row, col)
                while to_choose_from == []:
                    elem = path_to_curr_elem.pop()
                    dungeon.set_map(curr_map)
                    to_choose_from = dungeon.adj(elem[0], elem[1])
                row = elem[0]
                col = elem[1]
        # adding obsticles(such English, much fail)
        curr_map = [['#' if elem == 0 else elem for elem in row]
                    for row in curr_map]
        dungeon.set_map(curr_map)
        dungeon.spawn(dungeon.get_hero())
        return dungeon

    def print_map(self):
        printable = ""
        for row in range(self.__rows):
            for col in range(self.__cols):
                printable += (self.__map[row][col] + ' ')
            printable += '\n'
        printable = printable[:-1]
        print(printable)

    def spawn(self, hero):
        weapon = Weapon("Fart gun", 50)
        self.__hero.equip(weapon)
        self.__hero_pos = 'E'
        self.__hero_pos = self.__last_spawn
        self.__hero_pos = (0, 0)
        self.__map[self.__hero_pos[0]][self.__hero_pos[1]] = 'H'
        self.print_map()

    def hero_atack(self):
        enemy = Enemy(health=random.randrange(50, 150),
                      mana=random.randrange(20, 100),
                      damage=random.randrange(20, 80))

        # finding the enemy
        distance = 0
        curr_vec = 1
        row = self.__hero_pos[0]
        col = self.__hero_pos[1]
        choices = []
        range_to_enemy = 0
        atack_range = self.__hero.get_cast_range()

        if atack_range:
            while row - curr_vec >= 0 and curr_vec <= atack_range:
                if self.__map[row - curr_vec][col] == '#':
                    break
                choices.append((row - curr_vec, col))
                curr_vec -= 1

            curr_vec = 1
            while col + curr_vec < self.__cols and curr_vec <= atack_range:
                if self.__map[row][col + curr_vec] == '#':
                    break
                choices.append((row, col + curr_vec))