Lesson 25: Difficulty & DDA

For to-do 3, compute rate and let the existing last line do level + rate * dt; don't touch self.level inside the if. For to-do 2, remember that Director.update() calls compute_parameters every frame: anything that isn't inside that function won't survive. If you're unsure whether DDA is frame-rate independent, change clock.tick(60) to clock.tick(30) and time how long the level takes to climb one step.

If your instructor hands you the lab file, you will see a few extra lines marked lab runtime near the top and and frame_budget() in the loop. They let the instructor's checker run the program automatically; when you run it yourself they do nothing.

"""Adaptive Arena: Advanced Lesson 25 practice exercise (solution).

A small top-down arena shooter driven by one difficulty level (1 to 10). The
level feeds every tuning knob through its own curve, player-chosen assists
are applied on top, and three modes decide how the level changes:
1 = static, 2 = DDA (a gentle control loop, in levels per second),
3 = flow (only moves when you leave the flow channel).

Keys: WASD or arrows move, SPACE fires (hold it), 1/2/3 pick the mode,
8 toggles the shield assist, 9 toggles the slow-enemies assist.
Close the window to quit.
"""
import math
import random
from collections import deque
from dataclasses import dataclass

import pygame


WIDTH, HEIGHT = 900, 600
LEVEL_MIN, LEVEL_MAX, NORMAL = 1.0, 10.0, 5.0
PLAYER_SPEED = 240          # px/s
BULLET_SPEED = 520          # px/s
FIRE_COOLDOWN = 0.22        # seconds
CONTACT_DAMAGE = 20         # player hp lost when an enemy reaches you (before assists)
WINDOW = 15.0               # seconds of recent play that count as "performance"
TEXT = (235, 235, 235)
FLOW_COLORS = {"flow": (90, 220, 120), "boredom": (240, 210, 80), "anxiety": (240, 100, 90)}


@dataclass(frozen=True)
class Assists:
    shield: bool = False           # take half damage
    slow_enemies: bool = False     # enemies move 25% slower


def clamp(value, low, high):
    return max(low, min(high, value))


def compute_parameters(level, assists):
    """One level, many knobs, each with its own curve. Assists are applied LAST, every time,
    so recomputing the parameters can never wipe them out."""
    mult = level / NORMAL                              # 0.2 at level 1, 2.0 at level 10
    p = {
        "enemy_speed": 90 * mult ** 0.8,               # px/s: grows a bit slower than the level
        "enemy_hp": 20 * mult ** 1.2,                  # grows a bit faster than the level
        "spawn_interval": 1.6 / mult ** 0.7,           # seconds between spawns
        "player_damage": 10 * mult ** -0.5,            # shrinks, but never reaches 0
        "pickup_chance": 0.3 * mult ** -0.3,           # shrinks, but never reaches 0
        "damage_taken": 1.0,
    }
    if assists.slow_enemies:
        p["enemy_speed"] *= 0.75
    if assists.shield:
        p["damage_taken"] *= 0.5
    return p


class PerformanceWindow:
    """Counts events (shot, hit, kill, hurt) from the last `window` seconds."""
    def __init__(self, window=WINDOW):
        self.window = window
        self.events = deque()                          # (time in seconds, kind)

    def add(self, now, kind):
        self.events.append((now, kind))

    def trim(self, now):
        while self.events and now - self.events[0][0] > self.window:
            self.events.popleft()

    def count(self, kind):
        return sum(1 for _, k in self.events if k == kind)


def performance(window):
    """A 0..1 score from recent accuracy, kills and hits taken. Safe with no data (returns 0.5)."""
    shots, hits = window.count("shot"), window.count("hit")
    accuracy = hits / shots if shots else 0.5
    score = 0.5 + 0.4 * (accuracy - 0.5) + 0.04 * window.count("kill") - 0.12 * window.count("hurt")
    return clamp(score, 0.0, 1.0)


def flow_state(skill, challenge, band=0.25):
    """The flow channel: skill well above challenge is boredom, challenge well above skill is anxiety."""
    ratio = skill / max(challenge, 1e-6)
    if ratio > 1 + band:
        return "boredom"
    if ratio < 1 - band:
        return "anxiety"
    return "flow"


