68edfc2 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

68edfc2 — Peter John 2026-11-04T19:52:18+05:30

docs: kids' games review plan (queued last) and Balloon Pop draft

Files changed (3) hide show

docs/backlog.md +2 -0
docs/plans/2026-11-04-kids-games.review.md +94 -0
plum-examples/games/functional/kids/balloon_pop.plum +405 -0

docs/backlog.md CHANGED Viewed

@@ -13,6 +13,7 @@ Open work, in the order the user queued it, plus smaller items found during buil
 4. **FBIP: no heap mutation** — persistent std collections updated in place when unique, Koka-style `fip` functions as a checked in-place guarantee, a reference count used only as a uniqueness check if static proof falls short. Worklist = the `mut` fields left today (see below). (Decision record §9.)
 5. **One product type, `struct`** — after FBIP, merge `record` into an immutable `struct` with compiler-chosen boxing (optional hint, shown by `--explain`). (Decision record §9b.)
 6. **Deterministic games** — fixed timestep, input recording and replay, seeded `Random` in game state, state checksums; port the design from `../kam_macroquad` (`main.rs` tick accumulator, `game/replay.rs`). The `Io` capability makes recording and replaying host input straightforward. (Decision record §10.)
+7. **Kids' games (ages 4-7)** (user 2026-11-04: LAST, after all the refactoring is done) — review plan `docs/plans/2026-11-04-kids-games.review.md` (written, NOT approved; re-present for a fresh human approve). Seven functional-style games in `plum-examples/games/functional/kids/`: Balloon Pop (tap), Bunny Hop, Letter Bubbles, Caterpillar, Color Piano, Star Rocket (gentle Orb Run), Hoppy Frog (platformer); nothing can be lost. Draft `balloon_pop.plum` exists (untracked) and is blocked by the `List.length` bug below. Re-check the plan against the post-refactor APIs (explicit generics, `Io` primitive, crate paths) before approving.
 ## Planned, not yet placed in the queue
@@ -34,6 +35,7 @@ Open work, in the order the user queued it, plus smaller items found during buil
 ## Smaller open items
+- **`List.length()` on a locally built list fails codegen** — `fun count() -> Int =` / `xs := List(1, 2)` / `xs.length()` gives `codegen: unknown method 'List.lengthFrom' (in 'count')`; the same call on a `List` parameter, or inside a `test` block, works. Also hit with a static `Hue.palette().length()`. Found drafting the kids' games; the user wants it fixed (with a regression test) before those games are built. Check whether the cleanup refactor already fixed it.
 - **Spread from a field path** — `Stage(..w.stage, x: 1)` is rejected; only a plain variable can be a spread source. Worked around with small helpers in the pure game. (language-restrictions T14)
 - **Fields declared inside `init` can't be `mut`** (`self.camX: Float = 0.0`) — such fields were moved into the record header. (T8)
 - **Benchmark harness can't pass `--no-fusion`** — `plum-game/web-test` compiles without flags, so fusion-off numbers can't be taken since the env var was removed. (T11)

docs/plans/2026-11-04-kids-games.review.md ADDED Viewed

