Game — Lazy Enemy Spawner

By the end of this lesson you can:

• Use a generator as the "source of enemies" in a game loop.
• Make difficulty scale by including the wave number in each yield.
• Compose a randomised monster generator with a difficulty ramp.
• Use itertools.islice to cap the run at N enemies.

In every wave-based game (Vampire Survivors, Plants vs Zombies, Pac-Man, Space Invaders), there's an enemy source that drips out monsters at the right moments. A generator is the perfect way to model it.

def enemies():
    wave = 1
    while True:
        yield wave
        wave += 1

# Use in a battle loop
for wave_no in enemies():
    print(f"Wave {wave_no} arriving!")
    if wave_no > 5:
        break

The Monster class — reused from L3-09

import random

class Monster:
    def __init__(self, name, hp, attack):
        self.name = name; self.hp = hp; self.attack = attack
    def is_alive(self):
        return self.hp > 0
    def take_damage(self, n):
        self.hp = max(0, self.hp - n)
    def __repr__(self):
        return f"{self.name}(HP {self.hp}, ATK {self.attack})"

A spawner generator

Each yield builds a fresh monster, scaled by wave number.

def spawn_enemies():
    """Infinite spawner — difficulty rises with each wave."""
    types = ["Goblin", "Orc", "Skeleton", "Imp", "Wraith"]
    wave = 1
    while True:
        # Each wave: name from the type pool, HP and ATK scale up
        kind = random.choice(types)
        hp   = 20 + wave * 5 + random.randint(-5, 5)
        atk  = 4  + wave * 2 + random.randint(-1, 1)
        yield Monster(f"{kind}-W{wave}", hp, atk)
        wave += 1

Each call to next(spawn_enemies()) produces a tougher monster. The wave counter lives inside the generator — it remembers between calls.

The game loop

hero = Monster("Aisyah", hp=100, attack=15)

for monster in spawn_enemies():
    print(f"\nWave incoming: {monster}")

    while monster.is_alive() and hero.is_alive():
        # Hero strikes first
        monster.take_damage(hero.attack + random.randint(-2, 2))
        if monster.is_alive():
            hero.take_damage(monster.attack + random.randint(-1, 1))

    if not hero.is_alive():
        print("\n💀 Hero fell.")
        break
    print(f"  ✓ Defeated {monster.name}. Hero {hero.hp}/100.")

    # Tiny rest
    hero.hp = min(100, hero.hp + 5)

The for-loop consumes one monster per pass. The generator yields a fresh one each time. The loop breaks when the hero dies. The spawner never knows or cares how long the run lasted.

Capping the run with islice

What if you want to stop after, say, 10 waves regardless? Wrap with islice:

from itertools import islice

# Take at most 10 enemies
for monster in islice(spawn_enemies(), 10):
    ...

Now there are two exits: hero dies, or 10 waves complete. The generator stays infinite; islice bounds the iteration.

Why a generator instead of a list?

List of all possible monsters (BAD):
- Can't enumerate "all possible" — there are infinite waves
- Even bounding to 1000 wastes memory if the hero dies in wave 3
- Order is fixed once the list is built

Generator (GOOD):
- Each enemy is created at the moment it's needed
- Memory cost = one monster at a time
- The generator can use randomness, time, hero state
- Stops cleanly when the consumer stops asking

Multiple-yield-per-wave

What if every wave should be a group of monsters? Easy — yield each one:

def spawn_packs():
    """Each wave yields multiple monsters."""
    wave = 1
    while True:
        pack_size = 1 + wave // 3                   # bigger packs over time
        for i in range(pack_size):
            yield Monster(f"Goblin-W{wave}-{i+1}",
                          hp=20 + wave * 3,
                          attack=4 + wave)
        wave += 1

Two loops, one infinite. The outer counts waves; the inner yields each monster in the pack. Pure compose.

Save as spawner.py:

# spawner.py — generator-driven wave game

import random
from itertools import islice

# --- Classes ---

class Fighter:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.max_hp = hp
        self.attack = attack

    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 __repr__(self):
        return f"{self.name}(HP {self.hp}/{self.max_hp}, ATK {self.attack})"


# --- The infinite spawner ---

MONSTER_TYPES = ["Goblin", "Orc", "Skeleton", "Imp", "Wraith", "Troll"]

def spawn_enemies():
    wave = 1
    while True:
        kind = random.choice(MONSTER_TYPES)
        hp   = 25 + wave * 6 + random.randint(-5, 5)
        atk  = 4  + wave * 2 + random.randint(-1, 1)
        yield wave, Fighter(f"{kind}-W{wave}", hp, atk)
        wave += 1


# --- The battle ---

def fight(hero, monster):
    while hero.is_alive() and monster.is_alive():
        dmg = hero.attack + random.randint(-2, 2)
        monster.take_damage(dmg)
        print(f"  ⚔  {hero.name} hits {monster.name} for {dmg}. "
              f"({monster.name} HP {monster.hp}/{monster.max_hp})")
        if not monster.is_alive(): return

        dmg = monster.attack + random.randint(-1, 1)
        hero.take_damage(dmg)
        print(f"  ⚔  {monster.name} hits for {dmg}. "
              f"({hero.name} HP {hero.hp}/{hero.max_hp})")


# --- The run ---

random.seed(42)            # reproducible
hero = Fighter("Aisyah", hp=120, attack=18)
spawner = spawn_enemies()

# Cap at 15 waves max
for wave, enemy in islice(spawner, 15):
    print(f"\n=== Wave {wave}: {enemy} ===")
    fight(hero, enemy)

    if not hero.is_alive():
        print(f"\n💀 {hero.name} fell on wave {wave}.")
        break

    print(f"  ✓ {hero.name} clears the wave. HP {hero.hp}/{hero.max_hp}.")
    hero.heal(10)
else:
    print("\n🏆 Cleared 15 waves!")

print(f"\nFinal: {hero}")

Sample output (truncated)

=== Wave 1: Goblin-W1(HP 36/36, ATK 7) ===
  ⚔  Aisyah hits Goblin-W1 for 17. (Goblin-W1 HP 19/36)
  ⚔  Goblin-W1 hits for 6. (Aisyah HP 114/120)
  ⚔  Aisyah hits Goblin-W1 for 19. (Goblin-W1 HP 0/36)
  ✓ Aisyah clears the wave. HP 114/120.

=== Wave 2: Orc-W2(HP 39/39, ATK 9) ===
  ⚔  Aisyah hits Orc-W2 for 17.
  ...

=== Wave 6: Wraith-W6(HP 60/60, ATK 16) ===
  ⚔  Aisyah hits Wraith-W6 for 18. (Wraith-W6 HP 42/60)
  ⚔  Wraith-W6 hits for 17. (Aisyah HP 12/120)
  ...

💀 Aisyah fell on wave 6.

Final: Aisyah(HP 0/120, ATK 18)

Read the diff

The spawner is six lines and infinite. The game loop is six lines and bounded by either "hero dies" or "15 waves complete". islice caps the run; for/else handles "survived everything". No list of enemies ever exists — each is created when needed and discarded when defeated.

A generator is the right shape for "spawn an enemy on demand". The spawner stays infinite and pure — it produces one fresh monster per yield, scaled by wave number. The game loop consumes one monster per pass and decides when to stop (hero dies, slice exhausts). State that's "owned by the spawner" (wave counter, monster type pool) stays inside it. State that's "about the run" (hero, XP, score) stays outside. Two well-separated roles.