class Director:
    """Owns the difficulty level and changes it according to the mode."""
    def __init__(self, mode="dda", level=NORMAL, target=0.6, gain=2.0, deadband=0.08, max_rate=0.5):
        self.mode = mode
        self.level = level
        self.assists = Assists()
        self.target = target          # the performance we aim for (0..1)
        self.gain = gain              # levels per second per unit of error
        self.deadband = deadband      # errors smaller than this are ignored
        self.max_rate = max_rate      # never change faster than this many levels per second
        self.state = "flow"
        self.params = compute_parameters(level, self.assists)

    def skill_estimate(self, perf):
        return self.level * perf / self.target

    def update(self, perf, dt):
        self.state = flow_state(self.skill_estimate(perf), self.level)
        rate = 0.0
        if self.mode == "dda":
            error = perf - self.target
            if abs(error) > self.deadband:
                rate = clamp(self.gain * error, -self.max_rate, self.max_rate)
        elif self.mode == "flow":
            if self.state == "boredom":
                rate = self.max_rate / 2
            elif self.state == "anxiety":
                rate = -self.max_rate / 2
        self.level = clamp(self.level + rate * dt, LEVEL_MIN, LEVEL_MAX)
        self.params = compute_parameters(self.level, self.assists)

    def toggle(self, name):
        a = self.assists
        self.assists = Assists(shield=not a.shield if name == "shield" else a.shield,
                               slow_enemies=not a.slow_enemies if name == "slow" else a.slow_enemies)
        self.params = compute_parameters(self.level, self.assists)


class Enemy:
    def __init__(self, pos, hp):
        self.pos = pygame.Vector2(pos)     # float position: slow enemies still move
        self.hp = hp
        self.radius = 14

    def update(self, target, speed, dt):
        to_target = target - self.pos
        if to_target.length_squared() > 0:
            self.pos += to_target.normalize() * speed * dt


def spawn_point(rng):
    side = rng.randrange(4)
    if side == 0:
        return (rng.uniform(0, WIDTH), -20)
    if side == 1:
        return (rng.uniform(0, WIDTH), HEIGHT + 20)
    if side == 2:
        return (-20, rng.uniform(0, HEIGHT))
    return (WIDTH + 20, rng.uniform(0, HEIGHT))