@@ -0,0 +1,94 @@
+# Kids' games (ages 4-7): review plan
+## Summary
+Seven small example games for children aged 4 to 7, written in the functional style of Orb Run (one immutable game state, a list of messages that can happen to it, and a picture rebuilt every frame). Two are played by tapping or clicking, five with the keyboard, and two of those five are child-friendly versions of the ship game and of a platformer. None of them can be lost. There are no lives, no countdowns and no "game over", and mistakes get a gentle wiggle, never a penalty. Before the games, a compiler bug found while drafting them gets fixed: asking a list built inside a function for its length fails to compile.
+## What you will get
+- A `kids` folder of functional-style games, each one file that runs with `plum game <file>`:
+  - **Balloon Pop** (tap): balloons float up. Tap one to pop it, and its colour's name floats up ("Red!"). Every 10 pops there is a confetti party.
+  - **Bunny Hop** (arrows or WASD): steer a bunny around a garden to collect carrots, and a flower grows for each one. There are no enemies.
+  - **Letter Bubbles** (letter keys): bubbles with big letters drift down. Press that letter to pop the bubble. It starts with a few easy letters and adds more over time.
+  - **Caterpillar** (arrows): a gentle snake. It eats leaves and grows, the edges wrap around, and it passes through itself, so it never dies.
+  - **Color Piano** (keys 1-4 or tap): four coloured pads that light up and play notes, plus a "copy me" tune that only grows when the child copies it right.
+  - **Star Rocket** (arrows, like Orb Run): fly a friendly rocket and collect stars. Clouds just bump you softly, and there are no mines and no lives.
+  - **Hoppy Frog** (arrows plus Space, a platformer): hop across lily pads and logs to catch flies. Falling in the water puts the frog back on the last pad with a splash.
+- Big, bright shapes and big text, sized for small hands and early readers.
+- Five new synthesized sounds (four piano notes and a cheer), made by the existing sound generator, with the current pop, bump and music sounds reused.
+- Tests in every game for its rules, plus a check that each game compiles and runs frames without a browser.
+- A short "Kids' games" entry in the README games section.
+- The list-length compiler bug fixed, with a regression test.
+## What will be built
+| Part | What it does | Size | Built by |
+|---|---|---|---|
+| List-length fix | Lets a list built inside a function report its length, with a regression test | M | a careful helper |
+| New sounds | Adds four piano notes and a cheer to the sound generator and the asset folder | S | a fast helper |
+| Balloon Pop | Finishes the existing draft (it currently hits the list bug) and its tests | S | a careful helper |
+| Bunny Hop | Arrow-key garden walk that collects carrots and grows flowers | M | a careful helper |
+| Letter Bubbles | Falling letter bubbles popped by pressing the matching key | M | a careful helper |
+| Caterpillar | Grid-stepping caterpillar that grows, wraps at the edges and never dies | M | a careful helper |
+| Color Piano | Four lit pads with notes and a growing "copy me" tune | M | a careful helper |
+| Star Rocket | Orb Run's flying rules with stars, soft cloud bumps and no losing | M | a careful helper |
+| Hoppy Frog | Gravity, jumping and landing on platforms, with a safe respawn from the water | L | a careful helper |
+| Headless run check | Compiles each game and runs a few hundred frames with no browser | S | a fast helper |
+| README entry | Lists the games and how to run them | S | a fast helper |
+## How it fits together
+```mermaid
+flowchart LR
+  K[Keyboard and mouse] --> P[Input polling, once a frame]
+  P --> M["Messages: key, tap, tick"]
+  M --> S[Game state update]
+  S --> R[Picture rebuilt every frame]
+  R --> D[Browser renderer]
+  R -->|"what is under the tap"| S
+  S --> A[Sounds]
+  L[Shared functional scene library] --> R
+```
+## How it gets built
+```mermaid
+flowchart TB
+  F[List-length fix] --> W2
+  N[New sounds] --> W2
+  subgraph W2["Wave 2, seven games in parallel"]
+    G1[Balloon Pop]
+    G2[Bunny Hop]
+    G3[Letter Bubbles]
+    G4[Caterpillar]
+    G5[Color Piano]
+    G6[Star Rocket]
+    G7[Hoppy Frog]
+  end
+  W2 --> H[Headless run check and README]
+  H --> V[Final review]
+```
+## Decisions you can change
+- Where the games live: a `kids` folder inside the functional examples (default) | a top-level kids folder beside imperative, pure and functional.
+- Shared code: each game is one self-contained file, as Orb Run is (default) | a small shared kids helper module for the camera and the host shell.
+- How taps are read: pop as soon as the finger touches (default, because small children tap and do not click) | the usual press-and-release click.
+- Platformer controls: arrows plus Space to jump (default) | arrows only, with Up to jump.
+- Letter Bubbles letters: capital letters, starting with A to E and adding more every few pops (default) | the whole alphabet from the start.
+## Risks
+- **The list fix touches the compiler, which the open compiler-cleanup run is also changing.** We keep the fix small and local, with a regression test, and leave rebasing to whichever run lands second.
+- **More compiler gaps may turn up while writing the games.** Each one is noted in the backlog. A game works around it only when the fix would be large, and the workaround is called out in the final report.
+- **Rectangles do not rotate in the functional renderer.** The games use circles, lines and upright rectangles, and the frog's and rocket's turning is shown with circles and lines.
+- **Text width is only estimated, so centred text may sit slightly off.** Text is kept short and checked in the browser.
+- **Hoppy Frog's collision is the hardest logic.** It gets the most tests: landing, walking off an edge, hitting a pad from below, and respawning.
+## Out of scope
+- Images or sprite art drawn for these games (they use shapes, like the drafts).
+- Saving progress or high scores, menus, a game picker, settings, and voice-over (spoken colour or letter names).
+- Touch-specific gestures beyond a tap (no drag or swipe).
+- Changes to the shared functional scene library, unless a game is truly blocked.
+## How we will know it works
+- `plum test` passes for the whole kids folder and for the existing examples.
+- The headless check runs every kids game for 300 frames with no error.
+- In the browser, each game: Balloon Pop pops a balloon on tap. Bunny Hop collects carrots. Letter Bubbles pops on the right key and wiggles on a wrong one. Caterpillar grows and wraps. Color Piano plays and grows its tune. Star Rocket collects stars and survives clouds. Hoppy Frog jumps, lands and respawns.
+- The list-length regression test fails before the fix and passes after it, and the whole compiler test suite still passes.
+## Rough time and cost
+About 40 to 70 minutes and $15 to $30 (rough, until the machine plan is linted).

