aff71b3 | plum | pyrossh

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

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

aff71b3 — Peter John 2026-11-03T22:51:52+05:30

Functional scenes at feature parity: Anim, Ui, tagged hit-testing

Files changed (12) hide show

README.md +24 -0
docs/plans/2026-11-03-state-view-parity.benchmark.md +13 -0
docs/plans/2026-11-03-state-view-parity.incidents.jsonl +17 -0
docs/plans/2026-11-03-state-view-parity.md +189 -0
docs/plans/2026-11-03-state-view-parity.progress.md +22 -0
docs/plans/2026-11-03-state-view-parity.report.json +323 -0
docs/plans/2026-11-03-state-view-parity.report.md +50 -0
plum-examples/games/functional/game_state_view.plum +117 -17
plum-game/web-test/fixtures/stress_state_view.plum +88 -9
plum-std/game/functional/Anim.plum +165 -0
plum-std/game/functional/Picture.plum +70 -0
plum-std/game/functional/Ui.plum +210 -0

README.md CHANGED Viewed

@@ -1414,6 +1414,30 @@ export fun draw(w: World) =
 - **Pure scene** ([`game_pure_scene.plum`](plum-examples/games/pure/game_pure_scene.plum)): every update takes an owned value and hands it back, pointer clicks arrive as `UiEvent`s, and the rules can be tested without a host. Use it when you want pure updates and tests that run without a game host.
 - **State/view** ([`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum)): the game state is plain data and a `view` turns it into `std/game/functional/Picture`, a recursive picture type drawn by recursive functions. Use it when you want to draw from state instead of keeping a tree of actors.
+### Functional scenes (state/view)
+Three scene styles ship, each in its own folder: `std/game/Scene` (mutable actors), `std/game/pure/*` (owned, pure-update actors) and `std/game/functional/*` (plain state plus a `view`). The functional style is a loop of `State -> view -> draw`: the game state is plain data, `view(state)` builds a `SceneNode` (`std/game/functional/Picture`) and `draw` walks it. Nothing is retained between frames.
+- **`Anim`** describes motion as a function of time: `MoveBy`, `RotateBy`, `ScaleTo`, `Delay`, `Seq`, `Par` and `Forever`. `Anim.at(anim, t)` returns an `AnimPose` (dx, dy, rotation, scaleX, scaleY) for any `t`, so a view just applies the pose for `state.clock`.
+- **`Ui`** is pure pointer state. `Picture.hitId(view, x, y)` finds the `Tagged(id, child)` node under the pointer; `Ui.step(ui, input, hit)` returns a `UiStep` with the new `UiState` and the `UiEvent`s raised (`Press`, `Release`, `Click`, `Enter`, `Exit`, with pointer capture). `Ui.button(id, label, x, y, w, h, ui)` builds a tagged button that shows hover and pressed looks.
+From [`game_state_view.plum`](plum-examples/games/functional/game_state_view.plum): `update` runs `Ui.step` against the picture the player sees, then hands each event to `step`.
+```
+fun feed(s: State, input: UiInput) -> State =
+  r := Ui.step(s.ui, input, Picture.hitId(view(s), input.x, input.y))
+  n := State(..s)
+  n.ui = r.ui
+  feedEvents(n, r.events)
+fun uiEvent(s: State, e: UiEvent) -> State =
+  if s.over && e.id == Id.Restart && e.kind == Click
+    return restarted(s, nextSeed(s.seed))
+  s
+```
+Record `==` is identity today (structural `==` is a deferred item), so compare events by their fields (`e.id`, `e.kind`) as above.
 **Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png` builds the static web version, serves it and drives headless Chromium (software WebGPU; `--browser webkit` drives Playwright's WebKit, the Safari engine, instead) through [playwright-rs](https://crates.io/crates/playwright-rs): it fails if the canvas stays blank or stops changing, or the page logs an error, and reports whether audio started. It also takes `--assets DIR`, `--require-audio`, `--measure SECS` (with `--json`, `draws` is the GPU draw calls per frame), `--headed`, `--dpr N` (a device pixel ratio of N), `--lose-device` (destroys the GPU device after a few frames and requires rendering to resume) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y)), `--expect-unsupported-webgpu` (hides `navigator.gpu` and requires the page's "WebGPU is not supported" message while plum.wasm still loads) and `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw, as Safari does). `plum-game/web-test/fixtures/` has `interleave.plum`, `text_sizes.plum` and `rendertarget.plum` for these. One-time setup: `cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers`. See [`plum-game/web-test/README.md`](plum-game/web-test/README.md); `docs/game.png` above was made with `--screenshot`. [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) records the renderer benchmark that led to this design.
 **Asset root:** textures and files are read relative to the asset root. A path that escapes the root (`..` or absolute) fails like a missing file: `-1`, `""` or `false`. The headless runner's root is `--assets` or `assets` beside the wasm; it reads image headers for `textureWidth`/`textureHeight` and records sounds without decoding them.

docs/plans/2026-11-03-state-view-parity.benchmark.md ADDED Viewed

@@ -0,0 +1,13 @@
+# State/view parity benchmark
+Headed Chromium (real GPU, Apple M3 Pro), 1280x720, uncapped, 6 s warm-up then 10 s measured, run back to back in one session:
+`plum-game/web-test/target/debug/plum-web-test <fixture> --headed --uncapped --measure 10 --frames-wait 6 --json`.
+Reported, not a bar, except `stress_state_view` p95 < 4 ms (met: 2.50 ms).
+| fixture | avg ms | p50 | p95 | update ms | draw ms |
+|---|---|---|---|---|---|
+| stress_scene (mutable Scene) | 1.93 | 1.80 | 2.90 | 0.051 | 1.351 |
+| stress_pure_scene | 1.65 | 1.60 | 1.80 | 0.111 | 1.213 |
+| stress_state_view | 2.07 | 2.00 | 2.50 | 0.048 | 1.540 |
+Render (submit) was 0.30, 0.20 and 0.24 ms; all three issue 1 GPU draw call per frame. Differences under about 5% are noise.

docs/plans/2026-11-03-state-view-parity.incidents.jsonl ADDED Viewed

@@ -0,0 +1,17 @@
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum/plum-core && sed -i 's/h + (if BadNum := e then 1 else 2) +/h + { if Bad"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum && cargo test -q -p plum-wasm-codegen --test fusion_alloc_test -- --noca"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 82, "context": "seam T2↔T3: T2 Produces: Picture.hitId: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:38:20"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 66, "context": "seam T1↔T5: T1 Produces: Anim.at: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 66, "context": "seam T1↔T5: T1 Produces: Anim.length: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T5: T3 Produces: Ui.init: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T5: T3 Produces: Ui.pressed: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T5: T3 Produces: Ui.hovered: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T5: T3 Produces: Ui.button: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:40:37"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T4: T3 Produces: Ui.init: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 66, "context": "seam T1↔T4: T1 Produces: Anim.at: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T4: T3 Produces: Ui.pressed: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 66, "context": "seam T1↔T4: T1 Produces: Anim.length: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T4: T3 Produces: Ui.hovered: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "docs/plans/2026-11-03-state-view-parity.md", "line": 97, "context": "seam T3↔T4: T3 Produces: Ui.button: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "22:41:26"}
+{"file": "", "line": 0, "context": "verified: seam T4↔T6", "agent": "pt_review", "kind": "verified", "time": "22:48:37"}
+{"file": "", "line": 0, "context": "verified: seam T5↔T6", "agent": "pt_review", "kind": "verified", "time": "22:48:37"}

docs/plans/2026-11-03-state-view-parity.md ADDED Viewed

@@ -0,0 +1,189 @@
+# Functional state/view at feature parity
+**Review plan:** docs/plans/2026-11-03-state-view-parity.review.md
+**Goal:** give the functional scene style (`std/game/functional/Picture` + `games/functional/game_state_view.plum`) PureScene's features as pure functions: time-based animations (Anim), tagged hit-testing, and a pure UI layer (Ui: press/enter/exit/release/click, capture, buttons); port the game; measure and report performance.
+**Architecture:** new Plum std modules `std/game/functional/Anim` and `std/game/functional/Ui`; `Picture`'s `SceneNode` gains `Tagged(id, child)` plus `Picture.hitId`; the game's `update` runs `step` -> `Ui.step` against `view(state)` -> `step` per UiEvent. No compiler changes.
+**Tech stack:** Plum std/examples, plum-game host tests, playwright-rs web-test.
+**Spec:** docs/plans/2026-11-03-state-view-parity.review.md
+**Detail:** contracts
+**Target-min:** 25
+Global constraints:
+- Worktree: /Users/pyrossh/Code/plum/.superlite/worktrees/sessions/state-view-parity (branch superlite/sessions/state-view-parity). Build there: `cargo build --quiet` then `./target/debug/plum test <file>`.
+- Run tests ONLY via `bash "$SUPERLITE/skills/swarm/scripts/superlite-cli" run_tests --fast <files>` from the worktree (it really runs `plum test` for .plum paths and `cargo test --test <stem>` for Rust test files; output .superlite/test-output.log). Raw cargo test is hook-blocked.
+- Baseline: `plum test plum-std plum-examples` all green (640 + 74 files); host_test 17.
+- The functional folder never imports `std/game/pure/*`: Ui defines its own `UiEvent`/`UiKind`, Anim its own pose.
+- Pure functions over values only: no `own`, no mutation of shared values, no globals.
+- Plum syntax: `test "name"` + `assert`; an assignment in a match arm and a nested `match` each go on their own line; single-letter type names (`P`) parse as generics, use longer names; there is no `[a, b]` literal: use `List(a, b)` / `Cons(head:, tail:)` / `Slice(a, b)`; inline variants follow Rust rules (fields via patterns).
+- Existing tests keep names and values. Never `plum format` a real file.
+## Main diagram
+```mermaid
+flowchart LR
+  A["T1 Anim.at(anim, t) -> AnimPose"] --> G["T4 game_state_view"]
+  P["T2 Picture: Tagged + hitId"] --> U["T3 Ui.step / button"]
+  U --> G
+  U --> F["T5 stress_state_view"]
+  A --> F
+  G --> B["T6 benchmark + README"]
+  F --> B
+```
+## File structure
+Each task's Owns line is its file list.
+Spec map: Summary, What you will get, The design -> T1-T5; Folders (user, 2026-11-03) -> done before this plan; What will be built -> T1-T6; How it fits together -> main diagram; Decisions you can change -> defaults (time-based Anim, Tagged wrapper, PureScene kept); Risks -> R1/R2 measured in T6, R3 incidents; Out of scope -> not built; How we will know it works -> task tests + T6; Rough time and cost -> schedule.
+## Task graph
+```mermaid
+flowchart LR
+  T1[anim]
+  T2[picture tags]
+  T3[ui]
+  T4[game]
+  T5[fixture]
+  T6[bench docs]
+  T7[record eq]
+  %% taskgraph
+  T2 --> T3
+  T1 --> T4
+  T3 --> T4
+  T1 --> T5
+  T3 --> T5
+  T4 --> T6
+  T5 --> T6
+```
+Ruling: sequential - Plum modules can't be stubbed; a module's tests compile the real modules it imports - cost if wrong: ~5 min.
+Ruling: sequential [chain-58d0] - T3 is already checkpointed; T7 owns Ui.plum after it and T6 documents T7 - cost if wrong: none
+## Predicted schedule
+Generated by `superlite-cli plan_tools lint`.
+## Std modules
+**Probe entry:** run=./target/debug/plum test plum-std/game/functional
+Package: library/evaluator; categories: numeric, state, deep.
+### T1 Anim: animations as functions of time · Complexity 4 (O-1) · Est. context 35k
+**Owns:** plum-std/game/functional/Anim.plum
+**Components:** 1
+**LOC owned:** 150
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 3 min
+**Consumes:** none
+**Produces:** `struct AnimPose(dx: Float, dy: Float, rotation: Float, scaleX: Float, scaleY: Float)`; `enum Anim = | MoveBy(dx: Float, dy: Float, secs: Float) | RotateBy(radians: Float, secs: Float) | ScaleTo(sx: Float, sy: Float, secs: Float) | Delay(secs: Float) | Seq(steps: List[Anim]) | Par(steps: List[Anim]) | Forever(anim: Anim)`
+**Produces:** Anim.at(a: Anim, t: Float) -> AnimPose · Anim.length(a: Anim) -> Float
+e.g. Anim.at(MoveBy(dx: 10.0, dy: 0.0, secs: 2.0), 1.0) -> AnimPose(dx: 5.0, dy: 0.0, rotation: 0.0, scaleX: 1.0, scaleY: 1.0)
+e.g. Anim.at(Seq(steps: List(MoveBy(dx: 10.0, dy: 0.0, secs: 1.0), RotateBy(radians: 1.0, secs: 1.0))), 1.5) -> dx 10.0, rotation 0.5
+e.g. Anim.at(Forever(anim: RotateBy(radians: 1.0, secs: 2.0)), 5.0) -> rotation 0.5 (t mod 2 = 1); Anim.length(Forever(..)) -> Float.Infinity (or a documented large constant if Infinity doesn't exist)
+**Review Focus:** numeric: zero-length steps apply fully (no 0/0); t < 0 -> identity pose; t past the end clamps; Forever with zero-length lap -> identity, no division by zero; Par composes offsets additively and scales multiplicatively.
+**Test code:** the e.g. cases; `zero_length_move_applies_at_once`; `negative_time_is_identity`; `par_combines`; `forever_no_drift_after_many_laps` (t = 1000.25 lap 0.5).
+### T2 Picture: Tagged nodes and hitId · Complexity 3 (O-1) · Est. context 35k
+**Owns:** plum-std/game/functional/Picture.plum
+**Components:** 1
+**LOC owned:** 60
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2.5 min
+**Consumes:** none
+**Produces:** `SceneNode` variant `Tagged(id: Int, child: SceneNode)` (draw, bounds, hit pass through; hit paths treat it like a one-child group)
+**Produces:** Picture.hitId(node: SceneNode, x: Float, y: Float) -> Int?
+e.g. Picture.hitId(Group(transform: Identity, children: List(Tagged(id: 7, child: RectShape(x: 0.0, y: 0.0, w: 10.0, h: 10.0, color: Color.Red)))), 5.0, 5.0) -> 7; at (50.0, 5.0) -> null
+e.g. nested Tagged(1, Group(.., List(Tagged(2, rect)))) hit on the rect -> 2 (innermost wins); later siblings win over earlier ones
+**Review Focus:** deep: transforms between tag and point; state: existing Picture tests unchanged.
+**Test code:** the e.g. cases; `tagged_draw_and_bounds_pass_through`; `hit_path_through_tag`.
+### T3 Ui: pure pointer state, events, buttons · Complexity 5 (O-1) · Est. context 45k
+**Owns:** plum-std/game/functional/Ui.plum
+**Components:** 1
+**LOC owned:** 180
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 4 min
+**Consumes:** Picture.hitId(node: SceneNode, x: Float, y: Float) -> Int? (T2)
+**Produces:** `enum UiKind = | Press | Release | Click | Enter | Exit`; `struct UiEvent(id: Int, kind: UiKind)`; `enum UiInputKind = | PointerDown | PointerUp | PointerMove`; `struct UiInput(kind: UiInputKind, x: Float, y: Float)`; `record UiState(x: Float, y: Float, down: Bool, hot: Int?, captured: Int?)`; `record UiStep(ui: UiState, events: List[UiEvent])`
+**Produces:** Ui.init() -> UiState · Ui.step(ui: UiState, input: UiInput, hit: Int?) -> UiStep · Ui.pressed(ui: UiState, id: Int) -> Bool · Ui.hovered(ui: UiState, id: Int) -> Bool · Ui.button(id: Int, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode
+e.g. step(init, Down at hit 5) -> events List(UiEvent(5, Enter), UiEvent(5, Press)), captured 5; then step(.., Up at hit 5) -> List(UiEvent(5, Release), UiEvent(5, Click)), captured null
+e.g. press on 5, move to hit null -> Exit(5); up with hit null -> Release(5) and NO Click; press 5, move off, move back, up -> exactly one Click
+e.g. Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.init()) -> Tagged(id: 3, child: Group(transform: Translate(dx: 10.0, dy: 20.0), children: List(RectShape(x: 0.0, y: 0.0, w: 100.0, h: 40.0, color: <idle colour>), Text(text: "Go", ...))))
+e.g. same with ui where pressed(ui, 3) -> the RectShape colour is the pressed colour; hovered -> the hover colour
+**Review Focus:** state: event order; capture dropped when the captured id is not under the pointer and the button was released; hover with no press gives Enter/Exit only.
+**Test code:** the e.g. cases; `hover_without_press`; `stale_capture_dropped` (captured id no longer present -> cleared on next input); `button_visual_reflects_state` (pressed/hovered change the button's colour node).
+## Game and fixture
+**Probe entry:** run=./target/debug/plum test plum-examples/games/functional/game_state_view.plum
+Package: data pipeline (game rules); categories: state, numeric.
+### T4 Orb Run state/view on Anim and Ui · Complexity 5 (O-1) · Est. context 50k
+**Owns:** plum-examples/games/functional/game_state_view.plum
+**Components:** 1
+**LOC owned:** 160
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 4 min
+**Consumes:** Anim.at(a: Anim, t: Float) -> AnimPose (T1) · Ui.step(ui: UiState, input: UiInput, hit: Int?) -> UiStep (T3) · Ui.button(id: Int, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode (T3)
+**Produces:** none
+**Review Focus:** state: restart via a Click UiEvent; numeric: rules unchanged.
+**Test code:** every existing test keeps name and values; `restart_click_through_ui` (Down+Up over the restart button -> state restarted); `hit_flash_pose_at_fixed_times`; `title_anim_pose_at_fixed_times`.
+**Steps:** State gains `ui: UiState` and animation start times; `onRestart`'s hand hit test is replaced by `Ui.button` + Click; title/game-over panel animates with an Anim (e.g. Seq of ScaleTo + Forever pulse); the ship's hurt flash is an Anim instead of hand-rolled timing; host shell feeds mouse input as UiInput.
+### T5 stress_state_view with tags, buttons, animations · Complexity 3 (O-1) · Est. context 35k
+**Owns:** plum-game/web-test/fixtures/stress_state_view.plum
+**Components:** 1
+**LOC owned:** 80
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2.5 min
+**Consumes:** Anim.at(a: Anim, t: Float) -> AnimPose (T1) · Ui.button(id: Int, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode (T3)
+**Produces:** none
+**Review Focus:** numeric: same entity counts as before plus a fixed number of buttons/animated nodes.
+**Test code:** its `test` blocks pass; existing counts unchanged; add 20 buttons and 200 animated sprites (documented in the file header).
+## Language: record equality (user request, 2026-11-03)
+**Probe entry:** run=./target/debug/plum test plum-std plum-examples
+Package: library/evaluator (compiler); categories: deep, state.
+### T7 structural deep `==` for records and enums · Complexity 6 (O-1) · Est. context 55k
+**Status:** draft
+**Owns:** plum-checker/src/lib.rs, plum-wasm-codegen/src/lib.rs, plum-wasm-codegen/tests/record_eq_e2e_test.rs (deferred; Ui.plum tests and README follow-up when it runs)
+**Components:** 2
+**LOC owned:** 190
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 5 min
+**Consumes:** none
+**Produces:** `a == b` / `a != b` on records and enums (inline variants, union enums, generic ones) is structural and deep: same type/variant and every field `==`, recursing into records, structs, enums, Str (content) and List/Slice/Array (element-wise); a type with a user-defined `eq` keeps using it; a field of fn type makes `==` on that type a compile error naming the field
+e.g. `Pt(x: 1, y: 2) == Pt(x: 1, y: 2)` -> true; `UiEvent(id: 5, kind: Click) == UiEvent(id: 5, kind: Press)` -> false
+e.g. `Box(items: List(Pt(x: 1, y: 2))) == Box(items: List(Pt(x: 1, y: 2)))` -> true (deep); a record with a `f: fn(Int) -> Int` field: `a == b` -> compile error "can't compare Holder with ==: field f is a function"
+**Review Focus:** deep: nested generics, recursive types (List of records), union-enum members; state: no behaviour change for types with a user `eq`; documented: not cycle-safe.
+**Test code:** the e.g. cases in record_eq_e2e_test.rs plus `own_record_eq`, `enum_inline_variant_eq`, `generic_record_eq`, `user_eq_still_used`; Ui.plum tests switch from field-by-field helpers to `==`; README "Equality" paragraph.
+**Steps:** generate one equality fn per compared type in codegen (memoised by type), called from `==`; keep identity nowhere for records; run the whole suite to catch code that relied on identity and report any.
+## Benchmark and docs
+**Probe entry:** run=cargo test --manifest-path plum-game/Cargo.toml --test host_test
+Package: docs + host checks; categories: protocol.
+### T6 benchmark and README · Complexity 3 (O-1) · Est. context 35k
+**Owns:** README.md, docs/plans/2026-11-03-state-view-parity.benchmark.md
+**Components:** 1
+**LOC owned:** 70
+**Tests:** slow
+**Model:** sonnet
+**Est. time:** 4 min
+**Consumes:** none
+**Produces:** none
+**Review Focus:** protocol: host_test and web_check state_view pass.
+**Test code:** `run_tests --fast plum-game/tests/host_test.rs plum-game/web-test/tests/web_check.rs` green; headed benchmark (plum-game/web-test/BENCHMARK.md command, `--headed --uncapped --measure 10 --frames-wait 6 --json`) for stress_scene, stress_pure_scene, stress_state_view in one session -> table (avg, p95, update, draw) and the only bar: state/view p95 < 4 ms.
+**Steps:** README "Functional scenes (state/view)" section: State -> view -> draw loop, Anim, Ui with a short button example; mention the three styles and their folders.
+## Review Focus
+Per package lines above.
+## Self-review
+Spec map covers every section; Consumes match Produces; parallel tasks own distinct files.

docs/plans/2026-11-03-state-view-parity.progress.md ADDED Viewed

@@ -0,0 +1,22 @@
+- start 2060bf0
+- unblocked: dispatched T1 T2 at 22:29:39; T3 held (draft) until T2 checkpoints - Plum no stubs
+- Ruling: T3 held as draft until T2 checkpoints despite lint dropping the edge - Ui.button builds a Tagged node, Plum modules can't be stubbed - cost if wrong: ~3 min
+- checkpoint T1 33a93a8de9 Anim: animations as functions of time
+- checkpoint T2 0bb57d2212 Picture: Tagged nodes and hitId
+- unblocked: dispatched T3 at 22:35:56
+- checkpoint T3 6565c29ba4 Ui: pure pointer state, events, buttons
+- Ruling: Ui's UiEvent/UiInput are records (struct fields can't be enums); records have no ==, compare fields - cost if wrong: none
+- unblocked: dispatched T4 T5 at 22:38:20
+- tests fast passed=17 failed=0 skipped=0 seconds=60.6
+- checkpoint T5 98f4aaa234 stress_state_view with tags, buttons, animations
+- tests fast passed=17 failed=0 skipped=0 seconds=29.9
+- checkpoint T4 de628f0075 Orb Run state/view on Anim and Ui
+- Ruling: [scope] T7 record == (structural, deep; user choice 2026-11-03) added; T6 waits for it (README + bench after) - cost if wrong: none
+- Ruling: FROZEN note on T3 ignored - T3 is checkpointed; its block only gained e.g. lines before dispatch - cost if wrong: none
+- unblocked: dispatched T7 at 22:42:12; T6 held until T7 (both own README.md)
+- Ruling: [scope] T7 (record ==) deferred by the user before it changed any file; kept in the plan as draft; T6 no longer waits for it - cost if wrong: none
+- unblocked: dispatched T6 at 22:44:12
+- tests fast passed=33 failed=0 skipped=0 seconds=148.7
+- checkpoint T6 d2d4e28811 benchmark and README
+- tests full passed=2045 failed=0 skipped=0 seconds=177.0
+- Ruling: final review CHANGES_REQUESTED findings are tool artefacts - files 'untracked' because checkpoints are hidden until finish, and the contract checker can't parse Plum ('no module found'); verified directly: functional tests 23/23 (Anim 9, Picture 8, Ui 6), hitId signature as planned, full suite 2045/0 - cost if wrong: none

docs/plans/2026-11-03-state-view-parity.report.json ADDED Viewed

@@ -0,0 +1,323 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-03T22:28:59 (plan edited since)",
+ "headline": {
+  "wall_min": {
+   "projected": 19.405,
+   "actual": 18.997
+  },
+  "cost_usd_agents": {
+   "projected": 0.67166,
+   "actual": 1.608168
+  },
+  "task_min": {
+   "projected": 30.828,
+   "actual": 24.485
+  },
+  "agents": {
+   "projected": 6,
+   "actual": 21
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 1.405984,
+  "rework_usd": 0.202184,
+  "coordinator_usd": 32.876063,
+  "total_usd": 34.484231
+ },
+ "concurrency": {
+  "peak": 3,
+  "projected_peak": 3
+ },
+ "critical_path": {
+  "actual": [
+   "T2",
+   "T3",
+   "T4",
+   "T6"
+  ],
+  "projected": [
+   "T3",
+   "T4",
+   "T6"
+  ],
+  "projected_min": 19.405
+ },
+ "model_mix": {
+  "sonnet": {
+   "tasks": 8,
+   "cost_usd": 1.608168
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 32.876063
+ },
+ "quality": {
+  "tests": {
+   "passed": 2045,
+   "failed": 0,
+   "skipped": 0,
+   "seconds": 177.0,
+   "mode": "full",
+   "failures": [],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 0,
+  "rework_dispatches": 2,
+  "open_incidents": 13
+ },
+ "tasks": [
+  {
+   "task": "T3",
+   "model": "sonnet",
+   "pred_min": 6.927,
+   "actual_min": 2.028,
+   "delta": {
+    "abs": -4.8987,
+    "pct": -70.7
+   },
+   "cost_usd": 0.196543,
+   "first_time_pass": null
+  },
+  {
+   "task": "T4",
+   "model": "sonnet",
+   "pred_min": 6.178,
+   "actual_min": 2.543,
+   "delta": {
+    "abs": -3.6347,
+    "pct": -58.8
+   },
+   "cost_usd": 0.26867,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 2.435,
+   "actual_min": 5.058,
+   "delta": {
+    "abs": 2.6233,
+    "pct": 107.7
+   },
+   "cost_usd": 0.136374,
+   "first_time_pass": null
+  },
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": 6.3,
+   "actual_min": 4.365,
+   "delta": {
+    "abs": -1.935,
+    "pct": -30.7
+   },
+   "cost_usd": 0.123211,
+   "first_time_pass": null
+  },
+  {
+   "task": "T5",
+   "model": "sonnet",
+   "pred_min": 3.184,
+   "actual_min": 1.93,
+   "delta": {
+    "abs": -1.254,
+    "pct": -39.4
+   },
+   "cost_usd": 0.363576,
+   "first_time_pass": null
+  },
+  {
+   "task": "T1",
+   "model": "sonnet",
+   "pred_min": 5.804,
+   "actual_min": 4.702,
+   "delta": {
+    "abs": -1.1023,
+    "pct": -19.0
+   },
+   "cost_usd": 0.149532,
+   "first_time_pass": null
+  },
+  {
+   "task": "T10",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 3.858,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.370262,
+   "first_time_pass": null
+  },
+  {
+   "task": "T7",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.0,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 1.756,
+  "tokens": 3021450,
+  "wall_min": 298954294.6254,
+  "rows": [
+   {
+    "agent": "a097eab2aa6e4b189",
+    "model": "sonnet",
+    "wall_min": 29895438.8507,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a2a6f5a35f6745e5c",
+    "model": "sonnet",
+    "wall_min": 2.5521,
+    "tokens": 349023,
+    "usd": 0.2687
+   },
+   {
+    "agent": "a2a7a87010512ff3a",
+    "model": "sonnet",
+    "wall_min": 29895424.6719,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a3beeb2c61cd4ef65",
+    "model": "opus",
+    "wall_min": 0.0,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a44607c5458dd7718",
+    "model": "sonnet",
+    "wall_min": 29895434.3685,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a4670cccf9abb01e3",
+    "model": "sonnet",
+    "wall_min": 29895423.1749,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a4cd52b6b3e6b63c2",
+    "model": "sonnet",
+    "wall_min": 29895417.7031,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a56e86d1c1598fc48",
+    "model": "sonnet",
+    "wall_min": 2.8463,
+    "tokens": 564933,
+    "usd": 0.2022
+   },
+   {
+    "agent": "a61dbd2e694a740b6",
+    "model": "sonnet",
+    "wall_min": 0.0,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a62baea907b7f1e90",
+    "model": "sonnet",
+    "wall_min": 5.0663,
+    "tokens": 267688,
+    "usd": 0.1364
+   },
+   {
+    "agent": "a698f99e995432cd0",
+    "model": "sonnet",
+    "wall_min": 29895432.3728,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a70c930990128cf14",
+    "model": "sonnet",
+    "wall_min": 29895426.1614,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a7a8b990f632507e9",
+    "model": "sonnet",
+    "wall_min": 29895419.8222,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a8f785ab797f4c0cf",
+    "model": "opus",
+    "wall_min": 0.3016,
+    "tokens": 36604,
+    "usd": 0.1478
+   },
+   {
+    "agent": "a96803fc5635cf124",
+    "model": "sonnet",
+    "wall_min": 29895421.2612,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a9e9cbf0361e9e1f4",
+    "model": "sonnet",
+    "wall_min": 29895428.5211,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "aa24bc5adcb4edc27",
+    "model": "sonnet",
+    "wall_min": 3.8819,
+    "tokens": 787729,
+    "usd": 0.3703
+   },
+   {
+    "agent": "aabe4e92223e8dda5",
+    "model": "sonnet",
+    "wall_min": 4.3713,
+    "tokens": 205810,
+    "usd": 0.1232
+   },
+   {
+    "agent": "ac853a061c61cdf95",
+    "model": "sonnet",
+    "wall_min": 1.939,
+    "tokens": 224649,
+    "usd": 0.1614
+   },
+   {
+    "agent": "ad99e540a9a911c69",
+    "model": "sonnet",
+    "wall_min": 4.7158,
+    "tokens": 199508,
+    "usd": 0.1495
+   },
+   {
+    "agent": "afadb2c1171f376b0",
+    "model": "sonnet",
+    "wall_min": 2.0433,
+    "tokens": 385506,
+    "usd": 0.1965
+   }
+  ]
+ }
+}

docs/plans/2026-11-03-state-view-parity.report.md ADDED Viewed

@@ -0,0 +1,50 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-03T22:28:59 (plan edited since)
+                         Projected    Actual  Delta
+wall-clock (min)              19.4      19.0  -0.4 (-2%)
+agent cost (USD, +rework)      0.67      1.61  +0.94 (+139%)
+task-minutes                  30.8      24.5  -6.3 (-21%)
+agents                           6        21  +15 (+250%)
+cost split: agents $1.41, rework $0.20, coordinator $32.88, total $34.48
+concurrency: peak 3 at once (projected 3); critical path actual T2 T3 T4 T6; projected T3 > T4 > T6 (19.4 min)
+model mix: sonnet 8 tasks $1.61, coordinator opus $32.88
+quality: tests 2045 passed, 0 failed; first-time pass n/a; rework dispatches 2; open incidents 13
+task  model      pred  actual  delta             cost
+T3    sonnet      6.9     2.0  -4.9 (-71%)     $0.197
+T4    sonnet      6.2     2.5  -3.6 (-59%)     $0.269
+T2    sonnet      2.4     5.1  +2.6 (+108%)    $0.136
+T6    sonnet      6.3     4.4  -1.9 (-31%)     $0.123
+T5    sonnet      3.2     1.9  -1.3 (-39%)     $0.364
+(+3 smaller misses; `superlite-cli report --json` lists all)
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a097eab2aa6e4b189 | sonnet | 29895438.8507 | 0 | 0.0 |
+| a2a6f5a35f6745e5c | sonnet | 2.5521 | 349023 | 0.2687 |
+| a2a7a87010512ff3a | sonnet | 29895424.6719 | 0 | 0.0 |
+| a3beeb2c61cd4ef65 | opus | 0.0 | 0 | 0.0 |
+| a44607c5458dd7718 | sonnet | 29895434.3685 | 0 | 0.0 |
+| a4670cccf9abb01e3 | sonnet | 29895423.1749 | 0 | 0.0 |
+| a4cd52b6b3e6b63c2 | sonnet | 29895417.7031 | 0 | 0.0 |
+| a56e86d1c1598fc48 | sonnet | 2.8463 | 564933 | 0.2022 |
+| a61dbd2e694a740b6 | sonnet | 0.0 | 0 | 0.0 |
+| a62baea907b7f1e90 | sonnet | 5.0663 | 267688 | 0.1364 |
+| a698f99e995432cd0 | sonnet | 29895432.3728 | 0 | 0.0 |
+| a70c930990128cf14 | sonnet | 29895426.1614 | 0 | 0.0 |
+| a7a8b990f632507e9 | sonnet | 29895419.8222 | 0 | 0.0 |
+| a8f785ab797f4c0cf | opus | 0.3016 | 36604 | 0.1478 |
+| a96803fc5635cf124 | sonnet | 29895421.2612 | 0 | 0.0 |
+| a9e9cbf0361e9e1f4 | sonnet | 29895428.5211 | 0 | 0.0 |
+| aa24bc5adcb4edc27 | sonnet | 3.8819 | 787729 | 0.3703 |
+| aabe4e92223e8dda5 | sonnet | 4.3713 | 205810 | 0.1232 |
+| ac853a061c61cdf95 | sonnet | 1.939 | 224649 | 0.1614 |
+| ad99e540a9a911c69 | sonnet | 4.7158 | 199508 | 0.1495 |
+| afadb2c1171f376b0 | sonnet | 2.0433 | 385506 | 0.1965 |
+| totals |  | 298954294.6254 | 3021450 | 1.756 |
+cost source: est
+takeaway: ran 2% faster than projected; cost 139% over; biggest miss T3

plum-examples/games/functional/game_state_view.plum CHANGED Viewed

@@ -11,8 +11,10 @@
 # `view(state)` is pure too and builds a fresh `SceneNode` picture every frame, which
 # `Picture.draw` interprets. Both are structural recursion over `Link` and `List[SceneNode]`:
 # no loop runs in `step` or `view`. There is no
-# retained scene: the restart button is found by `Picture.hitPath` on the picture
+# retained scene: the restart button is a `Ui.button` in the picture; the host turns
+# the mouse into a `UiInput`, finds what is under it with `Picture.hitId` on the
-# the player is looking at. The `World` record is the host shell: it holds the
+# picture the player is looking at, runs `Ui.step`, and feeds each `UiEvent` to `step`.
+# The game-over title and the ship's hurt flash are `Anim`s of time since they began. The `World` record is the host shell: it holds the
 # current `State`, reads the keyboard and mouse into messages, and plays sounds.
 module game_state_view
 import std/Str
@@ -25,6 +27,8 @@ import std/game/Vec2
 import std/game/Color
 import std/game/Game
 import std/game/functional/Picture
+import std/game/functional/Anim
+import std/game/functional/Ui
 primitive Rules =
   ArenaW = 800.0
@@ -56,6 +60,7 @@ primitive Slot =
 primitive Id =
   Orb = 100
   Mine = 200
+  Restart = 1
 # A position and velocity: what a spawn returns and what drifters are bounced with.
 struct Motion(x: Float, y: Float, vx: Float, vy: Float)
@@ -82,6 +87,9 @@ record State(
   over: Bool,
   clock: Float,
   overClock: Float,
+  hurtAt: Float,
+  overAt: Float,
+  ui: UiState,
   sw: Float,
   sh: Float,
   sheet: Int,
@@ -92,6 +100,7 @@ enum Msg =
   | Tick(dt: Float, ax: Float, ay: Float)
   | Resize(w: Float, h: Float)
   | Restart(seed: Int)
+  | UiEv(event: UiEvent)
 fun mapLink(xs: List[A], f: fn(A) -> B) -> List[B] = match xs
@@ -248,7 +257,7 @@ fun newState(seed: Int, best: Int, sheet: Int, target: Int, sw: Float, sh: Float
   mm := makeMines(0, mineCount(0), made.seed, ship)
   State(
     ship: ship, orbs: made.orbs, mines: mm.mines, seed: mm.seed, score: 0, best: best, lives: Rules.StartLives,
-    over: false, clock: 0.0, overClock: 0.0, sw: sw, sh: sh, sheet: sheet, target: target)
+    over: false, clock: 0.0, overClock: 0.0, hurtAt: -1.0, overAt: -1.0, ui: Ui.init(), sw: sw, sh: sh, sheet: sheet, target: target)
 fun orbStill(o: Orb) -> Orb =
   orbAt(o.id, o.phase, o.clock, Motion(x: o.x, y: o.y, vx: 0.0, vy: 0.0))
@@ -311,8 +320,10 @@ fun tick(s: State, dt: Float, ax: Float, ay: Float) -> State =
   if n.ship.hurt <= 0.0 && touchesMine(n.mines, ship)
     n.lives = n.lives - 1
     n.ship = ShipState(x: ship.x, y: ship.y, vx: ship.vx, vy: ship.vy, rotation: ship.rotation, hurt: Rules.HurtTime)
+    n.hurtAt = n.clock
     if n.lives <= 0
       n.over = true
+      n.overAt = n.clock
       n.best = n.best.max(n.score)
   if n.over
     return freeze(n)
@@ -322,7 +333,19 @@ fun tick(s: State, dt: Float, ax: Float, ay: Float) -> State =
 fun step(s: State, msg: Msg) -> State = match msg
   Tick(dt, ax, ay) => tick(s, dt, ax, ay)
   Resize(w, h) => resized(s, w, h)
+  Restart(seed) => restarted(s, seed)
+  UiEv(event) => uiEvent(s, event)
+fun restarted(s: State, seed: Int) -> State =
-  Restart(seed) => newState(seed, s.best.max(s.score), s.sheet, s.target, s.sw, s.sh)
+  n := newState(seed, s.best.max(s.score), s.sheet, s.target, s.sw, s.sh)
+  n.ui = s.ui
+  n
+# A click on the restart button restarts a finished game; other events change nothing.
+fun uiEvent(s: State, e: UiEvent) -> State =
+  if s.over && e.id == Id.Restart && e.kind == Click
+    return restarted(s, nextSeed(s.seed))
+  s
 fun resized(s: State, w: Float, h: Float) -> State =
   n := State(..s)
@@ -377,9 +400,31 @@ fun orbView(sheet: Int, o: Orb) -> SceneNode =
       head: Filter(effect: BlendFx(mode: Blend.Add), child: glow, target: 0 - 1),
       tail: Cons(head: cell(sheet, 0.0 - Rules.Half, 0.0 - Rules.Half, Rules.Size, frameOf(o.clock + o.phase, 4, 8.0), 1), tail: Nil)))
+# The hurt flash: the ship shrinks and recovers every 0.1 s (the scale returns to 1 each lap).
+fun hitFlash() -> Anim =
+  Forever(anim: Seq(steps: List(ScaleTo(sx: 0.4, sy: 0.4, secs: 0.05), ScaleTo(sx: 2.5, sy: 2.5, secs: 0.05))))
+fun flashPose(t: Float) -> AnimPose =
+  Anim.at(hitFlash(), t)
+# The game-over title: grows to 1.3x, then pulses between 1.17x and 1.3x.
+fun titleAnim() -> Anim =
+  Seq(steps: List(
+    ScaleTo(sx: 1.3, sy: 1.3, secs: 0.3),
+    Forever(anim: Seq(steps: List(ScaleTo(sx: 0.9, sy: 0.9, secs: 0.5), ScaleTo(sx: 1.0 / 0.9, sy: 1.0 / 0.9, secs: 0.5))))))
+fun titlePose(t: Float) -> AnimPose =
+  Anim.at(titleAnim(), t)
+fun titleView(s: State) -> SceneNode =
+  p := titlePose(s.clock - s.overAt)
+  Group(
+    transform: Compose(first: Translate(dx: 400.0 + p.dx, dy: 268.0 + p.dy), then: Scale(sx: p.scaleX, sy: p.scaleY)),
+    children: Cons(head: Text(text: "Game over", x: -100.0, y: -24.0, size: 48.0, color: Color.Red), tail: Nil))
 # The ship blinks while hurt and is gone once the game is over (an empty group keeps the slots).
 fun shipView(s: State) -> SceneNode =
-  blink := s.ship.hurt > 0.0 && frameOf(s.clock, 2, 10.0) == 0
+  blink := s.ship.hurt > 0.0 && flashPose(s.clock - s.hurtAt).scaleX < 0.7
   if s.over || blink
     return Group(transform: Identity, children: Nil)
   Group(
@@ -407,17 +452,13 @@ fun hudView(s: State) -> SceneNode =
 fun overlayView(s: State) -> SceneNode =
   if !s.over
     return Group(transform: Identity, children: Nil)
-  button := Group(
-    transform: Identity,
-    children: Cons(
-      head: RectShape(x: 340.0, y: 342.0, w: 120.0, h: 44.0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)),
-      tail: Cons(head: Text(text: "Again", x: 372.0, y: 352.0, size: 24.0, color: Color.White), tail: Nil)))
+  button := Ui.button(Id.Restart, "Again", 340.0, 342.0, 120.0, 44.0, s.ui)
   panel := Group(
     transform: Identity,
     children: Cons(
       head: RectShape(x: 0.0, y: 230.0, w: Rules.ArenaW, h: 170.0, color: Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
       tail: Cons(
-        head: Text(text: "Game over", x: 300.0, y: 244.0, size: 48.0, color: Color.Red),
+        head: titleView(s),
         tail: Cons(
           head: Text(text: "Press Enter to play again", x: 270.0, y: 300.0, size: 24.0, color: Color.White),
           tail: Cons(head: button, tail: Nil)))))
@@ -439,8 +480,29 @@ fun view(s: State) -> SceneNode =
 # True when (x, y) in screen pixels is on the restart button of the picture `view` builds.
 fun onRestart(s: State, x: Float, y: Float) -> Bool =
-  p := Picture.hitPath(view(s), x, y)
+  if h := Picture.hitId(view(s), x, y)
+    return h == Id.Restart
+  false
-  p.length() >= 3 && p.at(0) == Slot.Overlay && p.at(1) == 0 && p.at(2) == 3
+# One pointer input: finds what is under it in the current view, runs the Ui, and
+# feeds each raised event to `step`.
+fun feed(s: State, input: UiInput) -> State =
+  r := Ui.step(s.ui, input, Picture.hitId(view(s), input.x, input.y))
+  n := State(..s)
+  n.ui = r.ui
+  feedEvents(n, r.events)
+fun feedEvents(s: State, evs: List[UiEvent]) -> State = match evs
+  Nil => s
+  Cons(e, rest) => feedEvents(step(s, UiEv(event: e)), rest)
+fun pointerKind(down: Bool, wasDown: Bool) -> UiInputKind =
+  if down && !wasDown
+    PointerDown
+  else if !down && wasDown
+    PointerUp
+  else
+    PointerMove
 # --- the host shell ---
@@ -473,11 +535,15 @@ fun axis(negative: Bool, positive: Bool) -> Float =
 export fun update(w: World, dt: Float) =
   s := step(w.state, Resize(w: screenWidth(), h: screenHeight()))
   down := isMouseDown(0)
-  released := w.wasDown && !down
-  w.wasDown = down
   m := mousePos()
+  clicked := feed(s, UiInput(kind: pointerKind(down, w.wasDown), x: m.x, y: m.y))
+  w.wasDown = down
+  if s.over && !clicked.over
+    w.state = clicked
+    startMusic(w)
+    return
+  s = clicked
-  again := s.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR) || {released && onRestart(s, m.x, m.y)}}
+  if s.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
-  if again
     w.state = step(s, Restart(seed: nextSeed(s.seed)))
     startMusic(w)
     return
@@ -543,6 +609,7 @@ fun forceOver(s: State) -> State =
   n := State(..s)
   n.lives = 0
   n.over = true
+  n.overAt = s.clock
   n.best = s.best.max(s.score)
   n
@@ -768,3 +835,36 @@ test "view_node_count"
   over := forceOver(s)
   assert countNodes(overlayView(over)) > 5
   assert countNodes(view(over)) > countNodes(view(s)) - 3
+test "restart_click_through_ui"
+  e := emptyState()
+  s := State(..e)
+  s.score = 90
+  s = forceOver(s)
+  down := feed(s, UiInput(kind: PointerDown, x: 400.0, y: 364.0))
+  assert down.over
+  assert Ui.pressed(down.ui, Id.Restart)
+  up := feed(down, UiInput(kind: PointerUp, x: 400.0, y: 364.0))
+  assert !up.over
+  assert up.score == 0
+  assert up.best == 90
+  assert up.lives == Rules.StartLives
+  off := feed(feed(s, UiInput(kind: PointerDown, x: 400.0, y: 364.0)), UiInput(kind: PointerUp, x: 100.0, y: 100.0))
+  assert off.over
+  miss := feed(feed(s, UiInput(kind: PointerDown, x: 100.0, y: 100.0)), UiInput(kind: PointerUp, x: 100.0, y: 100.0))
+  assert miss.over
+test "hit_flash_pose_at_fixed_times"
+  assert near(flashPose(0.0).scaleX, 1.0)
+  assert near(flashPose(0.05).scaleX, 0.4)
+  assert near(flashPose(0.075).scaleX, 0.7)
+  assert near(flashPose(0.1).scaleX, 1.0)
+  assert near(flashPose(1.05).scaleX, 0.4)
+test "title_anim_pose_at_fixed_times"
+  assert near(titlePose(0.0).scaleX, 1.0)
+  assert near(titlePose(0.15).scaleX, 1.15)
+  assert near(titlePose(0.3).scaleX, 1.3)
+  assert near(titlePose(0.8).scaleX, 1.17)
+  assert near(titlePose(1.3).scaleX, 1.3)
+  assert near(titlePose(1.8).scaleY, 1.17)

plum-game/web-test/fixtures/stress_state_view.plum CHANGED Viewed

@@ -6,6 +6,12 @@
 # and rebuilds the whole SceneNode tree every frame with recursive functions, which
 # `Picture.draw` interprets. Nothing is retained between frames but `State`. The
 # deepest recursion is the 700 drifters; no loops run in step or view.
+#
+# Entity counts: 5000 sprites (50 groups x 100), 500 rects, 200 circles, 50 texts,
+# plus 200 animated sprites (Pulsers, pose = Anim.at(anim, clock - start)) and
+# 20 Ui.button buttons (tagged ids 40000..40019, screen space, outside the camera).
+# `State.ui` is a Ui.UiState fed by mouse input: update turns the mouse into a
+# UiInput, hit-tests the button layer with Picture.hitId, and calls Ui.step.
 module stress_state_view
 import std/Str
 import std/Int
@@ -16,12 +22,16 @@ import std/game/Vec2
 import std/game/Color
 import std/game/Game
 import std/game/functional/Picture
+import std/game/functional/Anim
+import std/game/functional/Ui
 primitive Counts =
   Sprites = 5000
   Rects = 500
   Circles = 200
   Texts = 50
+  Pulsers = 200
+  Buttons = 20
   Groups = 50
   WorldW = 1600
   WorldH = 900
@@ -65,7 +75,18 @@ struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: F
 # Shows "n <count>" and counts up each frame.
 struct Counter(id: Int, x: Float, y: Float, n: Int)
+# An animated sprite that started its animation at `start` seconds of the clock.
+struct Pulser(id: Int, x: Float, y: Float, start: Float, srcX: Float)
-record State(sheet: Int, white: Int, spinners: List[Spinner], drifters: List[Drifter], counters: List[Counter])
+record State(sheet: Int, white: Int, spinners: List[Spinner], drifters: List[Drifter], counters: List[Counter], pulsers: List[Pulser], anim: Anim, clock: Float, ui: UiState, clicks: Int)
+fun pulseAnim() -> Anim =
+  Forever(anim: Seq(steps: List(
+    Par(steps: List(MoveBy(dx: 30.0, dy: 0.0, secs: 1.0), RotateBy(radians: 3.14159, secs: 1.0), ScaleTo(sx: 1.5, sy: 1.5, secs: 1.0))),
+    Par(steps: List(MoveBy(dx: 0.0 - 30.0, dy: 0.0, secs: 1.0), ScaleTo(sx: 0.6666, sy: 0.6666, secs: 1.0))))))
+fun newPulser(i: Int) -> Pulser =
+  Pulser(id: 50000 + i, x: Float(i * 97 % 1500), y: Float(i * 53 % 850), start: Float(i % 10) * 0.1, srcX: Float(i % 4 * 16))
 fun hue(i: Int) -> Color =
   Color(r: Float(i % 7) / 7.0, g: Float(i % 5) / 5.0, b: 0.4 + Float(i % 3) / 5.0, a: 0.8)
@@ -86,7 +107,8 @@ fun newState(sheet: Int, white: Int) -> State =
   State(
     sheet: sheet, white: white, spinners: rangeLink(0, Counts.Groups, |gi| newSpinner(gi)),
     drifters: appendLink(rects, circles),
-    counters: rangeLink(0, Counts.Texts, |i| Counter(id: 30000 + i, x: Float(i * 30 % Counts.WorldW), y: Float(i * 17 % Counts.WorldH), n: i)))
+    counters: rangeLink(0, Counts.Texts, |i| Counter(id: 30000 + i, x: Float(i * 30 % Counts.WorldW), y: Float(i * 17 % Counts.WorldH), n: i)),
+    pulsers: rangeLink(0, Counts.Pulsers, |i| newPulser(i)), anim: pulseAnim(), clock: 0.0, ui: Ui.init(), clicks: 0)
 # --- step: pure ---
@@ -111,7 +133,20 @@ fun stepCounter(c: Counter) -> Counter =
 fun step(s: State, dt: Float) -> State =
   State(
     sheet: s.sheet, white: s.white, spinners: mapLink(s.spinners, |p| stepSpinner(p, dt)),
-    drifters: mapLink(s.drifters, |d| stepDrifter(d)), counters: mapLink(s.counters, |c| stepCounter(c)))
+    drifters: mapLink(s.drifters, |d| stepDrifter(d)), counters: mapLink(s.counters, |c| stepCounter(c)),
+    pulsers: s.pulsers, anim: s.anim, clock: s.clock + dt, ui: s.ui, clicks: s.clicks)
+fun countClicks(es: List[UiEvent]) -> Int = match es
+  Nil => 0
+  Cons(e, t) => {if e.kind == Click then 1 else 0} + countClicks(t)
+# Feeds one pointer input through Ui.step against the button layer.
+fun stepUi(s: State, input: UiInput) -> State =
+  hit := Picture.hitId(buttonsView(s.ui), input.x, input.y)
+  r := Ui.step(s.ui, input, hit)
+  State(
+    sheet: s.sheet, white: s.white, spinners: s.spinners, drifters: s.drifters, counters: s.counters,
+    pulsers: s.pulsers, anim: s.anim, clock: s.clock, ui: r.ui, clicks: s.clicks + countClicks(r.events))
 # --- view: pure, the whole tree every frame ---
@@ -135,10 +170,26 @@ fun drifterView(white: Int, d: Drifter) -> SceneNode =
 fun counterView(c: Counter) -> SceneNode =
   Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
+fun pulserView(sheet: Int, anim: Anim, clock: Float, p: Pulser) -> SceneNode =
+  pose := Anim.at(anim, clock - p.start)
+  Group(
+    transform: Compose(first: Translate(dx: p.x + pose.dx + 8.0, dy: p.y + pose.dy + 8.0), then: Compose(first: Scale(sx: pose.scaleX, sy: pose.scaleY), then: Compose(first: Rotate(radians: pose.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0)))),
+    children: Cons(head: Sprite(
+      tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: p.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
+      tint: Color.White), tail: Nil))
+fun buttonNodes(i: Int, ui: UiState) -> List[SceneNode] =
+  if i >= Counts.Buttons then Nil else Cons(head: Ui.button(40000 + i, "b{i}", Float(i % 10 * 70 + 10), Float(i / 10 * 30 + 10), 64.0, 24.0, ui), tail: buttonNodes(i + 1, ui))
+fun buttonsView(ui: UiState) -> SceneNode =
+  Group(transform: Identity, children: buttonNodes(0, ui))
 fun view(s: State) -> SceneNode =
   texts := toNodes(s.counters, |c| counterView(c), Nil)
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
+  pulses := toNodes(s.pulsers, |p| pulserView(s.sheet, s.anim, s.clock, p), drifts)
-  Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), drifts))
+  world := Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), pulses))
+  Group(transform: Identity, children: List(world, buttonsView(s.ui)))
 fun whiteTexture() -> Int =
   t := textureCreate(1, 1)
@@ -147,13 +198,21 @@ fun whiteTexture() -> Int =
   renderTarget(-1)
   t
-record World(state: State)
+record World(state: State, wasDown: Bool)
 export fun init() -> World =
-  World(state: newState(textureLoad("sprites.png"), whiteTexture()))
+  World(state: newState(textureLoad("sprites.png"), whiteTexture()), wasDown: false)
 export fun update(w: World, dt: Float) =
+  m := mousePos()
+  down := isMouseDown(0)
+  kind := PointerMove
+  if down && !w.wasDown
+    kind = PointerDown
+  else if !down && w.wasDown
+    kind = PointerUp
+  w.wasDown = down
-  w.state = step(w.state, dt)
+  w.state = stepUi(step(w.state, dt), UiInput(kind: kind, x: m.x, y: m.y))
 export fun draw(w: World) =
   clear(Color.rgb(0.05, 0.06, 0.1))
@@ -172,7 +231,27 @@ test "view has one node per actor"
   s := newState(0, 0)
   v := view(s)
   match v
+    Group(_, top) =>
+      assert countNodes(top) == 2
+      match top.at(0)
-    Group(_, kids) =>
+        Group(_, kids) =>
-      assert countNodes(kids) == 50 + 500 + 200 + 50
+          assert countNodes(kids) == 50 + 500 + 200 + 50 + 200
+        _ =>
+          assert false
+      match top.at(1)
+        Group(_, buttons) =>
+          assert countNodes(buttons) == 20
+        _ =>
+          assert false
     _ =>
       assert false
+test "button click counts and pulsers animate"
+  s := newState(0, 0)
+  down := stepUi(s, UiInput(kind: PointerDown, x: 20.0, y: 20.0))
+  up := stepUi(down, UiInput(kind: PointerUp, x: 20.0, y: 20.0))
+  assert up.clicks == 1
+  assert Ui.hovered(up.ui, 40000)
+  p := newPulser(0)
+  a := Anim.at(s.anim, 0.5 - p.start)
+  assert a.dx > 14.9 && a.dx < 15.1

plum-std/game/functional/Anim.plum ADDED Viewed

@@ -0,0 +1,165 @@
+module std
+import std/Int
+import std/Float
+import std/List
+# Animations as pure functions of time. An `Anim` is plain data; `Anim.at(a, t)`
+# is the pose `t` seconds after it started, so a view can animate with nothing
+# but a clock in its state. Before the start (t < 0) the pose is the identity;
+# past the end it clamps to the final pose. A zero-length step applies fully at
+# any t >= 0. `Seq` runs steps one after another, `Par` runs them together
+# (offsets add, scales multiply). `Forever` repeats its lap using t - floor(t/lap)*lap,
+# so no per-frame time accumulates and there is no drift. A zero-length lap
+# gives the identity pose.
+# The animated part of a transform: an offset, a rotation and a scale.
+struct AnimPose(dx: Float, dy: Float, rotation: Float, scaleX: Float, scaleY: Float)
+enum Anim =
+  | MoveBy(dx: Float, dy: Float, secs: Float)
+  | RotateBy(radians: Float, secs: Float)
+  | ScaleTo(sx: Float, sy: Float, secs: Float)
+  | Delay(secs: Float)
+  | Seq(steps: List[Anim])
+  | Par(steps: List[Anim])
+  | Forever(anim: Anim)
+  # The pose `t` seconds into the animation.
+  fun at(a: Anim, t: Float) -> AnimPose = animAt(a, t)
+  # Duration in seconds. `Forever` has no end: it reports animForever, a large
+  # constant (Float has no Infinity constant).
+  fun length(a: Anim) -> Float = animLength(a)
+# Stands in for an infinite length.
+fun animForever() -> Float = 1e30
+fun animIdentity() -> AnimPose =
+  AnimPose(dx: 0.0, dy: 0.0, rotation: 0.0, scaleX: 1.0, scaleY: 1.0)
+fun animCombine(p: AnimPose, q: AnimPose) -> AnimPose =
+  AnimPose(dx: p.dx + q.dx, dy: p.dy + q.dy, rotation: p.rotation + q.rotation, scaleX: p.scaleX * q.scaleX, scaleY: p.scaleY * q.scaleY)
+# Fraction of a `secs` long step done at t, clamped to [0, 1]; a zero-length step is done at once.
+fun animProgress(secs: Float, t: Float) -> Float =
+  if secs <= 0.0
+    1.0
+  else if t >= secs
+    1.0
+  else
+    t / secs
+fun animLength(a: Anim) -> Float = match a
+  MoveBy(_, _, secs) => animMax0(secs)
+  RotateBy(_, secs) => animMax0(secs)
+  ScaleTo(_, _, secs) => animMax0(secs)
+  Delay(secs) => animMax0(secs)
+  Seq(steps) => animSeqLength(steps, 0.0)
+  Par(steps) => animParLength(steps, 0.0)
+  Forever(_) => animForever()
+fun animMax0(x: Float) -> Float =
+  if x > 0.0
+    x
+  else
+    0.0
+fun animSeqLength(steps: List[Anim], acc: Float) -> Float = match steps
+  Nil => acc
+  Cons(head, tail) => animSeqLength(tail, acc + animLength(head))
+fun animParLength(steps: List[Anim], acc: Float) -> Float = match steps
+  Nil => acc
+  Cons(head, tail) => animParLength(tail, if animLength(head) > acc then animLength(head) else acc)
+fun animAt(a: Anim, t: Float) -> AnimPose =
+  if t < 0.0
+    return animIdentity()
+  match a
+    MoveBy(dx, dy, secs) =>
+      p := animProgress(secs, t)
+      AnimPose(dx: dx * p, dy: dy * p, rotation: 0.0, scaleX: 1.0, scaleY: 1.0)
+    RotateBy(radians, secs) =>
+      AnimPose(dx: 0.0, dy: 0.0, rotation: radians * animProgress(secs, t), scaleX: 1.0, scaleY: 1.0)
+    ScaleTo(sx, sy, secs) =>
+      p := animProgress(secs, t)
+      AnimPose(dx: 0.0, dy: 0.0, rotation: 0.0, scaleX: 1.0 + {sx - 1.0} * p, scaleY: 1.0 + {sy - 1.0} * p)
+    Delay(_) => animIdentity()
+    Seq(steps) => animSeqAt(steps, t, animIdentity())
+    Par(steps) => animParAt(steps, t, animIdentity())
+    Forever(inner) => animForeverAt(inner, t)
+# Finished steps contribute their final pose; the first unfinished one its partial pose.
+fun animSeqAt(steps: List[Anim], t: Float, acc: AnimPose) -> AnimPose = match steps
+  Nil => acc
+  Cons(head, tail) =>
+    len := animLength(head)
+    if t >= len
+      animSeqAt(tail, t - len, animCombine(acc, animAt(head, len)))
+    else
+      animCombine(acc, animAt(head, t))
+fun animParAt(steps: List[Anim], t: Float, acc: AnimPose) -> AnimPose = match steps
+  Nil => acc
+  Cons(head, tail) => animParAt(tail, t, animCombine(acc, animAt(head, t)))
+fun animForeverAt(inner: Anim, t: Float) -> AnimPose =
+  lap := animLength(inner)
+  if lap <= 0.0 || lap >= animForever()
+    return animAt(inner, t)
+  animAt(inner, t - {t / lap}.floor() * lap)
+fun animNear(a: Float, b: Float) -> Bool =
+  {a - b}.abs() < 1e-6
+test "move_halfway"
+  p := Anim.at(MoveBy(dx: 10.0, dy: 0.0, secs: 2.0), 1.0)
+  assert animNear(p.dx, 5.0)
+  assert animNear(p.dy, 0.0)
+  assert animNear(p.rotation, 0.0)
+  assert animNear(p.scaleX, 1.0)
+  assert animNear(p.scaleY, 1.0)
+test "seq_second_step"
+  a := Seq(steps: List(MoveBy(dx: 10.0, dy: 0.0, secs: 1.0), RotateBy(radians: 1.0, secs: 1.0)))
+  p := Anim.at(a, 1.5)
+  assert animNear(p.dx, 10.0)
+  assert animNear(p.rotation, 0.5)
+  assert animNear(Anim.length(a), 2.0)
+test "past_the_end_clamps"
+  p := Anim.at(MoveBy(dx: 10.0, dy: 4.0, secs: 1.0), 99.0)
+  assert animNear(p.dx, 10.0)
+  assert animNear(p.dy, 4.0)
+test "forever_wraps"
+  p := Anim.at(Forever(anim: RotateBy(radians: 1.0, secs: 2.0)), 5.0)
+  assert animNear(p.rotation, 0.5)
+test "forever_no_drift_after_many_laps"
+  p := Anim.at(Forever(anim: RotateBy(radians: 1.0, secs: 0.5)), 1000.25)
+  assert animNear(p.rotation, 0.5)
+test "forever_zero_lap_is_identity"
+  p := Anim.at(Forever(anim: Delay(secs: 0.0)), 3.0)
+  assert animNear(p.rotation, 0.0)
+  q := Anim.at(Forever(anim: MoveBy(dx: 5.0, dy: 0.0, secs: 0.0)), 3.0)
+  assert animNear(q.dx, 5.0)
+test "zero_length_move_applies_at_once"
+  p := Anim.at(MoveBy(dx: 10.0, dy: 0.0, secs: 0.0), 0.0)
+  assert animNear(p.dx, 10.0)
+test "negative_time_is_identity"
+  p := Anim.at(MoveBy(dx: 10.0, dy: 3.0, secs: 1.0), 0.0 - 1.0)
+  assert animNear(p.dx, 0.0)
+  assert animNear(p.dy, 0.0)
+  assert animNear(p.scaleX, 1.0)
+test "par_combines"
+  a := Par(steps: List(MoveBy(dx: 2.0, dy: 0.0, secs: 1.0), MoveBy(dx: 3.0, dy: 0.0, secs: 2.0), ScaleTo(sx: 2.0, sy: 3.0, secs: 1.0), ScaleTo(sx: 2.0, sy: 1.0, secs: 1.0)))
+  p := Anim.at(a, 1.0)
+  assert animNear(p.dx, 3.5)
+  assert animNear(p.scaleX, 4.0)
+  assert animNear(p.scaleY, 3.0)
+  assert animNear(Anim.length(a), 2.0)

plum-std/game/functional/Picture.plum CHANGED Viewed

@@ -44,6 +44,7 @@ enum SceneNode =
   | RectShape(x: Float, y: Float, w: Float, h: Float, color: Color)
   | CircleShape(cx: Float, cy: Float, r: Float, color: Color)
   | LineShape(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, color: Color)
+  | Tagged(id: Int, child: SceneNode)
 struct Rect(x: Float, y: Float, w: Float, h: Float)
@@ -90,6 +91,7 @@ fun picBounds(node: SceneNode, m: Affine) -> Rect? = match node
   Text(txt, tx, ty, size, _) => picBox(tx, ty, size * 0.6 * Float(txt.length()), size, m)
   Group(tr, kids) => picBoundsKids(kids, m.mul(picMatrix(tr)), null)
   Filter(_, child, _) => picBounds(child, m)
+  Tagged(_, child) => picBounds(child, m)
 fun picBoundsKids(kids: List[SceneNode], m: Affine, acc: Rect?) -> Rect? = match kids
   Nil => acc
@@ -143,6 +145,37 @@ fun picHit(node: SceneNode, px: Float, py: Float) -> Slice[Int]? = match node
       picPrepend(0, fp)
     else
       null
+  Tagged(_, child) =>
+    if tp := picHit(child, px, py)
+      picPrepend(0, tp)
+    else
+      null
+# The id of the innermost Tagged node whose subtree is hit at (px, py), or null.
+# `outer` is the id of the nearest enclosing tag (null at the root).
+fun picHitId(node: SceneNode, outer: Int?, px: Float, py: Float) -> Int? = match node
+  Group(tr, kids) =>
+    if gi := picMatrix(tr).invert()
+      lp := gi.apply(Vec2(x: px, y: py))
+      picHitIdKids(kids, outer, lp.x, lp.y)
+    else
+      null
+  Filter(_, child, _) => picHitId(child, outer, px, py)
+  Tagged(id, child) => picHitId(child, id, px, py)
+  _ =>
+    if picHit(node, px, py) != null
+      outer
+    else
+      null
+# Later siblings are drawn on top, so they are tried first.
+fun picHitIdKids(kids: List[SceneNode], outer: Int?, px: Float, py: Float) -> Int? = match kids
+  Nil => null
+  Cons(head, tail) =>
+    if later := picHitIdKids(tail, outer, px, py)
+      later
+    else
+      picHitId(head, outer, px, py)
 # Tries the later children first (they are drawn on top); `i` is the index of
 # `kids`' head. The first hit found from the back wins.
@@ -180,6 +213,7 @@ fun picDraw(node: SceneNode, m: Affine, alpha: Float, target: Int) = match node
     drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
   Group(tr, kids) => picDrawKids(kids, m.mul(picMatrix(tr)), alpha, target)
   Filter(effect, child, tex) => picFilter(effect, child, tex, m, alpha, target)
+  Tagged(_, child) => picDraw(child, m, alpha, target)
 fun picDrawKids(kids: List[SceneNode], m: Affine, alpha: Float, target: Int) = match kids
   Nil => 0
@@ -229,6 +263,10 @@ primitive Picture =
       return p
     Slice[Int]()
+  # The id of the innermost Tagged node under (x, y), or null. Later siblings win.
+  fun hitId(node: SceneNode, x: Float, y: Float) -> Int? =
+    picHitId(node, null, x, y)
 fun picNear(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 1e-6
@@ -279,3 +317,35 @@ test "filter_bounds_is_child_bounds"
   assert picNear(r.y, 2.0)
   assert picNear(r.w, 10.0)
   assert picNear(r.h, 4.0)
+test "tagged_bounds_and_path"
+  g := Group(transform: Identity, children: Cons(head: Tagged(id: 7, child: picRect(1.0, 2.0, 10.0, 4.0, Color.Red)), tail: Nil))
+  r := Picture.bounds(g)
+  assert picNear(r.x, 1.0)
+  assert picNear(r.w, 10.0)
+  p := Picture.hitPath(g, 5.0, 3.0)
+  assert p.length() == 2
+  assert p.at(0) == 0
+  assert p.at(1) == 0
+test "hit_id_innermost_and_topmost"
+  inner := Tagged(id: 2, child: picRect(0.0, 0.0, 10.0, 10.0, Color.Blue))
+  outer := Tagged(id: 1, child: Group(transform: Identity, children: Cons(head: picRect(0.0, 0.0, 20.0, 20.0, Color.Red), tail: Cons(head: inner, tail: Nil))))
+  top := Tagged(id: 3, child: picRect(15.0, 15.0, 10.0, 10.0, Color.Red))
+  g := Group(transform: Translate(dx: 1.0, dy: 0.0), children: Cons(head: outer, tail: Cons(head: top, tail: Nil)))
+  a := Picture.hitId(g, 6.0, 5.0)
+  if va := a
+    assert va == 2
+  else
+    assert false
+  b := Picture.hitId(g, 19.0, 5.0)
+  if vb := b
+    assert vb == 1
+  else
+    assert false
+  c := Picture.hitId(g, 17.0, 17.0)
+  if vc := c
+    assert vc == 3
+  else
+    assert false
+  assert Picture.hitId(g, 100.0, 100.0) == null

plum-std/game/functional/Ui.plum ADDED Viewed

@@ -0,0 +1,210 @@
+module std
+import std/Int
+import std/Float
+import std/Str
+import std/Slice
+import std/List
+import std/game/Color
+import std/game/functional/Picture
+# A pure UI layer for the functional scene style. `Ui.step` takes the previous
+# UiState, one pointer input and the id under the pointer (from Picture.hitId on
+# the current view) and returns the new state plus the UiEvents it raised. Same
+# button rules as PureScene: Down captures the pressed id; while captured only
+# that id gets Enter/Exit; Up releases (Click only when still over it).
+enum UiKind =
+  | Press
+  | Release
+  | Click
+  | Enter
+  | Exit
+record UiEvent(id: Int, kind: UiKind)
+enum UiInputKind =
+  | PointerDown
+  | PointerUp
+  | PointerMove
+record UiInput(kind: UiInputKind, x: Float, y: Float)
+record UiState(x: Float, y: Float, down: Bool, hot: Int?, captured: Int?)
+record UiStep(ui: UiState, events: List[UiEvent])
+fun uiSame(a: Int?, b: Int?) -> Bool =
+  if va := a
+    if vb := b
+      return va == vb
+    return false
+  if vb := b
+    return false
+  true
+# Exit for the old hot id and Enter for the new one when they differ.
+fun uiHover(out: Slice[UiEvent], old: Int?, now: Int?) =
+  if !uiSame(old, now)
+    if o := old
+      out.push(UiEvent(id: o, kind: Exit))
+    if n := now
+      out.push(UiEvent(id: n, kind: Enter))
+primitive Ui =
+  fun init() -> UiState =
+    UiState(x: 0.0, y: 0.0, down: false, hot: null, captured: null)
+  fun step(ui: UiState, input: UiInput, hit: Int?) -> UiStep =
+    out := Slice[UiEvent]()
+    # a capture left over without a held button is stale
+    cap: Int? := ui.captured
+    if !ui.down
+      cap = null
+    hot: Int? := ui.hot
+    down := ui.down
+    match input.kind
+      PointerDown =>
+        cap = null
+        uiHover(out, hot, hit)
+        hot = hit
+        down = true
+        if h := hit
+          out.push(UiEvent(id: h, kind: Press))
+          cap = h
+      PointerMove =>
+        if c := cap
+          now: Int? := null
+          if uiSame(hit, cap)
+            now = cap
+          uiHover(out, hot, now)
+          hot = now
+        else
+          uiHover(out, hot, hit)
+          hot = hit
+      PointerUp =>
+        if c := cap
+          out.push(UiEvent(id: c, kind: Release))
+          if uiSame(hit, cap)
+            out.push(UiEvent(id: c, kind: Click))
+          cap = null
+          hot = hit
+        else
+          uiHover(out, hot, hit)
+          hot = hit
+        down = false
+    UiStep(ui: UiState(x: input.x, y: input.y, down: down, hot: hot, captured: cap), events: List.fromSlice(out))
+  fun pressed(ui: UiState, id: Int) -> Bool =
+    if c := ui.captured
+      return c == id && uiSame(ui.hot, ui.captured)
+    false
+  fun hovered(ui: UiState, id: Int) -> Bool =
+    if h := ui.hot
+      return h == id
+    false
+  # A tagged, translated rectangle with a label whose colour follows the state.
+  fun button(id: Int, label: Str, x: Float, y: Float, w: Float, h: Float, ui: UiState) -> SceneNode =
+    color := uiIdleColor()
+    if Ui.pressed(ui, id)
+      color = uiPressedColor()
+    else if Ui.hovered(ui, id)
+      color = uiHoverColor()
+    Tagged(id: id, child: Group(transform: Translate(dx: x, dy: y), children: List(
+      RectShape(x: 0.0, y: 0.0, w: w, h: h, color: color),
+      Text(text: label, x: 4.0, y: 4.0, size: h * 0.5, color: Color.White))))
+fun uiIdleColor() -> Color = Color.rgb(0.2, 0.2, 0.3)
+fun uiHoverColor() -> Color = Color.rgb(0.35, 0.35, 0.5)
+fun uiPressedColor() -> Color = Color.rgb(0.6, 0.2, 0.2)
+fun uiKinds(s: UiStep) -> List[UiKind] = s.events.map(|e| e.kind)
+fun uiDown(x: Float) -> UiInput = UiInput(kind: PointerDown, x: x, y: 0.0)
+fun uiUp(x: Float) -> UiInput = UiInput(kind: PointerUp, x: x, y: 0.0)
+fun uiMove(x: Float) -> UiInput = UiInput(kind: PointerMove, x: x, y: 0.0)
+fun uiCount(s: UiStep, k: UiKind) -> Int =
+  n := 0
+  for e := range s.events.items()
+    if e.kind == k
+      n = n + 1
+  n
+fun uiIs(e: UiEvent, id: Int, kind: UiKind) -> Bool = e.id == id && e.kind == kind
+fun uiButtonColor(n: SceneNode) -> Color = match n
+  Tagged(_, child) => uiButtonColor(child)
+  Group(_, children) => uiButtonColor(children.at(0))
+  RectShape(_, _, _, _, c) => c
+  _ => Color.Black
+test "press_sets_capture"
+  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  assert s1.events.length() == 2
+  assert uiIs(s1.events.at(0), 5, Enter)
+  assert uiIs(s1.events.at(1), 5, Press)
+  assert Ui.pressed(s1.ui, 5)
+  s2 := Ui.step(s1.ui, uiUp(1.0), 5)
+  assert s2.events.length() == 2
+  assert uiIs(s2.events.at(0), 5, Release)
+  assert uiIs(s2.events.at(1), 5, Click)
+  assert !Ui.pressed(s2.ui, 5)
+  assert Ui.hovered(s2.ui, 5)
+test "release_elsewhere_no_click"
+  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  s2 := Ui.step(s1.ui, uiMove(99.0), null)
+  assert s2.events.length() == 1
+  assert uiIs(s2.events.at(0), 5, Exit)
+  s3 := Ui.step(s2.ui, uiUp(99.0), null)
+  assert s3.events.length() == 1
+  assert uiIs(s3.events.at(0), 5, Release)
+  assert uiCount(s3, Click) == 0
+test "drag_off_and_back_one_click"
+  s1 := Ui.step(Ui.init(), uiDown(1.0), 5)
+  s2 := Ui.step(s1.ui, uiMove(99.0), null)
+  s3 := Ui.step(s2.ui, uiMove(1.0), 5)
+  assert s3.events.length() == 1
+  assert uiIs(s3.events.at(0), 5, Enter)
+  s4 := Ui.step(s3.ui, uiUp(1.0), 5)
+  assert uiCount(s4, Click) == 1
+  assert uiCount(s4, Release) == 1
+test "stale_capture_dropped"
+  stale := UiState(x: 0.0, y: 0.0, down: false, hot: null, captured: 5)
+  s := Ui.step(stale, uiMove(50.0), null)
+  assert s.events.length() == 0
+  if c := s.ui.captured
+    assert false
+  assert !Ui.pressed(s.ui, 5)
+test "hover_without_press_routes_move"
+  s1 := Ui.step(Ui.init(), uiMove(1.0), 5)
+  assert s1.events.length() == 1
+  assert uiIs(s1.events.at(0), 5, Enter)
+  assert Ui.hovered(s1.ui, 5)
+  s2 := Ui.step(s1.ui, uiMove(2.0), 5)
+  assert s2.events.length() == 0
+  s3 := Ui.step(s2.ui, uiMove(99.0), null)
+  assert s3.events.length() == 1
+  assert uiIs(s3.events.at(0), 5, Exit)
+  assert !Ui.hovered(s3.ui, 5)
+test "button_visual_reflects_state"
+  idle := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.init())
+  hov := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiMove(1.0), 3).ui)
+  prs := Ui.button(3, "Go", 10.0, 20.0, 100.0, 40.0, Ui.step(Ui.init(), uiDown(1.0), 3).ui)
+  assert uiButtonColor(idle).eq(uiIdleColor())
+  assert uiButtonColor(hov).eq(uiHoverColor())
+  assert uiButtonColor(prs).eq(uiPressedColor())
+  if hid := Picture.hitId(idle, 20.0, 30.0)
+    assert hid == 3
+  else
+    assert false