class Arena:
    def __init__(self, seed=None):
        self.rng = random.Random(seed)
        self.director = Director()
        self.window = PerformanceWindow()
        self.player = pygame.Vector2(WIDTH / 2, HEIGHT / 2)
        self.facing = pygame.Vector2(0, -1)
        self.hp = 100.0
        self.enemies = []
        self.bullets = []                  # [pos, vel] pairs of Vector2
        self.spawn_timer = 0.0
        self.fire_timer = 0.0
        self.clock = 0.0                   # seconds since start
        self.score = 0
        self.deaths = 0
        self.history = deque(maxlen=300)   # (time, level) for the graph

    def update(self, move, firing, dt):
        self.clock += dt
        p = self.director.params
        if move.length_squared() > 0:
            self.facing = move.normalize()
            self.player += self.facing * PLAYER_SPEED * dt
            self.player.x = clamp(self.player.x, 15, WIDTH - 15)
            self.player.y = clamp(self.player.y, 15, HEIGHT - 15)

        self.fire_timer = max(0.0, self.fire_timer - dt)
        if firing and self.fire_timer == 0:
            self.bullets.append([pygame.Vector2(self.player), self.facing * BULLET_SPEED])
            self.fire_timer = FIRE_COOLDOWN
            self.window.add(self.clock, "shot")

        self.spawn_timer -= dt
        if self.spawn_timer <= 0:
            self.spawn_timer += p["spawn_interval"]
            self.enemies.append(Enemy(spawn_point(self.rng), p["enemy_hp"]))

        for b in self.bullets:
            b[0] += b[1] * dt
        self.bullets = [b for b in self.bullets if -20 < b[0].x < WIDTH + 20 and -20 < b[0].y < HEIGHT + 20]

        for e in self.enemies:
            e.update(self.player, p["enemy_speed"], dt)
            for b in self.bullets:
                if b[0].distance_to(e.pos) < e.radius + 4:
                    self.bullets.remove(b)
                    e.hp -= p["player_damage"]
                    self.window.add(self.clock, "hit")
                    break
            if e.hp <= 0:
                self.score += 1
                self.window.add(self.clock, "kill")
            elif e.pos.distance_to(self.player) < e.radius + 12:
                e.hp = 0                                   # it hits you and is used up
                self.hp -= CONTACT_DAMAGE * p["damage_taken"]
                self.window.add(self.clock, "hurt")
        self.enemies = [e for e in self.enemies if e.hp > 0]
        if self.hp <= 0:
            self.deaths += 1
            self.hp = 100.0
            self.enemies.clear()

        self.window.trim(self.clock)
        self.director.update(performance(self.window), dt)
        self.history.append((self.clock, self.director.level))

    def draw(self, screen, font):
        screen.fill((22, 24, 32))
        for e in self.enemies:
            pygame.draw.circle(screen, (230, 90, 90), e.pos, e.radius)
        for b in self.bullets:
            pygame.draw.circle(screen, (255, 230, 90), b[0], 4)
        pygame.draw.circle(screen, (90, 200, 250), self.player, 12)
        pygame.draw.line(screen, (250, 250, 250), self.player, self.player + self.facing * 18, 3)

        d, p = self.director, self.director.params
        assists = [n for n, on in (("shield", d.assists.shield), ("slow", d.assists.slow_enemies)) if on]
        lines = [f"Mode: {d.mode}   (1 static  2 DDA  3 flow)   Assists: {', '.join(assists) or 'none'}  (8, 9)",
                 f"Level {d.level:4.2f}   performance {performance(self.window):.2f}   target {d.target:.2f}",
                 f"Enemy speed {p['enemy_speed']:5.1f} px/s   hp {p['enemy_hp']:4.1f}   "
                 f"spawn every {p['spawn_interval']:.2f} s   your damage {p['player_damage']:.1f}",
                 f"HP {self.hp:5.1f}   score {self.score}   deaths {self.deaths}"]
        for i, text in enumerate(lines):
            screen.blit(font.render(text, True, TEXT), (10, 8 + i * 20))
        state = font.render(f"Flow state: {d.state}", True, FLOW_COLORS[d.state])
        screen.blit(state, (10, 90))

        # Level over the last 30 seconds (bottom-right graph).
        gx, gy, gw, gh = WIDTH - 250, HEIGHT - 110, 240, 100
        pygame.draw.rect(screen, (40, 44, 56), (gx, gy, gw, gh))
        pts = [(gx + gw - (self.clock - t) / 30 * gw, gy + gh - (lvl - 1) / 9 * gh)
               for t, lvl in self.history if self.clock - t <= 30]
        if len(pts) > 1:
            pygame.draw.lines(screen, (120, 200, 255), False, pts, 2)


def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Adaptive Arena")
    clock = pygame.time.Clock()
    font = pygame.font.Font(None, 22)             # created once
    arena = Arena(seed=25)
    held = set()
    modes = {pygame.K_1: "static", pygame.K_2: "dda", pygame.K_3: "flow"}

    running = True
    while running:
        dt = min(clock.tick(60) / 1000, 0.05)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                held.add(event.key)
                if event.key in modes:
                    arena.director.mode = modes[event.key]
                elif event.key == pygame.K_8:
                    arena.director.toggle("shield")
                elif event.key == pygame.K_9:
                    arena.director.toggle("slow")
            elif event.type == pygame.KEYUP:
                held.discard(event.key)

        move = pygame.Vector2(
            (pygame.K_RIGHT in held or pygame.K_d in held) - (pygame.K_LEFT in held or pygame.K_a in held),
            (pygame.K_DOWN in held or pygame.K_s in held) - (pygame.K_UP in held or pygame.K_w in held))
        arena.update(move, pygame.K_SPACE in held, dt)
        arena.draw(screen, font)
        pygame.display.flip()

    pygame.quit()
    d = arena.director
    print(f"Mode: {d.mode}  level: {d.level:.2f}  score: {arena.score}  deaths: {arena.deaths}")
    print("Arena closed cleanly.")


if __name__ == "__main__":
    main()