plum-examples/games/functional/kids/balloon_pop.plum ADDED Viewed

@@ -0,0 +1,405 @@
+# Balloon Pop (`plum game plum-examples/games/functional/kids/balloon_pop.plum`): a
+# game for small children. Balloons float up the sky; tap or click one to pop it.
+# A popped balloon bursts into dots and its colour's name floats up ("Red!"), so the
+# child hears the pop and sees the word. Every 10 pops a "Hooray!" party with
+# confetti. There is no way to lose and no timer.
+#
+# Functional style, as in ../game_state_view.plum: `State` holds the whole game,
+# `Msg` is everything that can happen to it, `update(msg)` returns the next `State`
+# and `render()` returns a fresh `SceneNode[Msg]` picture every frame. Each balloon
+# is a `Clickable` carrying its own `Pop(id)` message, so a pointer press finds the
+# message under it in the picture (`hitId`, then `msgOf`) and sends it to `update`.
+# A press pops at once: small children tap, they do not click.
+module balloon_pop
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+import std/List
+import std/Math
+import std/Random
+import std/game/Vec2
+import std/game/Color
+import std/game/Game
+import std/game/functional/FunctionalScene
+import std/game/functional/Anim
+import std/game/Input
+import std/Io
+primitive Rules =
+  ArenaW = 800.0
+  ArenaH = 600.0
+  Count = 6
+  Radius = 40.0
+  MinSpeed = 35.0
+  MaxSpeed = 70.0
+  PopTime = 0.6
+  PartyEvery = 10
+  PartyTime = 2.5
+primitive Id =
+  Balloon = 100
+# The balloon colours a child can name.
+record Hue(name: Str, color: Color) =
+  fun palette() -> List[Hue] =
+    List(
+      Hue(name: "Red", color: Color.rgb(0.93, 0.2, 0.22)),
+      Hue(name: "Blue", color: Color.rgb(0.2, 0.45, 0.95)),
+      Hue(name: "Yellow", color: Color.rgb(1.0, 0.85, 0.15)),
+      Hue(name: "Green", color: Color.rgb(0.25, 0.75, 0.3)),
+      Hue(name: "Orange", color: Color.rgb(1.0, 0.55, 0.1)),
+      Hue(name: "Purple", color: Color.rgb(0.6, 0.3, 0.85)),
+      Hue(name: "Pink", color: Color.rgb(1.0, 0.5, 0.75))
+    )
+  fun of(i: Int) -> Hue =
+    hues := Hue.palette()
+    hues.at(i % hues.length())
+  fun count() -> Int =
+    Hue.palette().length()
+# --- small pure helpers ---
+fun nothing() -> SceneNode[Msg] =
+  Group(transform: Identity, children: Nil)
+# Text centred on `cx` (the host font is about 0.6 of its size wide per letter).
+fun centred(s: Str, cx: Float, y: Float, size: Float, color: Color) -> SceneNode[Msg] =
+  Text(text: s, x: cx - size * 0.3 * Float(s.length()), y: y, size: size, color: color)
+# Grows in, then pulses gently.
+fun partyAnim() -> Anim =
+  Seq(
+    steps: List(
+      ScaleTo(sx: 1.4, sy: 1.4, secs: 0.25),
+      Forever(anim: Seq(steps: List(ScaleTo(sx: 0.85, sy: 0.85, secs: 0.4), ScaleTo(sx: 1.0 / 0.85, sy: 1.0 / 0.85, secs: 0.4))))
+    )
+  )
+# One balloon. `poppedAt` is the clock time it was popped, or negative while whole.
+record Balloon(id: Int, x: Float, y: Float, speed: Float, hue: Int, phase: Float, poppedAt: Float) =
+  # A fresh balloon below the bottom edge, `depth` further down so they do not
+  # all arrive together.
+  fun spawn(id: Int, rng: Random, depth: Float) -> Spawned =
+    rx := rng.nextFloat()
+    rs := rx.rng.nextFloat()
+    rh := rs.rng.nextIntBelow(Hue.count())
+    x := 60.0 + rx.value * {Rules.ArenaW - 120.0}
+    speed := Rules.MinSpeed + rs.value * {Rules.MaxSpeed - Rules.MinSpeed}
+    b := Balloon(id: id, x: x, y: Rules.ArenaH + Rules.Radius + depth, speed: speed, hue: rh.value, phase: rx.value * Float.Tau, poppedAt: -1.0)
+    Spawned(balloon: b, rng: rh.rng)
+  fun popped(self) -> Bool =
+    self.poppedAt >= 0.0
+  # Where the balloon is drawn: it sways side to side as it rises.
+  fun swayX(self, clock: Float) -> Float =
+    self.x + 14.0 * Math.sin(clock * 1.3 + self.phase)
+  # Rises while whole; once popped it stays where it burst.
+  fun update(self, dt: Float) -> Balloon =
+    if self.popped() then self else Balloon(..self, y: self.y - self.speed * dt)
+  # Gone off the top, or popped long enough ago that the burst has faded.
+  fun done(self, clock: Float) -> Bool =
+    self.y < 0.0 - Rules.Radius * 3.0 || {self.popped() && clock - self.poppedAt > Rules.PopTime}
+  fun render(self, clock: Float) -> SceneNode[Msg] =
+    if self.popped() then self.renderBurst(clock - self.poppedAt) else self.renderWhole(clock)
+  fun renderWhole(self, clock: Float) -> SceneNode[Msg] =
+    r := Rules.Radius
+    c := Hue.of(self.hue).color
+    Clickable(
+      id: self.id,
+      msg: Pop(id: self.id),
+      child: Group(
+        transform: Translate(dx: self.swayX(clock), dy: self.y),
+        children: List(
+          LineShape(x1: 0.0, y1: r, x2: 6.0 * Math.sin(clock * 3.0 + self.phase), y2: r * 2.6, thickness: 2.0, color: Color.rgb(0.35, 0.35, 0.35)),
+          CircleShape(cx: 0.0, cy: r + 2.0, r: 6.0, color: c),
+          CircleShape(cx: 0.0, cy: 0.0, r: r, color: c),
+          CircleShape(cx: 0.0 - r * 0.35, cy: 0.0 - r * 0.4, r: r * 0.22, color: Color.White.withAlpha(0.55))
+        )
+      )
+    )
+  # Eight dots fly out and fade, and the colour's name floats up.
+  fun renderBurst(self, age: Float) -> SceneNode[Msg] =
+    t := {age / Rules.PopTime}.min(1.0)
+    fade := 1.0 - t
+    hue := Hue.of(self.hue)
+    reach := 20.0 + 70.0 * t
+    Group(
+      transform: Translate(dx: self.x, dy: self.y),
+      children: Cons(
+        head: centred("{hue.name}!", 0.0, -20.0 - 60.0 * t, 40.0, Color.rgb(0.15, 0.15, 0.3).withAlpha(fade)),
+        tail: burstDots(0, reach, hue.color.withAlpha(fade))
+      )
+    )
+fun burstDots(i: Int, reach: Float, c: Color) -> List[SceneNode[Msg]] =
+  if i >= 8
+    Nil
+  else
+    a := Float(i) * Float.Tau / 8.0
+    Cons(head: CircleShape(cx: Math.cos(a) * reach, cy: Math.sin(a) * reach, r: 8.0, color: c), tail: burstDots(i + 1, reach, c))
+record Spawned(balloon: Balloon, rng: Random)
+# What can happen to the game.
+enum Msg =
+  | Tick(dt: Float)
+  | Resize(w: Float, h: Float)
+  | Event(input: Input)
+  | Pop(id: Int)
+record State(balloons: List[Balloon], rng: Random, pops: Int, clock: Float, partyAt: Float, sw: Float, sh: Float) =
+  fun start(seed: Int, sw: Float, sh: Float) -> State =
+    State(balloons: Nil, rng: Random.seeded(seed), pops: 0, clock: 0.0, partyAt: -100.0, sw: sw, sh: sh).fill(0)
+  # Balloons `i` and up, spread out below the screen.
+  fun fill(self, i: Int) -> State =
+    if i >= Rules.Count
+      return self
+    sp := Balloon.spawn(Id.Balloon + i, self.rng, Float(i) * 110.0 - Rules.ArenaH * 0.6)
+    State(..self, balloons: self.balloons.append(List(sp.balloon)), rng: sp.rng).fill(i + 1)
+  fun update(self, msg: Msg) -> State = match msg
+    Tick(dt) => self.tick(dt)
+    Resize(w, h) => State(..self, sw: w, sh: h)
+    Event(input) => self.onInput(input)
+    Pop(id) => self.pop(id)
+  fun tick(self, dt: Float) -> State =
+    moved := State(..self, clock: self.clock + dt, balloons: self.balloons.map(|b| b.update(dt)))
+    moved.balloons.fold(moved, |s, b| s.renew(b))
+  # A balloon that is gone comes back at the bottom with a new colour.
+  fun renew(self, b: Balloon) -> State =
+    if !b.done(self.clock)
+      return self
+    sp := Balloon.spawn(b.id, self.rng, 0.0)
+    State(..self, balloons: self.balloons.map(|x| if x.id == b.id then sp.balloon else x), rng: sp.rng)
+  fun pop(self, id: Int) -> State =
+    hit := self.balloons.fold(false, |found, b| found || {b.id == id && !b.popped()})
+    if !hit
+      return self
+    pops := self.pops + 1
+    State(
+      ..self,
+      pops: pops,
+      partyAt: if pops % Rules.PartyEvery == 0 then self.clock else self.partyAt,
+      balloons: self.balloons.map(|b| if b.id == id then Balloon(..b, x: b.swayX(self.clock), poppedAt: self.clock) else b)
+    )
+  fun partying(self) -> Bool =
+    self.clock - self.partyAt < Rules.PartyTime
+  # A press pops the balloon under it; everything else is ignored.
+  fun onInput(self, e: Input) -> State = match e
+    PointerDown(x, y) => self.pressAt(x, y)
+    _ => self
+  fun pressAt(self, x: Float, y: Float) -> State =
+    view := self.render()
+    id := view.hitId(x, y) ?: return self
+    msg := view.msgOf(id) ?: return self
+    self.update(msg)
+  # --- render ---
+  fun zoom(self) -> Float =
+    {self.sw / Rules.ArenaW}.min(self.sh / Rules.ArenaH)
+  fun offsetX(self) -> Float =
+    {self.sw - self.zoom() * Rules.ArenaW} / 2.0
+  fun offsetY(self) -> Float =
+    {self.sh - self.zoom() * Rules.ArenaH} / 2.0
+  fun render(self) -> SceneNode[Msg] =
+    z := self.zoom()
+    Group(
+      transform: Compose(first: Translate(dx: self.offsetX(), dy: self.offsetY()), then: Scale(sx: z, sy: z)),
+      children: List(
+        renderSky(self.clock),
+        Group(transform: Identity, children: self.balloons.map(|b| b.render(self.clock))),
+        self.renderHud(),
+        self.renderParty()
+      )
+    )
+  fun renderHud(self) -> SceneNode[Msg] =
+    Group(
+      transform: Identity,
+      children: List(
+        RectShape(x: 16.0, y: 14.0, w: 170.0, h: 56.0, color: Color.White.withAlpha(0.7)),
+        CircleShape(cx: 46.0, cy: 42.0, r: 18.0, color: Hue.of(0).color),
+        Text(text: "{self.pops}", x: 80.0, y: 20.0, size: 44.0, color: Color.rgb(0.15, 0.15, 0.3))
+      )
+    )
+  fun renderParty(self) -> SceneNode[Msg] =
+    if !self.partying()
+      return nothing()
+    age := self.clock - self.partyAt
+    p := Anim.at(partyAnim(), age)
+    Group(
+      transform: Identity,
+      children: List(
+        Group(transform: Identity, children: confetti(0, age)),
+        Group(
+          transform: Compose(first: Translate(dx: Rules.ArenaW / 2.0, dy: 250.0), then: Scale(sx: p.scaleX, sy: p.scaleY)),
+          children: List(
+            centred("Hooray!", 0.0, -40.0, 72.0, Color.rgb(0.95, 0.3, 0.5)),
+            centred("{self.pops} balloons!", 0.0, 40.0, 40.0, Color.rgb(0.15, 0.15, 0.3))
+          )
+        )
+      )
+    )
+# 30 confetti squares falling from the top, `age` seconds into the party.
+fun confetti(i: Int, age: Float) -> List[SceneNode[Msg]] =
+  if i >= 30
+    Nil
+  else
+    x := Float({i * 7919} % 800)
+    y := Float({i * 104729} % 200) - 200.0 + age * {180.0 + Float(i % 5) * 40.0}
+    wob := 10.0 * Math.sin(age * 4.0 + Float(i))
+    Cons(head: RectShape(x: x + wob, y: y, w: 12.0, h: 12.0, color: Hue.of(i).color), tail: confetti(i + 1, age))
+# Sky, two drifting clouds and the grass.
+fun renderSky(clock: Float) -> SceneNode[Msg] =
+  Group(
+    transform: Identity,
+    children: List(
+      RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: Rules.ArenaH, color: Color.rgb(0.55, 0.8, 1.0)),
+      RectShape(x: 0.0, y: 0.0, w: Rules.ArenaW, h: 200.0, color: Color.rgb(0.45, 0.72, 0.98)),
+      CircleShape(cx: 690.0, cy: 90.0, r: 46.0, color: Color.rgb(1.0, 0.9, 0.35)),
+      cloud(wrapX(120.0 + clock * 12.0), 130.0),
+      cloud(wrapX(520.0 + clock * 8.0), 220.0),
+      RectShape(x: 0.0, y: Rules.ArenaH - 50.0, w: Rules.ArenaW, h: 50.0, color: Color.rgb(0.4, 0.78, 0.35))
+    )
+  )
+fun wrapX(x: Float) -> Float =
+  span := Rules.ArenaW + 200.0
+  x - span * Float(Int(x / span)) - 100.0
+fun cloud(x: Float, y: Float) -> SceneNode[Msg] =
+  white := Color.White.withAlpha(0.9)
+  Group(
+    transform: Translate(dx: x, dy: y),
+    children: List(
+      CircleShape(cx: -30.0, cy: 8.0, r: 24.0, color: white),
+      CircleShape(cx: 0.0, cy: 0.0, r: 32.0, color: white),
+      CircleShape(cx: 32.0, cy: 8.0, r: 24.0, color: white)
+    )
+  )
+# --- the host shell ---
+record World(mut state: State, mut held: Held, popSound: Int, partySound: Int, musicSound: Int)
+export fun init(io: Io) -> World =
+  w := World(
+    state: State.start(io.randomSeed(), Rules.ArenaW, Rules.ArenaH),
+    held: Held.none(),
+    popSound: io.soundLoad("pickup.wav"),
+    partySound: io.soundLoad("gameover.wav"),
+    musicSound: io.soundLoad("music.wav")
+  )
+  io.soundLoop(w.musicSound, 0.2)
+  w
+# Polls the host once, sends every input to the state, then one tick of time;
+# plays a pop for each new pop and a fanfare when a party starts.
+export fun update(io: Io, w: World, dt: Float) =
+  polled := Input.poll(io, w.held)
+  w.held = polled.held
+  s := w.state.update(Resize(w: io.screenWidth(), h: io.screenHeight()))
+  before := s
+  for i := range polled.inputs.length()
+    s = s.update(Event(input: polled.inputs.at(i)))
+  if s.pops > before.pops
+    io.soundPlay(w.popSound, 0.9)
+  if s.partyAt != before.partyAt
+    io.soundPlay(w.partySound, 0.6)
+  w.state = s.update(Tick(dt: dt))
+export fun draw(io: Io, w: World) =
+  io.clear(Color.rgb(0.55, 0.8, 1.0))
+  w.state.render().draw(io)
+# --- tests ---
+fun newState() -> State =
+  State.start(3, Rules.ArenaW, Rules.ArenaH)
+# A state whose first balloon is still and in the middle of the screen.
+fun withCentred(s: State) -> State =
+  State(..s, balloons: s.balloons.map(|b| if b.id == Id.Balloon then Balloon(..b, x: 400.0, y: 300.0, speed: 0.0, phase: 0.0) else b))
+fun first(s: State) -> Balloon =
+  s.balloons.at(0)
+test "a new game has its balloons below the screen and no pops"
+  s := newState()
+  assert s.balloons.length() == Rules.Count
+  assert s.pops == 0
+  assert s.balloons.fold(true, |ok, b| ok && b.y > Rules.ArenaH * 0.4)
+test "balloons rise"
+  s := newState()
+  t := s.update(Tick(dt: 1.0))
+  assert first(t).y < first(s).y
+  assert first(s).y == newState().balloons.at(0).y
+test "pressing a balloon pops it and counts"
+  s := withCentred(newState())
+  t := s.update(Event(input: PointerDown(x: 400.0, y: 300.0)))
+  assert t.pops == 1
+  assert first(t).popped()
+  again := t.update(Event(input: PointerDown(x: 400.0, y: 300.0)))
+  assert again.pops == 1
+test "pressing the sky does nothing"
+  s := withCentred(newState())
+  t := s.update(Event(input: PointerDown(x: 50.0, y: 560.0)))
+  assert t.pops == 0
+test "a popped balloon comes back at the bottom"
+  s := withCentred(newState()).update(Pop(id: Id.Balloon))
+  t := s.update(Tick(dt: Rules.PopTime + 0.1))
+  assert !first(t).popped()
+  assert first(t).y > Rules.ArenaH
+test "every tenth pop starts a party that ends"
+  s := newState()
+  for i := range 9
+    s = State(..s, pops: s.pops + 1)
+  assert !s.partying()
+  t := withCentred(s).update(Pop(id: Id.Balloon))
+  assert t.pops == 10
+  assert t.partying()
+  u := t.update(Tick(dt: Rules.PartyTime + 0.1))
+  assert !u.partying()
+test "the press is found through the camera"
+  s := withCentred(newState()).update(Resize(w: 1600.0, h: 600.0))
+  miss := s.update(Event(input: PointerDown(x: 400.0, y: 300.0)))
+  assert miss.pops == 0
+  hit := s.update(Event(input: PointerDown(x: 800.0, y: 300.0)))
+  assert hit.pops == 1
+test "the same seed gives the same balloons"
+  a := State.start(9, Rules.ArenaW, Rules.ArenaH)
+  b := State.start(9, Rules.ArenaW, Rules.ArenaH)
+  assert first(a).x == first(b).x
+  assert first(a).hue == first(b).hue