Multiple Levels & Difficulty Curves

By the end of this lesson you can:

• Derive speed, spawn interval and max-enemies from a single level integer using simple formulas.
• Advance the level when the player reaches a score threshold and reschedule spawners.
• Run a game that visibly becomes harder as the level climbs.

We can derive several game settings from one number. Predict the output:

for lvl in range(1, 5):
    speed        = 3 + lvl
    spawn_secs   = max(0.5, 2.0 - lvl * 0.3)
    max_enemies  = lvl * 2
    print(f"L{lvl}: speed={speed}, spawn={spawn_secs:.1f}s, max={max_enemies}")

L1: speed=4, spawn=1.7s, max=2
L2: speed=5, spawn=1.4s, max=4
L3: speed=6, spawn=1.1s, max=6
L4: speed=7, spawn=0.8s, max=8

Think of a thermostat. One dial controls the whole heating system. Your level variable is that thermostat — turn it up by one and everything calibrates automatically.

The level-to-settings function

def get_settings(lvl):
    speed       = 3 + lvl              # pixels per frame
    spawn_secs  = max(0.5, 2.0 - lvl * 0.3)  # seconds between spawns
    max_enemies = lvl * 2              # cap on simultaneous enemies
    return speed, spawn_secs, max_enemies

Advancing to the next level

Check the score inside update(). When it crosses the threshold, increment level and reschedule the spawner:

def advance_level():
    global level, speed, max_enemies
    level += 1
    speed, spawn_secs, max_enemies = get_settings(level)
    clock.unschedule(spawn_enemy)
    clock.schedule_interval(spawn_enemy, spawn_secs)

Score threshold per level

LEVEL_THRESHOLD = 300   # score points needed to advance

def update():
    global score
    score += 1
    if score >= level * LEVEL_THRESHOLD:
        advance_level()

Imran builds on the endless runner. Save as levels.py. Only the new additions are shown — keep the PZ-38/39 foundation.

Part A — level state

# levels.py — difficulty-curve demo
import pgzrun
import random

WIDTH  = 600
HEIGHT = 300
GROUND_Y    = 240
GRAVITY     = 0.6
JUMP_SPEED  = 12
LEVEL_THRESHOLD = 300

level       = 1
speed       = 4
spawn_secs  = 1.7
max_enemies = 2
score       = 0
game_over   = False

player_x = 80
player_y = GROUND_Y
vy       = 0.0
ground_x = 0.0
rocks    = []

Part B — settings helper + spawner

def get_settings(lvl):
    spd   = 3 + lvl
    secs  = max(0.5, 2.0 - lvl * 0.3)
    maxen = lvl * 2
    return spd, secs, maxen

def spawn_rock():
    if len(rocks) < max_enemies:
        rocks.append({"x": WIDTH + 10, "h": random.randint(20, 40)})

clock.schedule_interval(spawn_rock, spawn_secs)

Part C — update with level advance

def update():
    global player_y, vy, ground_x, score, game_over
    global level, speed, spawn_secs, max_enemies
    if game_over:
        return
    vy += GRAVITY
    player_y += vy
    if player_y >= GROUND_Y:
        player_y = GROUND_Y
        vy = 0.0
    ground_x -= speed
    if ground_x <= -WIDTH:
        ground_x = 0.0
    for rock in rocks:
        rock["x"] -= speed
    rocks[:] = [r for r in rocks if r["x"] > -30]
    p_rect = Rect((player_x - 12, player_y - 28), (24, 28))
    for rock in rocks:
        if p_rect.colliderect(Rect((rock["x"] + 2, GROUND_Y - rock["h"]), (16, rock["h"]))):
            game_over = True
    score += 1
    if score >= level * LEVEL_THRESHOLD:
        level += 1
        speed, spawn_secs, max_enemies = get_settings(level)
        clock.unschedule(spawn_rock)
        clock.schedule_interval(spawn_rock, spawn_secs)

Part D — draw with level badge

def draw():
    if game_over:
        screen.fill("black")
        screen.draw.text("GAME OVER", center=(WIDTH // 2, HEIGHT // 2 - 20),
                         fontsize=56, color="red")
        screen.draw.text(f"Score: {score}  Level: {level}",
                         center=(WIDTH // 2, HEIGHT // 2 + 30), fontsize=28, color="white")
        return
    screen.fill("lightyellow")
    gx = int(ground_x)
    screen.draw.filled_rect(Rect((gx, GROUND_Y), (WIDTH, 60)), "saddlebrown")
    screen.draw.filled_rect(Rect((gx + WIDTH, GROUND_Y), (WIDTH, 60)), "saddlebrown")
    screen.draw.filled_rect(Rect((player_x - 15, player_y - 30), (30, 30)), "royalblue")
    for rock in rocks:
        screen.draw.filled_rect(Rect((rock["x"], GROUND_Y - rock["h"]), (20, rock["h"])), "dimgray")
    screen.draw.text(f"Score: {score}", topleft=(10, 10), fontsize=22, color="black")
    screen.draw.text(f"Level: {level}", topleft=(10, 34), fontsize=22, color="purple")

def on_key_down(key):
    global vy
    if key == keys.SPACE and player_y >= GROUND_Y:
        vy = -JUMP_SPEED

pgzrun.go()

A single level integer is the master dial for difficulty. Helper functions convert it into speed, spawn interval, and enemy cap using simple formulas. When the score passes level * THRESHOLD, increment level and re-derive all settings. Always clamp with max() or min() so extreme levels stay playable.