Work on demos

1 files changed, 0 insertions, 922 deletions

diff --git a/docs/superpowers/plans/2026-04-05-demos.md b/docs/superpowers/plans/2026-04-05-demos.md
deleted file mode 100644
index 6fea0bb..0000000
--- a/docs/superpowers/plans/2026-04-05-demos.md
+++ /dev/null
@@ -1,922 +0,0 @@
-# Demo Games Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Build 5 self-contained demo games in `demo/` that collectively exercise every engine system and compile via `make demos`.
-
-**Architecture:** Each demo is a standalone Chicken Scheme program that imports downstroke engine modules and links against all engine `.o` files. Shared assets (tileset, levels, fonts, sounds) live in `demo/assets/` copied from macroknight. `mixer.scm` and `sound.scm` are adapted from macroknight and added to the engine build.
-
-**Tech Stack:** Chicken Scheme, SDL2 (sdl2 egg), SDL2_mixer (via mixer FFI), SDL2_ttf (sdl2-ttf egg), SDL2_image (sdl2-image egg), SRFI-64 (tests not applicable to demo programs — `make demos` compilation success is the test).
-
----
-
-## Key API Reference
-
-Before implementing, keep these exact signatures in mind:
-
-```scheme
-;; Entity ops (downstroke/entity)
-(entity-ref entity #:key [default])   ;; read field, default=#f
-(entity-set entity #:key value)        ;; returns NEW entity (immutable)
-(entity-type entity)                   ;; = (entity-ref entity #:type #f)
-
-;; World (downstroke/world)
-(make-scene entities: '() tilemap: #f camera: (make-camera x: 0 y: 0) tileset-texture: #f)
-(make-camera x: 0 y: 0)
-(scene-entities scene)
-(scene-entities-set! scene list)       ;; mutates in place
-(scene-camera scene)                   ;; camera-x, camera-y, camera-x-set!, camera-y-set!
-(scene-tilemap scene)
-(scene-tileset-texture scene)
-(scene-add-entity scene entity)        ;; mutates, returns scene
-(scene-filter-entities scene pred)     ;; mutates, returns scene
-(scene-update-entities scene proc ...) ;; maps each proc over all entities
-
-;; Tilemap (downstroke/tilemap)
-(load-tilemap "path.tmx")              ;; loads TMX + TSX + PNG; returns tilemap
-(tilemap-tileset tilemap)              ;; → tileset struct
-(tileset-image tileset)                ;; → SDL texture (the tileset-texture for make-scene)
-
-;; Physics (downstroke/physics)
-;; Full platformer pipeline (execute in this order):
-(apply-jump entity jump-pressed?)      ;; sets #:ay if on-ground
-(apply-acceleration entity)            ;; consumes #:ay → #:vy, gated on #:gravity?
-(apply-gravity entity)                 ;; adds *gravity*(=1) to #:vy, gated on #:gravity?
-(apply-velocity-x entity)             ;; #:x += #:vx
-(resolve-tile-collisions-x entity tm) ;; snaps #:x, zeros #:vx on hit
-(apply-velocity-y entity)             ;; #:y += #:vy
-(resolve-tile-collisions-y entity tm) ;; snaps #:y, zeros #:vy on hit
-(detect-ground entity tm)             ;; sets #:on-ground?, gated on #:gravity?
-;; Entity-entity collision:
-(scene-resolve-collisions scene)       ;; mutates scene; needs #:solid? #t on both entities
-;; AABB check:
-(aabb-overlap? x1 y1 w1 h1 x2 y2 w2 h2)  ;; → bool
-
-;; Input (downstroke/input)
-(game-input game)                      ;; current input-state
-(input-held? state 'action)           ;; true while button held
-(input-pressed? state 'action)        ;; true only on first frame pressed
-;; Default action names: up down left right a b start select quit
-;; Keyboard: W/up=up, S/down=down, A/left=left, D/right=right,
-;;           J/Z=a, K/X=b, return=start, escape=quit
-
-;; Engine (downstroke/engine)
-(game-run! game)
-(game-scene game), (game-scene-set! game scene)
-(game-renderer game)                   ;; SDL renderer — valid from preload: onward
-(game-input game)                      ;; current input-state
-(game-asset game key)                  ;; = (asset-ref (game-assets game) key)
-(game-asset-set! game key value)
-(game-camera game)                     ;; = (scene-camera (game-scene game))
-
-;; Renderer (downstroke/renderer)
-(render-scene! renderer scene)         ;; draws tilemap + entities (when tilemap present)
-(draw-ui-text renderer font str color x y)
-
-;; Sound (downstroke/sound) — after copying from macroknight
-(init-audio!)
-(load-sounds! '((key . "path.wav") ...))
-(play-sound 'key)                      ;; NOTE: no bang
-(load-music! "path.ogg")
-(play-music! volume)                   ;; volume = 0.0–1.0
-(stop-music!)                          ;; added when copying sound.scm
-```
-
----
-
-## File Structure
-
-**New files to create:**
-```
-demo/assets/           ← copied from macroknight/assets/
-  monochrome-transparent.png
-  monochrome_transparent.tsx
-  level-0.tmx
-  DejaVuSans.ttf
-  jump.wav
-  theme.ogg
-demo/platformer.scm
-demo/shmup.scm
-demo/topdown.scm
-demo/audio.scm
-demo/sandbox.scm
-mixer.scm              ← adapted from macroknight (module renamed to downstroke/mixer)
-sound.scm              ← adapted from macroknight (module renamed to downstroke/sound, +stop-music!)
-```
-
-**Files to modify:**
-```
-Makefile               ← add mixer/sound to MODULE_NAMES, update demos: target
-CLAUDE.md              ← add make demos requirement
-```
-
----
-
-## Task 1: Infrastructure — assets, audio modules, Makefile, CLAUDE.md
-
-**Files:**
-- Create: `demo/assets/` (7 files copied from macroknight)
-- Create: `mixer.scm` (adapted from `/home/gene/src/macroknight/mixer.scm`)
-- Create: `sound.scm` (adapted from `/home/gene/src/macroknight/sound.scm`)
-- Modify: `Makefile`
-- Modify: `CLAUDE.md`
-
-- [ ] **Step 1: Create demo/assets/ and copy asset files**
-
-```bash
-mkdir -p demo/assets
-cp /home/gene/src/macroknight/assets/monochrome-transparent.png demo/assets/
-cp /home/gene/src/macroknight/assets/monochrome_transparent.tsx demo/assets/
-cp /home/gene/src/macroknight/assets/level-0.tmx demo/assets/
-cp /home/gene/src/macroknight/assets/DejaVuSans.ttf demo/assets/
-cp /home/gene/src/macroknight/assets/jump.wav demo/assets/
-cp /home/gene/src/macroknight/assets/theme.ogg demo/assets/
-```
-
-Verify: `ls demo/assets/` shows 6 files (png, tsx, tmx, ttf, wav, ogg).
-
-- [ ] **Step 2: Copy and adapt mixer.scm**
-
-Copy `/home/gene/src/macroknight/mixer.scm` to `mixer.scm` in the downstroke root. Change the module declaration from:
-```scheme
-(module mixer *
-```
-to:
-```scheme
-(module downstroke/mixer *
-```
-
-No other changes needed.
-
-- [ ] **Step 3: Copy and adapt sound.scm**
-
-Copy `/home/gene/src/macroknight/sound.scm` to `sound.scm` in the downstroke root. Make three changes:
-
-1. Change module declaration from `(module sound *` to `(module downstroke/sound *`
-2. Change `(import ... mixer)` to `(import ... downstroke/mixer)`
-3. Add `stop-music!` near the other music functions:
-
-```scheme
-(define (stop-music!) (mix-halt-music))
-```
-
-The full adapted `sound.scm` should look like:
-
-```scheme
-(module downstroke/sound *
-  (import scheme
-          (chicken base)
-          (only srfi-1 for-each)
-          downstroke/mixer)
-
-  (define *sound-registry* '())
-  (define *music* #f)
-
-  (define (init-audio!)
-    (mix-open-audio! 44100 mix-default-format 2 512))
-
-  (define (load-sounds! sound-alist)
-    (set! *sound-registry*
-      (map (lambda (pair)
-             (cons (car pair) (mix-load-chunk (cdr pair))))
-           sound-alist)))
-
-  (define (play-sound sym)
-    (let ((entry (assq sym *sound-registry*)))
-      (when (and entry (cdr entry))
-        (mix-play-channel -1 (cdr entry) 0))))
-
-  (define (load-music! path)
-    (set! *music* (mix-load-mus path)))
-
-  (define (play-music! volume)
-    (when *music*
-      (mix-play-music *music* -1)
-      (mix-volume-music (inexact->exact (round (* volume 128))))))
-
-  (define (stop-music!) (mix-halt-music))
-
-  (define (set-music-volume! volume)
-    (mix-volume-music (inexact->exact (round (* volume 128)))))
-
-  (define (cleanup-audio!)
-    (when *music*
-      (mix-halt-music)
-      (mix-free-music! *music*)
-      (set! *music* #f))
-    (for-each (lambda (pair) (mix-free-chunk! (cdr pair)))
-              *sound-registry*)
-    (set! *sound-registry* '())
-    (mix-close-audio!)))
-```
-
-- [ ] **Step 4: Update Makefile**
-
-Replace the current `MODULE_NAMES` line and add mixer/sound deps and demos target. The updated Makefile:
-
-```makefile
-.DEFAULT_GOAL := engine
-
-# Modules listed in dependency order
-MODULE_NAMES := entity tilemap world input physics renderer assets engine mixer sound
-OBJECT_FILES := $(patsubst %,bin/%.o,$(MODULE_NAMES))
-
-DEMO_NAMES := platformer shmup topdown audio sandbox
-DEMO_BINS  := $(patsubst %,bin/demo-%,$(DEMO_NAMES))
-
-# Build all engine modules
-engine: $(OBJECT_FILES)
-
-bin:
-	@mkdir -p $@
-
-downstroke:
-	@mkdir -p $@
-
-# Explicit inter-module dependencies
-bin/entity.o:
-bin/tilemap.o:
-bin/world.o: bin/entity.o bin/tilemap.o
-bin/input.o: bin/entity.o
-bin/physics.o: bin/entity.o bin/world.o bin/tilemap.o
-bin/renderer.o: bin/entity.o bin/tilemap.o bin/world.o
-bin/assets.o:
-bin/engine.o: bin/renderer.o bin/world.o bin/input.o bin/assets.o
-bin/mixer.o:
-bin/sound.o: bin/mixer.o
-
-# Pattern rule: compile each module as a library unit
-bin/%.o: %.scm | bin downstroke
-	csc -c -J -unit downstroke/$* $*.scm -o bin/$*.o -I bin -L bin/downstroke
-	@mkdir -p bin/downstroke && if [ -f downstroke/$*.import.scm ]; then mv downstroke/$*.import.scm bin/downstroke/; fi
-
-.PHONY: clean test engine demos
-
-clean:
-	rm -rf bin
-	rm -f *.import.scm
-	rm -f *.log
-
-test:
-	@echo "Running unit tests..."
-	@csi -s tests/entity-test.scm
-	@csi -s tests/world-test.scm
-	@csi -s tests/tilemap-test.scm
-	@csi -s tests/physics-test.scm
-	@csi -s tests/input-test.scm
-	@csi -s tests/renderer-test.scm
-	@csi -s tests/assets-test.scm
-	@csi -s tests/engine-test.scm
-
-demos: engine $(DEMO_BINS)
-
-bin/demo-%: demo/%.scm $(OBJECT_FILES) | bin
-	csc demo/$*.scm $(OBJECT_FILES) -o bin/demo-$* -I bin
-```
-
-- [ ] **Step 5: Update CLAUDE.md**
-
-In the "Build & Test" section of `/home/gene/src/downstroke/CLAUDE.md`, update the code block:
-
-```bash
-make              # compile engine + all demos in demo/
-make test         # run all SRFI-64 test suites
-make demos        # build demo games only (verify they compile)
-```
-
-Also add after the build section (or at end of Build & Test):
-
-> `make demos` must always succeed. A demo that fails to compile is a build failure. Run `make && make demos` to verify both engine and demos build cleanly.
-
-- [ ] **Step 6: Verify engine builds with mixer and sound**
-
-```bash
-cd /home/gene/src/downstroke
-make clean && make
-```
-
-Expected: All 10 modules compile without errors. `bin/` contains `.o` files for all MODULE_NAMES including `mixer.o` and `sound.o`.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add demo/assets/ mixer.scm sound.scm Makefile CLAUDE.md
-git commit -m "feat: add demo infrastructure (assets, mixer/sound, Makefile demos target)"
-```
-
----
-
-## Task 2: demo/platformer.scm
-
-Exercises: input, physics (gravity + tile collision + jump), renderer (tilemap + entities), world/scene, camera follow (x), audio (sound effect).
-
-**Files:**
-- Create: `demo/platformer.scm`
-
-- [ ] **Step 1: Create demo/platformer.scm**
-
-```scheme
-(import scheme
-        (chicken base)
-        (prefix sdl2 "sdl2:")
-        (prefix sdl2-ttf "ttf:")
-        (prefix sdl2-image "img:")
-        downstroke/engine
-        downstroke/world
-        downstroke/tilemap
-        downstroke/renderer
-        downstroke/input
-        downstroke/physics
-        downstroke/assets
-        downstroke/entity
-        downstroke/sound)
-
-(define *game*
-  (make-game
-    title: "Demo: Platformer" width: 600 height: 400
-
-    preload: (lambda (game)
-      (init-audio!)
-      (load-sounds! '((jump . "demo/assets/jump.wav")))
-      (game-asset-set! game 'tilemap
-        (load-tilemap "demo/assets/level-0.tmx")))
-
-    create: (lambda (game)
-      (let* ((tm  (game-asset game 'tilemap))
-             (tex (tileset-image (tilemap-tileset tm)))
-             (player (list #:type 'player
-                           #:x 100 #:y 50
-                           #:width 16 #:height 16
-                           #:vx 0 #:vy 0
-                           #:gravity? #t
-                           #:on-ground? #f
-                           #:tile-id 1)))
-        (game-scene-set! game
-          (make-scene
-            entities:        (list player)
-            tilemap:         tm
-            camera:          (make-camera x: 0 y: 0)
-            tileset-texture: tex))))
-
-    update: (lambda (game dt)
-      (let* ((input  (game-input game))
-             (scene  (game-scene game))
-             (tm     (scene-tilemap scene))
-             (player (car (scene-entities scene)))
-             ;; horizontal input
-             (player (entity-set player #:vx
-                       (cond
-                         ((input-held? input 'left)  -3)
-                         ((input-held? input 'right)  3)
-                         (else 0))))
-             ;; play jump sound when jump fires
-             (_ (when (and (input-pressed? input 'a)
-                           (entity-ref player #:on-ground? #f))
-                  (play-sound 'jump)))
-             ;; physics pipeline
-             (player (apply-jump        player (input-pressed? input 'a)))
-             (player (apply-acceleration player))
-             (player (apply-gravity      player))
-             (player (apply-velocity-x   player))
-             (player (resolve-tile-collisions-x player tm))
-             (player (apply-velocity-y   player))
-             (player (resolve-tile-collisions-y player tm))
-             (player (detect-ground      player tm)))
-        ;; camera follows player x, clamped so we don't go negative
-        (let ((cam-x (max 0 (- (entity-ref player #:x 0) 300))))
-          (camera-x-set! (scene-camera scene) cam-x))
-        ;; put player back
-        (scene-entities-set! scene (list player))))))
-
-(game-run! *game*)
-```
-
-- [ ] **Step 2: Verify it compiles**
-
-```bash
-cd /home/gene/src/downstroke
-make demos
-```
-
-Expected: `bin/demo-platformer` is created with no errors.
-
-- [ ] **Step 3: Smoke test — run and verify it opens a window**
-
-```bash
-./bin/demo-platformer
-```
-
-Expected: A window titled "Demo: Platformer" opens. Player entity (tile sprite) appears. Left/right moves it, J/Z triggers a jump with sound. Escape quits.
-
-Note: Tile ID 1 may show the wrong sprite — that's expected. The spec says tile IDs are placeholder values to be adjusted visually.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add demo/platformer.scm
-git commit -m "feat: add platformer demo"
-```
-
----
-
-## Task 3: demo/shmup.scm
-
-Exercises: entity spawning/removal, manual AABB collision, input, renderer (SDL colored rects in render: hook), world/scene (no tilemap), audio (sound effect on shoot).
-
-The engine's `render-scene!` draws nothing for this scene (no tilemap). All visual output comes from the `render:` hook using `sdl2:render-fill-rect!`.
-
-**Files:**
-- Create: `demo/shmup.scm`
-
-- [ ] **Step 1: Create demo/shmup.scm**
-
-```scheme
-(import scheme
-        (chicken base)
-        (prefix sdl2 "sdl2:")
-        (prefix sdl2-ttf "ttf:")
-        (prefix sdl2-image "img:")
-        downstroke/engine
-        downstroke/world
-        downstroke/physics
-        downstroke/input
-        downstroke/entity
-        downstroke/assets
-        downstroke/sound)
-
-;; Frame counter for enemy spawning
-(define *frame-count* 0)
-
-(define (make-bullet px py)
-  (list #:type 'bullet #:x px #:y py #:width 4 #:height 8 #:vx 0 #:vy -6))
-
-(define (make-enemy rx)
-  (list #:type 'enemy #:x rx #:y 0 #:width 16 #:height 16 #:vx 0 #:vy 2))
-
-(define (make-player)
-  (list #:type 'player #:x 280 #:y 360 #:width 16 #:height 16 #:vx 0 #:vy 0))
-
-;; Check collision between two entities using physics.scm's aabb-overlap?
-(define (entities-overlap? a b)
-  (aabb-overlap?
-    (entity-ref a #:x 0) (entity-ref a #:y 0)
-    (entity-ref a #:width 1) (entity-ref a #:height 1)
-    (entity-ref b #:x 0) (entity-ref b #:y 0)
-    (entity-ref b #:width 1) (entity-ref b #:height 1)))
-
-;; Returns list of entities to remove (bullets and enemies that collide)
-(define (find-collisions entities)
-  (let ((bullets (filter (lambda (e) (eq? (entity-ref e #:type) 'bullet)) entities))
-        (enemies  (filter (lambda (e) (eq? (entity-ref e #:type) 'enemy))  entities))
-        (dead '()))
-    (for-each
-      (lambda (b)
-        (for-each
-          (lambda (en)
-            (when (entities-overlap? b en)
-              (set! dead (cons b (cons en dead)))))
-          enemies))
-      bullets)
-    dead))
-
-(define *game*
-  (make-game
-    title: "Demo: Shoot-em-up" width: 600 height: 400
-
-    preload: (lambda (game)
-      (init-audio!)
-      (load-sounds! '((shoot . "demo/assets/jump.wav"))))
-
-    create: (lambda (game)
-      ;; No tilemap — render-scene! will draw nothing for this scene.
-      ;; All drawing happens in the render: hook below.
-      (game-scene-set! game
-        (make-scene
-          entities: (list (make-player))
-          tilemap:  #f
-          camera:   (make-camera x: 0 y: 0)
-          tileset-texture: #f)))
-
-    update: (lambda (game dt)
-      (let* ((input   (game-input game))
-             (scene   (game-scene game))
-             (entities (scene-entities scene))
-             (player  (car (filter (lambda (e) (eq? (entity-ref e #:type) 'player)) entities))))
-        (set! *frame-count* (+ *frame-count* 1))
-
-        ;; Move player left/right
-        (let ((player (entity-set player #:vx
-                        (cond
-                          ((input-held? input 'left)  -4)
-                          ((input-held? input 'right)  4)
-                          (else 0)))))
-          (let ((player (apply-velocity-x player)))
-            ;; Clamp player to screen
-            (let ((player (entity-set player #:x
-                            (max 0 (min 584 (entity-ref player #:x 0))))))
-              ;; Fire bullet on 'a'
-              (when (input-pressed? input 'a)
-                (play-sound 'shoot)
-                (scene-add-entity scene
-                  (make-bullet (+ (entity-ref player #:x 0) 6) 340)))
-
-              ;; Spawn enemy every 60 frames
-              (when (zero? (modulo *frame-count* 60))
-                (scene-add-entity scene
-                  (make-enemy (+ 20 (* (random 28) 20)))))
-
-              ;; Update scene with current player
-              (scene-entities-set! scene
-                (cons player
-                  (filter (lambda (e) (not (eq? (entity-ref e #:type) 'player)))
-                          (scene-entities scene)))))))
-
-        ;; Move bullets and enemies
-        (scene-update-entities scene
-          (lambda (e)
-            (if (eq? (entity-ref e #:type) 'player)
-                e
-                (entity-set (entity-set e
-                              #:x (+ (entity-ref e #:x 0) (entity-ref e #:vx 0)))
-                            #:y (+ (entity-ref e #:y 0) (entity-ref e #:vy 0))))))
-
-        ;; Remove bullet-enemy collisions
-        (let ((dead (find-collisions (scene-entities scene))))
-          (scene-filter-entities scene
-            (lambda (e) (not (memq e dead)))))
-
-        ;; Remove out-of-bounds bullets and enemies
-        (scene-filter-entities scene
-          (lambda (e)
-            (let ((y (entity-ref e #:y 0)))
-              (or (eq? (entity-ref e #:type) 'player)
-                  (and (> y -20) (< y 420))))))))
-
-    render: (lambda (game)
-      (let* ((renderer (game-renderer game))
-             (scene    (game-scene game))
-             (entities (scene-entities scene)))
-        (for-each
-          (lambda (e)
-            (let ((type (entity-ref e #:type 'unknown))
-                  (x    (inexact->exact (floor (entity-ref e #:x 0))))
-                  (y    (inexact->exact (floor (entity-ref e #:y 0))))
-                  (w    (entity-ref e #:width 16))
-                  (h    (entity-ref e #:height 16)))
-              (sdl2:render-draw-color-set! renderer
-                (case type
-                  ((player) (sdl2:make-color 255 255 255 255))
-                  ((bullet) (sdl2:make-color 255 255 0   255))
-                  ((enemy)  (sdl2:make-color 255 50  50  255))
-                  (else     (sdl2:make-color 100 100 100 255))))
-              (sdl2:render-fill-rect! renderer
-                (sdl2:make-rect x y w h))))
-          entities)))))
-
-(game-run! *game*)
-```
-
-- [ ] **Step 2: Verify it compiles**
-
-```bash
-make demos
-```
-
-Expected: `bin/demo-shmup` created with no errors.
-
-- [ ] **Step 3: Smoke test**
-
-```bash
-./bin/demo-shmup
-```
-
-Expected: Black window. White player rectangle at bottom. J/Z fires yellow bullet upward (with sound). Red enemy rectangles fall from the top. Bullets disappear on contact with enemies. Escape quits.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add demo/shmup.scm
-git commit -m "feat: add shmup demo"
-```
-
----
-
-## Task 4: demo/topdown.scm
-
-Exercises: input (8-directional), renderer (tilemap + entities), world/scene, camera follow (both axes), physics tile collision (no gravity).
-
-**Files:**
-- Create: `demo/topdown.scm`
-
-- [ ] **Step 1: Create demo/topdown.scm**
-
-```scheme
-(import scheme
-        (chicken base)
-        (prefix sdl2 "sdl2:")
-        (prefix sdl2-ttf "ttf:")
-        (prefix sdl2-image "img:")
-        downstroke/engine
-        downstroke/world
-        downstroke/tilemap
-        downstroke/renderer
-        downstroke/input
-        downstroke/physics
-        downstroke/assets
-        downstroke/entity)
-
-(define (clamp val lo hi) (max lo (min hi val)))
-
-(define *game*
-  (make-game
-    title: "Demo: Top-down Explorer" width: 600 height: 400
-
-    preload: (lambda (game)
-      (game-asset-set! game 'tilemap
-        (load-tilemap "demo/assets/level-0.tmx")))
-
-    create: (lambda (game)
-      (let* ((tm  (game-asset game 'tilemap))
-             (tex (tileset-image (tilemap-tileset tm)))
-             (player (list #:type 'player
-                           #:x 100 #:y 100
-                           #:width 16 #:height 16
-                           #:vx 0 #:vy 0
-                           #:gravity? #f
-                           #:tile-id 1)))
-        (game-scene-set! game
-          (make-scene
-            entities:        (list player)
-            tilemap:         tm
-            camera:          (make-camera x: 0 y: 0)
-            tileset-texture: tex))))
-
-    update: (lambda (game dt)
-      (let* ((input  (game-input game))
-             (scene  (game-scene game))
-             (tm     (scene-tilemap scene))
-             (player (car (scene-entities scene)))
-             ;; 8-directional velocity
-             (dx (+ (if (input-held? input 'left)  -3 0)
-                    (if (input-held? input 'right)  3 0)))
-             (dy (+ (if (input-held? input 'up)    -3 0)
-                    (if (input-held? input 'down)    3 0)))
-             (player (entity-set (entity-set player #:vx dx) #:vy dy))
-             ;; tile collision on both axes
-             (player (apply-velocity-x player))
-             (player (resolve-tile-collisions-x player tm))
-             (player (apply-velocity-y player))
-             (player (resolve-tile-collisions-y player tm))
-             ;; update camera to center on player
-             (px (entity-ref player #:x 0))
-             (py (entity-ref player #:y 0)))
-        (camera-x-set! (scene-camera scene) (max 0 (- px 300)))
-        (camera-y-set! (scene-camera scene) (max 0 (- py 200)))
-        (scene-entities-set! scene (list player))))))
-
-(game-run! *game*)
-```
-
-- [ ] **Step 2: Verify it compiles**
-
-```bash
-make demos
-```
-
-Expected: `bin/demo-topdown` created with no errors.
-
-- [ ] **Step 3: Smoke test**
-
-```bash
-./bin/demo-topdown
-```
-
-Expected: Window with tilemap visible. Player sprite moves in 8 directions with WASD or arrow keys. Camera follows player on both axes. Escape quits.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add demo/topdown.scm
-git commit -m "feat: add topdown demo"
-```
-
----
-
-## Task 5: demo/audio.scm
-
-Exercises: audio (sound effects + music), renderer (text via draw-ui-text), input, assets. No scene, no physics.
-
-**Files:**
-- Create: `demo/audio.scm`
-
-- [ ] **Step 1: Create demo/audio.scm**
-
-```scheme
-(import scheme
-        (chicken base)
-        (prefix sdl2 "sdl2:")
-        (prefix sdl2-ttf "ttf:")
-        (prefix sdl2-image "img:")
-        downstroke/engine
-        downstroke/renderer
-        downstroke/input
-        downstroke/assets
-        downstroke/sound)
-
-;; Music toggle state
-(define *music-on?* #f)
-
-(define *game*
-  (make-game
-    title: "Demo: Audio" width: 600 height: 400
-
-    preload: (lambda (game)
-      (init-audio!)
-      (load-sounds! '((jump . "demo/assets/jump.wav")))
-      (load-music! "demo/assets/theme.ogg")
-      (game-asset-set! game 'font
-        (ttf:open-font "demo/assets/DejaVuSans.ttf" 20)))
-
-    ;; No create: hook — no scene needed
-    ;; engine.scm guards render-scene! with (when (game-scene game) ...)
-    ;; so omitting game-scene-set! is safe.
-
-    update: (lambda (game dt)
-      (let ((input (game-input game)))
-        ;; J = play jump sound
-        (when (input-pressed? input 'a)
-          (play-sound 'jump))
-        ;; K/X = toggle music (mapped to 'b' in default input config)
-        (when (input-pressed? input 'b)
-          (if *music-on?*
-              (begin (stop-music!) (set! *music-on?* #f))
-              (begin (play-music! 0.5) (set! *music-on?* #t))))))
-
-    render: (lambda (game)
-      (let* ((renderer (game-renderer game))
-             (font     (game-asset game 'font))
-             (white    (sdl2:make-color 255 255 255 255))
-             (gray     (sdl2:make-color 180 180 180 255)))
-        ;; Background
-        (sdl2:render-draw-color-set! renderer (sdl2:make-color 30 30 60 255))
-        (sdl2:render-fill-rect! renderer (sdl2:make-rect 0 0 600 400))
-        ;; Title
-        (draw-ui-text renderer font "Audio Demo" white 220 80)
-        ;; Instructions
-        (draw-ui-text renderer font "J / Z   — play sound effect" gray 160 160)
-        (draw-ui-text renderer font "K / X   — toggle music on/off" gray 160 200)
-        (draw-ui-text renderer font "Escape  — quit" gray 160 240)
-        ;; Music status
-        (draw-ui-text renderer font
-          (if *music-on?* "Music: ON" "Music: OFF")
-          (if *music-on?*
-              (sdl2:make-color 100 255 100 255)
-              (sdl2:make-color 255 100 100 255))
-          240 310)))))
-
-(game-run! *game*)
-```
-
-**Note on key bindings:** The default input config maps `j`/`z` → `'a` action and `k`/`x` → `'b` action. So pressing J plays the sound and K toggles music. The display labels say "J / Z" and "K / X" accordingly. There is no direct key-to-symbol mapping in `*default-input-config*` for arbitrary keys; use the existing action names.
-
-- [ ] **Step 2: Verify it compiles**
-
-```bash
-make demos
-```
-
-Expected: `bin/demo-audio` created with no errors.
-
-- [ ] **Step 3: Smoke test**
-
-```bash
-./bin/demo-audio
-```
-
-Expected: Dark blue window with white text showing key bindings. J plays a sound. K toggles music (status shows ON/OFF in green/red). Escape quits.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add demo/audio.scm
-git commit -m "feat: add audio demo"
-```
-
----
-
-## Task 6: demo/sandbox.scm
-
-Exercises: physics (gravity + tile collision + entity-entity collision), renderer, world/scene. No player input.
-
-**Files:**
-- Create: `demo/sandbox.scm`
-
-- [ ] **Step 1: Create demo/sandbox.scm**
-
-```scheme
-(import scheme
-        (chicken base)
-        (prefix sdl2 "sdl2:")
-        (prefix sdl2-ttf "ttf:")
-        (prefix sdl2-image "img:")
-        downstroke/engine
-        downstroke/world
-        downstroke/tilemap
-        downstroke/renderer
-        downstroke/input
-        downstroke/physics
-        downstroke/assets
-        downstroke/entity)
-
-;; Respawn timer (accumulates dt in milliseconds)
-(define *elapsed* 0)
-(define *respawn-interval* 10000)  ;; 10 seconds
-
-(define (spawn-entities)
-  (let loop ((i 0) (acc '()))
-    (if (= i 10)
-        acc
-        (loop (+ i 1)
-              (cons (list #:type 'box
-                          #:x (+ 30 (* i 55))
-                          #:y (+ 10 (* (random 4) 20))
-                          #:width 16 #:height 16
-                          #:vx 0 #:vy 0
-                          #:gravity? #t
-                          #:on-ground? #f
-                          #:solid? #t
-                          #:tile-id 1)
-                    acc)))))
-
-(define *game*
-  (make-game
-    title: "Demo: Physics Sandbox" width: 600 height: 400
-
-    preload: (lambda (game)
-      (game-asset-set! game 'tilemap
-        (load-tilemap "demo/assets/level-0.tmx")))
-
-    create: (lambda (game)
-      (let* ((tm  (game-asset game 'tilemap))
-             (tex (tileset-image (tilemap-tileset tm))))
-        (game-scene-set! game
-          (make-scene
-            entities:        (spawn-entities)
-            tilemap:         tm
-            camera:          (make-camera x: 0 y: 0)
-            tileset-texture: tex))))
-
-    update: (lambda (game dt)
-      (let* ((scene (game-scene game))
-             (tm    (scene-tilemap scene)))
-        ;; Advance respawn timer
-        (set! *elapsed* (+ *elapsed* dt))
-        (when (>= *elapsed* *respawn-interval*)
-          (set! *elapsed* 0)
-          (scene-entities-set! scene (spawn-entities)))
-
-        ;; Physics pipeline for all entities
-        (scene-update-entities scene
-          apply-gravity
-          apply-velocity-x
-          (lambda (e) (resolve-tile-collisions-x e tm))
-          apply-velocity-y
-          (lambda (e) (resolve-tile-collisions-y e tm))
-          (lambda (e) (detect-ground e tm)))
-
-        ;; Entity-entity collision (push-apart, requires #:solid? #t)
-        (scene-resolve-collisions scene)))))
-
-(game-run! *game*)
-```
-
-- [ ] **Step 2: Verify it compiles**
-
-```bash
-make demos
-```
-
-Expected: `bin/demo-sandbox` created with no errors. All 5 `bin/demo-*` executables exist.
-
-- [ ] **Step 3: Smoke test**
-
-```bash
-./bin/demo-sandbox
-```
-
-Expected: Window shows 10 tile sprites falling with gravity. They land on tilemap floor tiles, pile up, and push each other apart. After 10 seconds they respawn at random positions near the top. Escape quits.
-
-- [ ] **Step 4: Final verification — make demos succeeds cleanly**
-
-```bash
-cd /home/gene/src/downstroke && make clean && make && make demos
-```
-
-Expected: Full clean build succeeds. All 5 demo binaries exist in `bin/`.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add demo/sandbox.scm
-git commit -m "feat: add sandbox demo"
-```