Game — Dungeon Hero Class

By the end of this lesson you can:

• Design a Hero class with several attributes and several methods.
• Build a turn-based duel loop using two instances.
• Add an XP/level system with a method that triggers automatically when XP crosses a threshold.
• Spot how class methods on TWO instances (hero.attack(monster)) form interaction.

Combat involves two characters — attacker and victim. The Pythonic way is one method on the attacker that takes the victim as a parameter:

hero.attack(monster)            # hero attacks monster
monster.attack(hero)            # monster attacks back

Inside the method, self is the attacker and the parameter is the victim. The method modifies both:

def attack(self, victim):
    damage = self.attack_power
    victim.take_damage(damage)

That's the whole interaction pattern. Two objects, one method, mutual state change.

The attributes

name          str       "Aisyah"
hp            int       current health
max_hp        int       cap for healing
attack_power  int       damage per hit
inventory     list      items the hero carries
xp            int       experience points, starts at 0
level         int       starts at 1

The methods

is_alive(self)               True if hp > 0
take_damage(self, n)         hp -= n, clamped at 0
heal(self, n)                hp += n, clamped at max_hp
attack(self, victim)         victim takes self.attack_power damage
pick_up(self, item)          inventory.append
gain_xp(self, n)             increase XP, level up if threshold reached
_level_up(self)              private-ish helper (we'll learn about _ in L3-10)
report(self)                 multi-line status banner

Levelling formula

The classic: each level requires level × 100 XP. After levelling up, max_hp grows by 20, attack_power by 2, and HP refills to full.

def gain_xp(self, n):
    self.xp += n
    while self.xp >= self.level * 100:
        self.xp -= self.level * 100
        self._level_up()

def _level_up(self):
    self.level += 1
    self.max_hp += 20
    self.attack_power += 2
    self.hp = self.max_hp
    print(f"  ✨ {self.name} leveled up to {self.level}!")

The while handles multi-level jumps — gaining 500 XP at level 1 levels you twice. The leading underscore in _level_up signals "private helper, don't call from outside" — formalised in PY-L3-10.

The duel loop

def duel(hero, monster):
    while hero.is_alive() and monster.is_alive():
        hero.attack(monster)
        if not monster.is_alive():
            break
        monster.attack(hero)
    return hero if hero.is_alive() else monster

Two-object turn-based combat in 6 lines. The function operates on the instances; the rules live in the methods.

Save as dungeon.py:

# dungeon.py — Hero class + a duel

import random

class Hero:
    def __init__(self, name, hp=100, attack_power=12):
        self.name         = name
        self.hp           = hp
        self.max_hp       = hp
        self.attack_power = attack_power
        self.inventory    = []
        self.xp           = 0
        self.level        = 1

    def is_alive(self):
        return self.hp > 0

    def take_damage(self, n):
        self.hp = max(0, self.hp - n)

    def heal(self, n):
        self.hp = min(self.max_hp, self.hp + n)

    def attack(self, victim):
        dmg = self.attack_power + random.randint(-2, 2)
        victim.take_damage(dmg)
        print(f"  {self.name} hits {victim.name} for {dmg}. "
              f"({victim.name} HP {victim.hp}/{victim.max_hp})")

    def pick_up(self, item):
        self.inventory.append(item)
        print(f"  {self.name} picked up {item}.")

    def gain_xp(self, n):
        self.xp += n
        while self.xp >= self.level * 100:
            self.xp -= self.level * 100
            self._level_up()

    def _level_up(self):
        self.level        += 1
        self.max_hp       += 20
        self.attack_power += 2
        self.hp = self.max_hp
        print(f"  ✨ {self.name} leveled up to {self.level}!")

    def report(self):
        bar = "█" * (self.hp * 10 // self.max_hp) + "░" * (10 - self.hp * 10 // self.max_hp)
        return (f"{self.name} (Lv {self.level}) "
                f"HP {self.hp}/{self.max_hp} [{bar}] "
                f"ATK {self.attack_power}")


# Monster as a simpler class (we'll formalise this in PY-L3-09)
class Monster:
    def __init__(self, name, hp, attack_power):
        self.name = name; self.hp = hp; self.max_hp = hp
        self.attack_power = attack_power

    def is_alive(self):
        return self.hp > 0

    def take_damage(self, n):
        self.hp = max(0, self.hp - n)

    def attack(self, victim):
        dmg = self.attack_power + random.randint(-1, 1)
        victim.take_damage(dmg)
        print(f"  {self.name} hits {victim.name} for {dmg}. "
              f"({victim.name} HP {victim.hp}/{victim.max_hp})")


def duel(hero, monster):
    print(f"\n⚔  {hero.report()}\n   vs {monster.name} (HP {monster.hp})\n")
    turn = 1
    while hero.is_alive() and monster.is_alive():
        print(f"-- Turn {turn} --")
        hero.attack(monster)
        if monster.is_alive():
            monster.attack(hero)
        turn += 1
    if hero.is_alive():
        print(f"\n🏆 {hero.name} wins!")
        hero.gain_xp(80)
        hero.pick_up("gold coin")
    else:
        print(f"\n💀 {monster.name} wins. {hero.name} fell in the dungeon.")


# Play
aisyah = Hero("Aisyah", hp=80, attack_power=14)
goblin = Monster("Goblin", hp=40, attack_power=8)

duel(aisyah, goblin)
print("\n" + aisyah.report())
print("Inventory:", aisyah.inventory)

Sample output (numbers will vary)

⚔  Aisyah (Lv 1) HP 80/80 [██████████] ATK 14
   vs Goblin (HP 40)

-- Turn 1 --
  Aisyah hits Goblin for 13. (Goblin HP 27/40)
  Goblin hits Aisyah for 9. (Aisyah HP 71/80)
-- Turn 2 --
  Aisyah hits Goblin for 16. (Goblin HP 11/40)
  Goblin hits Aisyah for 8. (Aisyah HP 63/80)
-- Turn 3 --
  Aisyah hits Goblin for 14. (Goblin HP 0/40)

🏆 Aisyah wins!
  Aisyah picked up gold coin.

Aisyah (Lv 1) HP 63/80 [████████░░] ATK 14
Inventory: ['gold coin']

Read the diff

Every interaction is method-on-instance. hero.attack(goblin) calls hero's attack method, passing goblin as the victim. goblin.attack(hero) is the same shape with the roles swapped. The duel function knows nothing about HP arithmetic or damage — it just orchestrates turns. The HP bar uses string multiplication from Level 1. The split between Hero and Monster classes is intentional; tomorrow's lesson is about reusing code between them with inheritance.

The Hero class is everything from the last five lessons in one place. __init__ sets up attributes. Methods read and write self. Methods that take another instance as a parameter handle interactions like combat. A duel loop calls those methods turn after turn. An XP system mutates the hero's state automatically when thresholds are crossed. Tomorrow we'll address the elephant in the room — Hero and Monster share almost all their code — with inheritance.