4745ae8 | plum | pyrossh

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

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

4745ae8 — Peter John 2026-11-06T15:20:27+05:30

Simpler language: plain games and one scene style

Files changed (46) hide show

compiler/cli/src/program.rs +4 -4
compiler/cli/tests/cli/game_entry_test.rs +51 -2
compiler/cli/tests/cli/game_web_test.rs +3 -3
compiler/core/src/game_entry.rs +97 -0
compiler/core/src/lib.rs +1 -0
compiler/core/src/main_result.rs +1 -1
compiler/game/src/host.rs +16 -6
compiler/game/tests/fixtures/assets_fixture.plum +17 -19
compiler/game/tests/fixtures/host_fixture.plum +13 -13
compiler/game/tests/fixtures/main_game_fixture.plum +11 -12
compiler/game/tests/fixtures/main_missing_fixture.plum +7 -8
compiler/game/tests/fixtures/target_fixture.plum +15 -17
compiler/game/tests/host_test.rs +12 -63
compiler/game/web-test/README.md +3 -3
compiler/game/web-test/fixtures/interleave.plum +11 -12
compiler/game/web-test/fixtures/main_game.plum +9 -9
compiler/game/web-test/fixtures/rendertarget.plum +34 -36
compiler/game/web-test/fixtures/stress.plum +15 -16
compiler/game/web-test/fixtures/stress_pure_scene.plum +0 -144
compiler/game/web-test/fixtures/stress_scene.plum +0 -117
compiler/game/web-test/fixtures/stress_state_view.plum +18 -18
compiler/game/web-test/fixtures/stress_state_view_deep.plum +14 -15
compiler/game/web-test/fixtures/stress_world.plum +66 -56
compiler/game/web-test/fixtures/text_sizes.plum +20 -20
compiler/game/web-test/tests/web_check.rs +6 -16
compiler/game/web/plum_bridge.js +3 -3
compiler/lsp/src/main.rs +2 -2
compiler/wasm-codegen/src/lib.rs +13 -25
compiler/wasm-codegen/tests/wasm_codegen/fusion_alloc_test.rs +1 -1
docs/plans/2026-11-06-simpler-language.benchmark.md +4 -0
examples/games/{imperative/game_loop.plum → game_loop.plum} +0 -0
examples/games/imperative/game.plum +0 -435
examples/games/imperative/game_scene.plum +0 -663
examples/games/imperative/scene.plum +0 -433
examples/games/{functional/kids → kids}/balloon_pop.plum +21 -23
examples/games/{functional/game_state_view.plum → orb_run.plum} +45 -47
examples/games/pure/game_pure_scene.plum +0 -880
std/game/{functional/Anim.plum → Anim.plum} +0 -0
std/game/Game.plum +54 -184
std/game/Input.plum +46 -76
std/game/{functional/FunctionalScene.plum → Scene.plum} +27 -26
std/game/{functional/Ui.plum → Ui.plum} +2 -2
std/game/imperative/Scene.plum +0 -851
std/game/pure/Actions.plum +0 -402
std/game/pure/PureScene.plum +0 -689
std/game/pure/SceneInput.plum +0 -313

compiler/cli/src/program.rs CHANGED Viewed

@@ -11,7 +11,7 @@ use plum_core::ast::{self, Item};
 /// A compiled entry file.
 pub struct Program {
     pub wasm: Vec<u8>,
-    /// A game: `main` returns `Game` (or a subtype).
+    /// A game: `main` returns a type with `update(self, io, dt)` and `draw(self, io)`.
     pub isGame: bool,
     /// `main` returns a `Result`; the compiled `main` is a wrapper that crashes with the name
     /// of the `Err` variant (see `plum_core::main_result`).
@@ -73,7 +73,7 @@ pub fn tryCompileProgram(
         render(&ds, true)
     })?;
     if !out.isGame && hasLegacyGameExports(&ast) {
-        return Err(Failure { codegen: false, text: format!("{}: the `export fun init/update/draw` game entry is gone; a game is a struct embedding `Game` with `override fun update(self, dt)` and `override fun draw(self)`, started by `fun main(io: Io) -> Game`", file.display()) });
+        return Err(Failure { codegen: false, text: format!("{}: the `export fun init/update/draw` game entry is gone; a game is a type with `fun update(self, io: Io, dt: Float) -> Self` and `fun draw(self, io: Io)`, started by `fun main(io: Io) -> ThatType`", file.display()) });
     }
     Ok(Program { isGame: out.isGame, wasm: out.wasm, resultMain })
 }
@@ -87,7 +87,7 @@ pub fn rebuildGame(
 ) -> std::result::Result<Vec<u8>, String> {
     let program = tryCompileProgram(file, lib_path, fusion).map_err(|f| f.text)?;
     if !program.isGame {
-        return Err(format!("{}: `main` no longer returns a `Game`; restart `plum run` to run it as a program", file.display()));
+        return Err(format!("{}: `main` no longer returns a game (a type with `update` and `draw`); restart `plum run` to run it as a program", file.display()));
     }
     Ok(program.wasm)
 }
@@ -109,6 +109,6 @@ mod rebuildTests {
         let root = Path::new(env!("CARGO_MANIFEST_DIR")).ancestors().nth(2).unwrap();
         let got = rebuildGame(&src, root, opts());
         let _ = std::fs::remove_dir_all(&dir);
-        assert!(got.unwrap_err().contains("no longer returns a `Game`"));
+        assert!(got.unwrap_err().contains("no longer returns a game"));
     }
 }

compiler/cli/tests/cli/game_entry_test.rs CHANGED Viewed

@@ -1,5 +1,6 @@
 #![allow(non_snake_case)]
-//! What `main` returning a struct called `Game` of the user's own compiles to: not a game.
+//! What a `main` return type compiles to: a game when it has `update` and `draw`, a plain program
+//! when it has neither, an error when it has only one.
 use std::process::Command;
 fn plumBin() -> std::path::PathBuf {
@@ -13,7 +14,7 @@ fn plumBin() -> std::path::PathBuf {
 }
 #[test]
-fn aUserStructNamedGameIsNotAGame() {
+fn aStructWithoutUpdateAndDrawIsNotAGame() {
     let dir = std::env::temp_dir().join(format!("plum_gameentry_{}", std::process::id()));
     std::fs::create_dir_all(&dir).unwrap();
     let src = dir.join("app.plum");
@@ -40,3 +41,51 @@ fn aGameThatCrashesInAFrameSaysSoOnThePage() {
     let at = bridge.find("frame failed:").expect("frame failure handler");
     assert!(bridge[at..at + 400].contains("textContent"), "a frame crash must reach the page");
 }
+fn compileSource(name: &str, text: &str) -> (bool, String) {
+    let dir = std::env::temp_dir().join(format!("plum_gameentry_{}_{name}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let src = dir.join("app.plum");
+    std::fs::write(&src, text).unwrap();
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).ancestors().nth(2).unwrap();
+    let out = Command::new(plumBin())
+        .current_dir(root)
+        .args(["compile", src.to_str().unwrap(), "-o", dir.join("app.wasm").to_str().unwrap()])
+        .output()
+        .unwrap();
+    let wasm = std::fs::read(dir.join("app.wasm")).unwrap_or_default();
+    let _ = std::fs::remove_dir_all(&dir);
+    let err = String::from_utf8_lossy(&out.stderr).into_owned();
+    let exports = ["update", "draw"].iter().all(|n| wasm.windows(n.len()).any(|w| w == n.as_bytes()));
+    (out.status.success() && exports, err)
+}
+const HEAD: &str = "module app\nimport std/Int\nimport std/Float\nimport std/Str\nimport std/Io\n\nstruct Counter(n: Int) =\n";
+#[test]
+fn aTypeWithUpdateAndDrawIsAGame() {
+    let src = format!("{HEAD}  fun update(self, io: Io, dt: Float) -> Counter =\n    Counter(n: self.n + 1)\n\n  fun draw(self, io: Io) =\n    io.printLn(\"x\")\n\nfun main(io: Io) -> Counter =\n  Counter(n: 0)\n");
+    let (ok, err) = compileSource("game", &src);
+    assert!(ok, "{err}");
+}
+#[test]
+fn aTypeWithOnlyUpdateNamesTheMissingDraw() {
+    let src = format!("{HEAD}  fun update(self, io: Io, dt: Float) -> Counter =\n    self\n\nfun main(io: Io) -> Counter =\n  Counter(n: 0)\n");
+    let (ok, err) = compileSource("noDraw", &src);
+    assert!(!ok && err.contains("`Counter` has `update` but no `draw`"), "{err}");
+}
+#[test]
+fn aTypeWithOnlyDrawNamesTheMissingUpdate() {
+    let src = format!("{HEAD}  fun draw(self, io: Io) =\n    io.printLn(\"x\")\n\nfun main(io: Io) -> Counter =\n  Counter(n: 0)\n");
+    let (ok, err) = compileSource("noUpdate", &src);
+    assert!(!ok && err.contains("`Counter` has `draw` but no `update`"), "{err}");
+}
+#[test]
+fn anUpdateThatDoesNotReturnTheGameIsRejected() {
+    let src = format!("{HEAD}  fun update(self, io: Io, dt: Float) =\n    io.printLn(\"x\")\n\n  fun draw(self, io: Io) =\n    io.printLn(\"x\")\n\nfun main(io: Io) -> Counter =\n  Counter(n: 0)\n");
+    let (ok, err) = compileSource("badUpdate", &src);
+    assert!(!ok && err.contains("a game's update is `fun update(self, io: Io, dt: Float) -> Counter`"), "{err}");
+}

compiler/cli/tests/cli/game_web_test.rs CHANGED Viewed

@@ -29,9 +29,9 @@ fn makeAssets(name: &str) -> (std::path::PathBuf, std::path::PathBuf) {
     (scratch, assets)
 }
-/// A game with `fun main(io: Io) -> Game`, with host calls recorded in a fixed order.
+/// A game whose `main` returns a type with `update` and `draw`, with host calls recorded in a fixed order.
 const FIXTURE: &str = "compiler/game/tests/fixtures/host_fixture.plum";
-/// A game whose entry is `fun main(io: Io) -> Game`.
+/// A game whose entry is `main` returning a type with `update` and `draw`.
 const MAIN_GAME: &str = "compiler/game/web-test/fixtures/main_game.plum";
 #[test]
@@ -172,7 +172,7 @@ fn oldInitEntryIsRejectedWithAPointer() {
         let out = Command::new(plumBin()).current_dir(root()).args([cmd]).arg(&file).args(["--lib-path", "."]).output().unwrap();
         let err = String::from_utf8_lossy(&out.stderr);
         assert!(!out.status.success(), "{cmd} should fail");
-        assert!(err.contains("fun main(io: Io) -> Game"), "{cmd}: {err}");
+        assert!(err.contains("fun main(io: Io) -> ThatType"), "{cmd}: {err}");
     }
     let _ = std::fs::remove_dir_all(&scratch);
 }

compiler/core/src/game_entry.rs ADDED Viewed

@@ -0,0 +1,97 @@
+//! A game is the type `main` returns, when it has `update(self, io: Io, dt: Float) -> T` and
+//! `draw(self, io: Io)`. This lowering (run before checking) appends the two frame entry points
+//! the host calls, `gameUpdate(io, g, dt)` and `gameDraw(io, g)`, which call those methods.
+//! The wasm module exports them as `update(state, dt) -> state` and `draw(state)`. `Int`,
+//! `Result` or no return type, or a type with neither method, is a command line program.
+use crate::ast::*;
+use crate::diag::{DiagKind, Diagnostic};
+use crate::main_result::parseItems;
+pub const GAME_UPDATE: &str = "gameUpdate";
+pub const GAME_DRAW: &str = "gameDraw";
+fn method<'a>(source: &'a Source, ty: &str, name: &str) -> Option<&'a Fn> {
+    source.items.iter().find_map(|i| match i {
+        Item::Fn(f) if f.name == name && f.has_self && f.type_param.as_deref() == Some(ty) => Some(f),
+        _ => None,
+    })
+}
+fn isParam(f: &Fn, i: usize, name: &str, ty: &str) -> bool {
+    matches!(f.params.get(i), Some(p) if p.name == name
+        && matches!(&p.ty, ParamType::Type(t) if t.name == ty && t.generics.is_empty()))
+}
+/// The game type `main` returns: `Ok(None)` for a program that is not a game, an error for a
+/// type with only one of the two methods or with the wrong signatures.
+pub fn gameType(source: &Source) -> Result<Option<String>, Diagnostic> {
+    let Some(main) = source.items.iter().find_map(|i| match i {
+        Item::Fn(f) if f.name == "main" && f.type_param.is_none() => Some(f),
+        _ => None,
+    }) else {
+        return Ok(None);
+    };
+    let Some(ret) = main.returns.as_ref().filter(|t| t.generics.is_empty()) else { return Ok(None) };
+    let ty = ret.name.as_str();
+    let declared = source.items.iter().any(|i| matches!(i, Item::Enum(e) if e.name == ty));
+    if !declared {
+        return Ok(None);
+    }
+    let (update, draw) = (method(source, ty, "update"), method(source, ty, "draw"));
+    let at = |f: &Fn, msg: String| Diagnostic::new(DiagKind::Type, f.file.clone(), f.line, f.column, msg);
+    match (update, draw) {
+        (None, None) => Ok(None),
+        (Some(u), None) => Err(at(u, format!("`{ty}` has `update` but no `draw`: a game needs `fun draw(self, io: Io)` as well"))),
+        (None, Some(d)) => Err(at(d, format!("`{ty}` has `draw` but no `update`: a game needs `fun update(self, io: Io, dt: Float) -> {ty}` as well"))),
+        (Some(u), Some(d)) => {
+            let updateOk = u.params.len() == 2
+                && isParam(u, 0, "io", "Io")
+                && isParam(u, 1, "dt", "Float")
+                && u.returns.as_ref().is_some_and(|r| r.name == ty && r.generics.is_empty());
+            if !updateOk {
+                return Err(at(u, format!("a game's update is `fun update(self, io: Io, dt: Float) -> {ty}`")));
+            }
+            if d.params.len() != 1 || !isParam(d, 0, "io", "Io") {
+                return Err(at(d, "a game's draw is `fun draw(self, io: Io)`".to_string()));
+            }
+            Ok(Some(ty.to_string()))
+        }
+    }
+}
+/// Is `source` a lowered game: does it have the frame entry points?
+pub fn isLoweredGame(source: &Source) -> bool {
+    let has = |n: &str| source.items.iter().any(|i| matches!(i, Item::Fn(f) if f.name == n && f.type_param.is_none()));
+    has(GAME_UPDATE) && has(GAME_DRAW)
+}
+/// If `main` returns a game type, appends the frame entry points and numbers the new nodes.
+/// Returns whether `source` is a game.
+pub fn lowerGame(source: &mut Source) -> Result<bool, Diagnostic> {
+    let Some(ty) = gameType(source)? else { return Ok(false) };
+    let file = source
+        .items
+        .iter()
+        .find_map(|i| match i {
+            Item::Fn(f) if f.name == "main" => Some(f.file.clone()),
+            _ => None,
+        })
+        .unwrap_or_default();
+    let text = format!(
+        "fun {GAME_UPDATE}(io: Io, g: {ty}, dt: Float) -> {ty} = g.update(io, dt)\n\nfun {GAME_DRAW}(io: Io, g: {ty}) = g.draw(io)\n"
+    );
+    // The host holds the state as one reference between frames: a flat struct would travel as
+    // several wasm values, so the game's own struct is always boxed.
+    for item in &mut source.items {
+        if let Item::Enum(e) = item {
+            if e.name == ty {
+                if let Some(info) = e.structInfoMut() {
+                    info.forceBoxed = true;
+                }
+            }
+        }
+    }
+    source.items.extend(parseItems(&text, &file));
+    numberIds(source);
+    Ok(true)
+}

compiler/core/src/lib.rs CHANGED Viewed

@@ -14,6 +14,7 @@ pub mod enum_checks;
 pub mod formatter;
 pub mod fip;
 pub mod forms;
+pub mod game_entry;
 pub mod generics;
 pub mod layout;
 pub mod loader;

compiler/core/src/main_result.rs CHANGED Viewed

@@ -93,7 +93,7 @@ fn clearFnPositions(f: &mut Fn) {
 }
 /// Parses `text` (a few top-level fns) into items with no positions.
-fn parseItems(text: &str, file: &str) -> Vec<Item> {
+pub(crate) fn parseItems(text: &str, file: &str) -> Vec<Item> {
     let mut parser = tree_sitter::Parser::new();
     parser.set_language(&tree_sitter_plum::LANGUAGE.into()).expect("plum grammar");
     let tree = parser.parse(text, None).expect("parse the main wrapper");

compiler/game/src/host.rs CHANGED Viewed

@@ -164,7 +164,7 @@ impl<B: Backend> PlumGame<B> {
         for name in ["main", "update", "draw"] {
             if module.get_export(name).is_none() {
                 let old = if name == "main" && module.get_export("init").is_some() {
-                    " (the `export fun init` entry is gone: write `fun main(io: Io) -> Game`)"
+                    " (the `export fun init` entry is gone: write `fun main(io: Io) -> YourGame`)"
                 } else {
                     ""
                 };
@@ -211,21 +211,31 @@ impl<B: Backend> PlumGame<B> {
     }
     /// Calls `name` with the state (and `extra`) inside a root scope, so the
-    /// per-frame `Rooted` handle is released instead of accumulating.
+    /// per-frame `Rooted` handle is released instead of accumulating. `update` returns
+    /// the next state, which replaces the current one.
-    fn call_with_state(&mut self, name: &str, extra: &[Val]) -> Result<()> {
+    fn call_with_state(&mut self, name: &str, extra: &[Val], returns_state: bool) -> Result<()> {
         let func = self.func(name)?;
         let s = self.state.clone().ok_or_else(|| wasmtime::Error::msg("`main` has not run"))?;
         let mut scope = wasmtime::RootScope::new(&mut self.store);
         let mut args = vec![Val::AnyRef(Some(s.to_rooted(&mut scope)))];
         args.extend_from_slice(extra);
+        if !returns_state {
+            return func.call(&mut scope, &args, &mut []);
+        }
+        let mut out = [Val::AnyRef(None)];
-        func.call(&mut scope, &args, &mut [])
+        func.call(&mut scope, &args, &mut out)?;
+        let Val::AnyRef(Some(next)) = &out[0] else {
+            return Err(wasmtime::Error::msg("`update` returned no state"));
+        };
+        self.state = Some(next.to_owned_rooted(&mut scope)?);
+        Ok(())
     }
     pub fn update(&mut self, dt: f32) -> Result<()> {
-        self.call_with_state("update", &[fv(dt)])
+        self.call_with_state("update", &[fv(dt)], true)
     }
     pub fn draw(&mut self) -> Result<()> {
-        self.call_with_state("draw", &[])
+        self.call_with_state("draw", &[], false)
     }
 }

compiler/game/tests/fixtures/assets_fixture.plum CHANGED Viewed

@@ -9,27 +9,25 @@ import std/game/Color
 import std/game/Game
 import std/Io
-# Loads through the raw `io` (a missing file answers -1 or empty, where `Assets` would crash),
+# Loads through the raw `io` (a missing file answers -1 or empty, where `Texture.load`
-# and draws through the `Canvas`.
+# would crash) and draws through it.
-struct State(Game(engine), io: Io, mut frames: Int) =
+struct State(frames: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> State =
-    self.frames = self.frames + 1
+    State(frames: self.frames + 1)
   # Loads a texture and files from the asset root and reports what came back as text.
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    io := self.io
-    c := self.canvas
     t := Texture(id: io.textureLoad("sprites.png"))
-    c.drawText("size {c.textureWidth(t)}x{c.textureHeight(t)}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("size {io.textureWidth(t.id)}x{io.textureHeight(t.id)}", 0.0, 0.0, 8.0, Color.White)
-    c.setSmooth(t, true)
+    t.setSmooth(io, true)
-    c.drawTexture(t, 1.0, 2.0, Color.White)
+    t.draw(io, 1.0, 2.0, Color.White)
-    c.drawTextureEx(t, 16.0, 0.0, 16.0, 16.0, 10.0, 20.0, 32.0, 48.0, 0.5, true, Color.Blue)
+    io.drawTextureEx(t.id, 16.0, 0.0, 16.0, 16.0, 10.0, 20.0, 32.0, 48.0, 0.5, true, Color.Blue)
-    c.drawText("bad {c.textureWidth(Texture(id: 99))} {io.textureLoad("missing.png")}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("bad {io.textureWidth(99)} {io.textureLoad("missing.png")}", 0.0, 0.0, 8.0, Color.White)
     if io.fileExists("hello.txt")
-      c.drawText("file [{io.fileLoad("hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
+      io.drawText("file [{io.fileLoad("hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
-    c.drawText("missing [{io.fileLoad("nope.txt")}] {io.fileExists("nope.txt")}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("missing [{io.fileLoad("nope.txt")}] {io.fileExists("nope.txt")}", 0.0, 0.0, 8.0, Color.White)
-    c.drawText("escape {io.textureLoad("../sprites.png")} {io.fileExists("../hello.txt")} [{io.fileLoad("../hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("escape {io.textureLoad("../sprites.png")} {io.fileExists("../hello.txt")} [{io.fileLoad("../hello.txt")}]", 0.0, 0.0, 8.0, Color.White)
-    c.drawText("abs {io.textureLoad("/etc/hosts")} {io.fileExists("/etc/hosts")}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("abs {io.textureLoad("/etc/hosts")} {io.fileExists("/etc/hosts")}", 0.0, 0.0, 8.0, Color.White)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> State =
-  State(engine: Engine.create(io), io: io, frames: 0)
+  State(frames: 0)

compiler/game/tests/fixtures/host_fixture.plum CHANGED Viewed

@@ -9,19 +9,19 @@ import std/game/Color
 import std/game/Game
 import std/Io
-# Keeps `io` for the one raw host read (`mousePos`), so the recorded call order stays the same.
+# One raw host read in `draw` (`mousePos`), so the recorded call order is fixed.
-struct State(Game(engine), io: Io, mut frames: Int) =
+struct State(frames: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> State =
-    self.frames = self.frames + 1
+    State(frames: self.frames + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    self.canvas.clear(Color.Black)
+    io.clear(Color.Black)
-    self.canvas.drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
+    io.drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
-    self.canvas.drawCircle(5.0, 6.0, 7.0, Color.Green)
+    io.drawCircle(5.0, 6.0, 7.0, Color.Green)
-    p := self.io.mousePos()
+    p := io.mousePos()
-    self.canvas.drawText("hi", p.x, p.y, 16.0, Color.White)
+    io.drawText("hi", p.x, p.y, 16.0, Color.White)
     if self.frames > 0
-      self.canvas.drawText("frames {self.frames}", 0.0, 0.0, 8.0, Color.White)
+      io.drawText("frames {self.frames}", 0.0, 0.0, 8.0, Color.White)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> State =
-  State(engine: Engine.create(io), io: io, frames: 0)
+  State(frames: 0)

compiler/game/tests/fixtures/main_game_fixture.plum CHANGED Viewed

@@ -11,18 +11,17 @@ import std/game/Game
 import std/game/Input
 import std/Io
-# A game whose entry is `main`, declared to return the subtype `Orbs`.
+# A game whose entry is `main`, declared to return `Orbs`, which has `update` and `draw`.
-struct Orbs(Game(engine), mut x: Float, ship: Texture) =
+struct Orbs(x: Float, ship: Texture, input: Input, frame: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Orbs =
-    if self.input.isKeyDown(Key.Right)
+    input := self.input.poll(io)
-      self.x = self.x + 100.0 * dt
+    x := if input.isKeyDown(Key.Right) then self.x + 100.0 * dt else self.x
+    Orbs(..self, x: x, input: input, frame: self.frame + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    first := self.input.events().length()
+    first := self.input.events.length()
-    second := self.input.events().length()
+    second := self.input.events.length()
-    again := self.assets.texture("sprites.png")
-    self.canvas.drawText("clock {self.clock.frame} {self.engine.clock.frame} ev {first} {second} x {self.x} tex {self.ship.id} {again.id} w {self.canvas.width()}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("frame {self.frame} ev {first} {second} x {self.x} tex {self.ship.id} w {io.screenWidth()}", 0.0, 0.0, 8.0, Color.White)
 fun main(io: Io) -> Orbs =
-  e := Engine.create(io)
-  Orbs(engine: e, x: 0.0, ship: e.assets.texture("sprites.png"))
+  Orbs(x: 0.0, ship: Texture.load(io, "sprites.png"), input: Input.create(), frame: 0)

compiler/game/tests/fixtures/main_missing_fixture.plum CHANGED Viewed

@@ -3,17 +3,16 @@ module main_missing_fixture
 import std/Int
 import std/Float
 import std/Str
+import std/game/Color
 import std/game/Game
 import std/Io
-struct Broken(Game(engine)) =
+struct Broken(tex: Texture) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Broken =
-    return
+    self
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    return
+    io.clear(Color.Black)
 fun main(io: Io) -> Broken =
-  e := Engine.create(io)
-  _ := e.assets.texture("nope.png")
+  Broken(tex: Texture.load(io, "nope.png"))
-  Broken(engine: e)

compiler/game/tests/fixtures/target_fixture.plum CHANGED Viewed

@@ -9,22 +9,20 @@ import std/game/Game
 import std/Io
 # `bad` is a raw `io.textureCreate` of an impossible size: it answers -1 where
-# `Canvas.createTexture` would crash.
+# `Texture.create` would crash.
-struct State(Game(engine), target: Texture, bad: Int) =
+struct State(target: Texture, bad: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> State =
-    return
+    self
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    c := self.canvas
-    c.renderTarget(self.target)
+    self.target.renderTarget(io)
-    c.clear(Color.Transparent)
+    io.clear(Color.Transparent)
-    c.drawRect(0.0, 0.0, 10.0, 10.0, Color.Red)
+    io.drawRect(0.0, 0.0, 10.0, 10.0, Color.Red)
-    c.screenTarget()
+    Texture.screen(io)
-    c.blendMode(Blend.Add)
+    io.blendMode(Blend.Add)
-    c.drawTexture(self.target, 20.0, 20.0, Color.White)
+    self.target.draw(io, 20.0, 20.0, Color.White)
-    c.blendMode(Blend.Normal)
+    io.blendMode(Blend.Normal)
-    c.drawText("size {c.textureWidth(self.target)}x{c.textureHeight(self.target)} bad {self.bad}", 0.0, 0.0, 8.0, Color.White)
+    io.drawText("size {self.target.width(io)}x{self.target.height(io)} bad {self.bad}", 0.0, 0.0, 8.0, Color.White)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> State =
-  e := Engine.create(io)
-  State(engine: e, target: e.canvas.createTexture(64, 32), bad: io.textureCreate(0, 5))
+  State(target: Texture.create(io, 64, 32), bad: io.textureCreate(0, 5))

compiler/game/tests/host_test.rs CHANGED Viewed

@@ -96,7 +96,7 @@ fn oldInitEntryIsRejected() {
     let out = plum_wasm_codegen::compile(&source, &plum_wasm_codegen::CompileOptions::default()).expect("compile");
     assert!(!out.isGame);
     let err = PlumGame::load(&out.wasm, Recorder::new()).err().expect("should fail");
-    assert!(err.to_string().contains("`main`") && err.to_string().contains("fun main(io: Io) -> Game"), "{err}");
+    assert!(err.to_string().contains("`main`") && err.to_string().contains("fun main(io: Io) -> YourGame"), "{err}");
 }
 #[test]
@@ -106,7 +106,7 @@ fn unknownImportTraps() {
     let path = dir.join("m.plum");
     std::fs::write(
         &path,
-        "import std/Int\nimport std/Float\nimport std/Str\nimport std/Io\nimport std/game/Game\nstruct State(Game(engine), io: Io) =\n  override fun update(self, dt: Float) =\n    return\n  override fun draw(self) =\n    x := self.io.rawExists(\"a\")\n\nfun main(io: Io) -> Game =\n  State(engine: Engine.create(io), io: io)\n",
+        "import std/Int\nimport std/Float\nimport std/Str\nimport std/Io\nimport std/game/Game\nstruct State(n: Int) =\n  fun update(self, io: Io, dt: Float) -> State =\n    self\n  fun draw(self, io: Io) =\n    x := io.rawExists(\"a\")\n\nfun main(io: Io) -> State =\n  State(n: 0)\n",
     )
     .unwrap();
     let wasm = compile(&path);
@@ -207,7 +207,7 @@ fn assetPathEscapeRejected() {
 #[test]
 fn exampleGameRunsFrames() {
-    let wasm = compile(&root().join("examples/games/imperative/game.plum"));
+    let wasm = compile(&root().join("examples/games/orb_run.plum"));
     let mut g = PlumGame::load(&wasm, Recorder::with_assets(examples_assets())).expect("load game");
     g.init().expect("init");
     for _ in 0..60 {
@@ -270,8 +270,8 @@ fn soundPathEscapeRejected() {
 }
 #[test]
-fn sceneExampleRunsFrames() {
+fn balloonExampleRunsFrames() {
-    let wasm = compile(&root().join("examples/games/imperative/scene.plum"));
+    let wasm = compile(&root().join("examples/games/kids/balloon_pop.plum"));
     let mut g = PlumGame::load(&wasm, Recorder::with_assets(examples_assets())).expect("load game");
     g.init().expect("init");
     for _ in 0..10 {
@@ -281,57 +281,6 @@ fn sceneExampleRunsFrames() {
     assert!(g.backend().calls.iter().any(|c| c.starts_with("draw")), "{:?}", g.backend().calls);
 }
-#[test]
-fn pureSceneExampleRunsFrames() {
-    let wasm = compile(&root().join("examples/games/pure/game_pure_scene.plum"));
-    let mut g = PlumGame::load(&wasm, Recorder::with_assets(examples_assets())).expect("load game");
-    g.init().expect("init");
-    for _ in 0..10 {
-        g.update(1.0 / 60.0).expect("update");
-    }
-    g.draw().expect("draw");
-    assert!(g.backend().calls.iter().any(|c| c.starts_with("draw")), "{:?}", g.backend().calls);
-}
-#[test]
-fn pureSceneMatchesSceneDrawCounts() {
-    let load = |name: &str| {
-        let wasm = compile(&root().join(name));
-        let mut g = PlumGame::load(&wasm, Recorder::with_assets(examples_assets())).expect("load game");
-        g.init().expect("init");
-        g
-    };
-    let mut a = load("examples/games/imperative/game_scene.plum");
-    let mut b = load("examples/games/pure/game_pure_scene.plum");
-    let tex_ids = |calls: &[String]| {
-        let mut v: Vec<String> = calls
-            .iter()
-            .filter(|c| c.starts_with("drawTextureEx("))
-            .map(|c| c["drawTextureEx(".len()..].split(',').next().unwrap().to_string())
-            .collect();
-        v.sort();
-        v.dedup();
-        v
-    };
-    let count = |calls: &[String], p: &str| calls.iter().filter(|c| c.starts_with(p)).count();
-    for frame in 0..60 {
-        let mut calls = Vec::new();
-        for g in [&mut a, &mut b] {
-            g.backend_mut().calls.clear();
-            g.update(1.0 / 60.0).expect("update");
-            g.draw().expect("draw");
-            calls.push(g.backend().calls.clone());
-        }
-        let (ca, cb) = (&calls[0], &calls[1]);
-        assert!(
-            count(ca, "drawTextureEx(") == count(cb, "drawTextureEx(")
-                && count(ca, "drawText(") == count(cb, "drawText(")
-                && tex_ids(ca) == tex_ids(cb),
-            "frame {frame}\nscene: {ca:?}\npure: {cb:?}"
-        );
-    }
-}
 #[test]
 fn renderTargetAndBlendCallsAreRecorded() {
     let wasm = compile(&Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/target_fixture.plum"));
@@ -365,7 +314,7 @@ fn randomSeedProvidedByHost() {
     let path = dir.join("m.plum");
     std::fs::write(
         &path,
-        "import std/Int\nimport std/Float\nimport std/Str\nimport std/Io\nimport std/game/Color\nimport std/game/Game\nstruct State(Game(engine), seed: Int) =\n  override fun update(self, dt: Float) =\n    return\n  override fun draw(self) =\n    self.canvas.drawText(\"seed {self.seed}\", 0.0, 0.0, 8.0, Color.White)\n\nfun main(io: Io) -> Game =\n  State(engine: Engine.create(io), seed: io.randomSeed())\n",
+        "import std/Int\nimport std/Float\nimport std/Str\nimport std/Io\nimport std/game/Color\nimport std/game/Game\nstruct State(seed: Int) =\n  fun update(self, io: Io, dt: Float) -> State =\n    self\n  fun draw(self, io: Io) =\n    io.drawText(\"seed {self.seed}\", 0.0, 0.0, 8.0, Color.White)\n\nfun main(io: Io) -> State =\n  State(seed: io.randomSeed())\n",
     )
     .unwrap();
     let wasm = compile(&path);
@@ -394,7 +343,7 @@ fn mainGame(rec: Recorder) -> PlumGame<Recorder> {
 }
 #[test]
-fn mainReturningGameSubtypeIsAGame() {
+fn mainReturningATypeWithUpdateAndDrawIsAGame() {
     assert!(fixtureOut("main_game_fixture.plum").isGame);
     assert!(!fixtureOut("main_cli_fixture.plum").isGame);
     assert!(fixtureOut("host_fixture.plum").isGame);
@@ -408,7 +357,7 @@ fn nonGameMainStaysACliProgram() {
 }
 #[test]
-fn clockTicksOncePerFrameAndIsShared() {
+fn stateReturnedByUpdateIsTheNextFramesSelf() {
     let mut g = mainGame(Recorder::with_assets(examples_assets()));
     for _ in 0..3 {
         g.update(0.016).unwrap();
@@ -416,8 +365,8 @@ fn clockTicksOncePerFrameAndIsShared() {
         g.draw().unwrap();
     }
     let last = g.backend().calls.iter().rev().find(|c| c.starts_with("drawText")).unwrap().clone();
-    // Drawing twice per frame does not tick again; Game.clock is Engine.clock.
+    // Drawing twice per frame does not advance the state; each update does.
-    assert!(last.contains("clock 3 3 "), "{last}");
+    assert!(last.contains("frame 3 "), "{last}");
 }
 #[test]
@@ -437,7 +386,7 @@ fn eventsPolledOncePerFrame() {
 }
 #[test]
-fn gameUpdateDispatchesAndAssetsCache() {
+fn gameUpdateDispatchesAndTheTextureLoadsOnce() {
     let mut rec = Recorder::with_assets(examples_assets());
     rec.keys_down.insert(262);
     let mut g = mainGame(rec);
@@ -446,7 +395,7 @@ fn gameUpdateDispatchesAndAssetsCache() {
     let calls = &g.backend().calls;
     assert_eq!(calls.iter().filter(|c| c.starts_with("textureLoad")).count(), 1, "{calls:?}");
     let last = calls.iter().rev().find(|c| c.starts_with("drawText")).unwrap();
-    assert!(last.contains("x 50.0 tex 0 0"), "{last}");
+    assert!(last.contains("x 50.0 tex 0 "), "{last}");
     assert!(last.contains("w 800.0"), "{last}");
 }

compiler/game/web-test/README.md CHANGED Viewed

@@ -19,10 +19,10 @@ Downloads the Chromium and WebKit builds matching the bundled Playwright driver
 ## Usage
-    cargo run --manifest-path compiler/game/web-test/Cargo.toml -- examples/games/imperative/game.plum --screenshot /tmp/orb-run.png
+    cargo run --manifest-path compiler/game/web-test/Cargo.toml -- examples/games/orb_run.plum --screenshot /tmp/orb-run.png
-Options: `--browser chromium|webkit` (default chromium; WebKit is Playwright's Safari-engine build and has WebGPU, so the same render assertions apply; a WebKit build without `navigator.gpu` is checked for the "WebGPU is not supported in this browser" message and a loadable plum.wasm instead), `--expect-unsupported-webgpu` (hides `navigator.gpu` in any browser and checks that path), `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw the TypeError Safari gives for typed GC references), `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--assets DIR` (default: the nearest `assets` folder beside the source or in a parent, e.g. `examples/games/assets`), `--require-audio`, `--json` (adds a one-line JSON object with the backend and frame stats), `--headed` (a real GPU window instead of headless software WebGPU), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame), `--dpr N` (Playwright `deviceScaleFactor`; also checks the backing store is CSS size x ratio), `--lose-device` (destroys the GPU device from the page after a few frames and requires the `GPU device lost (...); restored` log and resumed rendering; the page exposes the device only when the harness asks) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y), default tolerance 2). `--json` also reports `draws`, the GPU draw calls per frame. `fixtures/interleave.plum`, `text_sizes.plum` and `rendertarget.plum` exercise multi-texture batching, SDF text and render targets/blend modes. `fixtures/stress.plum` and `fixtures/stress_scene.plum` are the scenes behind [BENCHMARK.md](BENCHMARK.md).
+Options: `--browser chromium|webkit` (default chromium; WebKit is Playwright's Safari-engine build and has WebGPU, so the same render assertions apply; a WebKit build without `navigator.gpu` is checked for the "WebGPU is not supported in this browser" message and a loadable plum.wasm instead), `--expect-unsupported-webgpu` (hides `navigator.gpu` in any browser and checks that path), `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw the TypeError Safari gives for typed GC references), `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--assets DIR` (default: the nearest `assets` folder beside the source or in a parent, e.g. `examples/games/assets`), `--require-audio`, `--json` (adds a one-line JSON object with the backend and frame stats), `--headed` (a real GPU window instead of headless software WebGPU), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame), `--dpr N` (Playwright `deviceScaleFactor`; also checks the backing store is CSS size x ratio), `--lose-device` (destroys the GPU device from the page after a few frames and requires the `GPU device lost (...); restored` log and resumed rendering; the page exposes the device only when the harness asks) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y), default tolerance 2). `--json` also reports `draws`, the GPU draw calls per frame. `fixtures/interleave.plum`, `text_sizes.plum` and `rendertarget.plum` exercise multi-texture batching, SDF text and render targets/blend modes. `fixtures/stress.plum`, `fixtures/stress_state_view.plum` and `fixtures/stress_world.plum` are the scenes behind [BENCHMARK.md](BENCHMARK.md).
 Exit code is non-zero with a message on failure.
 `cargo test --manifest-path compiler/game/web-test/Cargo.toml` runs the same check on
-`examples/games/imperative/game.plum`, `examples/games/imperative/game_scene.plum` and `examples/games/imperative/scene.plum`, plus WebKit runs; each skips with a note if its browser is not installed.
+`examples/games/orb_run.plum`, `examples/games/kids/balloon_pop.plum` and `fixtures/stress_state_view.plum`, plus WebKit runs; each skips with a note if its browser is not installed.

compiler/game/web-test/fixtures/interleave.plum CHANGED Viewed

@@ -17,23 +17,22 @@ primitive Scene =
   WorldW = 1264
   WorldH = 704
-struct Interleave(Game(engine), tex: Array[Texture], mut t: Int) =
+struct Interleave(tex: Array[Texture], t: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Interleave =
-    self.t = self.t + 1
+    Interleave(..self, t: self.t + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    drawSprites(self.canvas, self.tex, self.t)
+    drawSprites(io, self.tex, self.t)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Interleave =
-  e := Engine.create(io)
   tex := Array.filled(Scene.Textures, Texture(id: -1))
   for i := range Scene.Textures
-    tex.set(i, e.assets.texture("tex{i}.png"))
+    tex.set(i, Texture.load(io, "tex{i}.png"))
-  Interleave(engine: e, tex: tex, t: 0)
+  Interleave(tex: tex, t: 0)
-fun drawSprites(canvas: Canvas, tex: Array[Texture], t: Int) =
+fun drawSprites(io: Io, tex: Array[Texture], t: Int) =
-  canvas.clear(Color.rgb(0.05, 0.06, 0.1))
+  io.clear(Color.rgb(0.05, 0.06, 0.1))
   for i := range Scene.Sprites
     x := {i * 37 + t * {1 + i % 5}} % Scene.WorldW
     y := {i * 53 + t * {1 + i % 3}} % Scene.WorldH
-    canvas.drawTexture(tex.get(i % Scene.Textures), Float(x), Float(y), Color.White)
+    tex.get(i % Scene.Textures).draw(io, Float(x), Float(y), Color.White)

compiler/game/web-test/fixtures/main_game.plum CHANGED Viewed

@@ -8,15 +8,15 @@ import std/game/Color
 import std/game/Game
 import std/Io
-# A game whose entry is `main` returning a Game subtype; draws a square that moves with the clock.
+# A game whose entry is `main` returning a type with `update` and `draw`; draws a square that moves with the frame count.
-struct Mover(Game(engine)) =
+struct Mover(frame: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Mover =
-    return
+    Mover(frame: self.frame + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    self.canvas.clear(Color.rgb(0.2, 0.2, 0.2))
+    io.clear(Color.rgb(0.2, 0.2, 0.2))
-    self.canvas.drawRect(Float(self.clock.frame % 600), 100.0, 40.0, 40.0, Color.Yellow)
+    io.drawRect(Float(self.frame % 600), 100.0, 40.0, 40.0, Color.Yellow)
-    self.canvas.drawText("frame {self.clock.frame}", 20.0, 20.0, 16.0, Color.White)
+    io.drawText("frame {self.frame}", 20.0, 20.0, 16.0, Color.White)
 fun main(io: Io) -> Mover =
-  Mover(engine: Engine.create(io))
+  Mover(frame: 0)

compiler/game/web-test/fixtures/rendertarget.plum CHANGED Viewed

@@ -19,42 +19,40 @@ import std/game/Color
 import std/game/Game
 import std/Io
-struct Targets(Game(engine), big: Texture, small: Texture, glass: Texture, mut t: Int) =
+struct Targets(big: Texture, small: Texture, glass: Texture, t: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Targets =
-    self.t = self.t + 1
+    Targets(..self, t: self.t + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    drawTargets(self.canvas, self)
+    drawTargets(io, self)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Targets =
-  e := Engine.create(io)
-  c := e.canvas
-  Targets(engine: e, big: c.createTexture(64, 64), small: c.createTexture(16, 16), glass: c.createTexture(16, 16), t: 0)
+  Targets(big: Texture.create(io, 64, 64), small: Texture.create(io, 16, 16), glass: Texture.create(io, 16, 16), t: 0)
-fun drawTargets(canvas: Canvas, g: Targets) =
+fun drawTargets(io: Io, g: Targets) =
-  canvas.setCamera(10.0, 0.0, 2.0)
+  io.setCamera(10.0, 0.0, 2.0)
-  canvas.renderTarget(g.big)
+  g.big.renderTarget(io)
-  canvas.clear(Color.Transparent)
+  io.clear(Color.Transparent)
-  canvas.drawRect(0.0, 0.0, 32.0, 32.0, Color.rgb(1.0, 0.0, 0.0))
+  io.drawRect(0.0, 0.0, 32.0, 32.0, Color.rgb(1.0, 0.0, 0.0))
-  canvas.drawRect(32.0, 32.0, 32.0, 32.0, Color.rgb(0.0, 1.0, 0.0))
+  io.drawRect(32.0, 32.0, 32.0, 32.0, Color.rgb(0.0, 1.0, 0.0))
-  canvas.renderTarget(g.small)
+  g.small.renderTarget(io)
-  canvas.clear(Color.rgb(0.0, 0.0, 1.0))
+  io.clear(Color.rgb(0.0, 0.0, 1.0))
-  canvas.renderTarget(g.glass)
+  g.glass.renderTarget(io)
-  canvas.clear(Color.Transparent)
+  io.clear(Color.Transparent)
-  canvas.drawRect(0.0, 0.0, 16.0, 16.0, Color(r: 1.0, g: 0.0, b: 0.0, a: 0.5))
+  io.drawRect(0.0, 0.0, 16.0, 16.0, Color(r: 1.0, g: 0.0, b: 0.0, a: 0.5))
-  canvas.screenTarget()
+  Texture.screen(io)
-  canvas.clear(Color.rgb(0.2, 0.2, 0.2))
+  io.clear(Color.rgb(0.2, 0.2, 0.2))
-  canvas.drawTexture(g.big, 60.0, 50.0, Color.White)
+  g.big.draw(io, 60.0, 50.0, Color.White)
-  canvas.resetCamera()
+  io.resetCamera()
-  canvas.blendMode(Blend.Add)
+  io.blendMode(Blend.Add)
-  canvas.drawRect(400.0, 100.0, 100.0, 100.0, Color.rgb(0.2, 0.4, 0.6))
+  io.drawRect(400.0, 100.0, 100.0, 100.0, Color.rgb(0.2, 0.4, 0.6))
-  canvas.blendMode(Blend.Multiply)
+  io.blendMode(Blend.Multiply)
-  canvas.drawRect(550.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 1.0, 0.5))
+  io.drawRect(550.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 1.0, 0.5))
-  canvas.blendMode(Blend.Screen)
+  io.blendMode(Blend.Screen)
-  canvas.drawRect(700.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 0.5, 0.5))
+  io.drawRect(700.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 0.5, 0.5))
-  canvas.blendMode(Blend.Normal)
+  io.blendMode(Blend.Normal)
-  canvas.drawRect(850.0, 100.0, 100.0, 100.0, Color(r: 1.0, g: 0.0, b: 0.0, a: 0.5))
+  io.drawRect(850.0, 100.0, 100.0, 100.0, Color(r: 1.0, g: 0.0, b: 0.0, a: 0.5))
-  canvas.drawTexture(g.small, 400.0, 300.0, Color.White)
+  g.small.draw(io, 400.0, 300.0, Color.White)
-  canvas.drawTexture(g.glass, 400.0, 400.0, Color.White)
+  g.glass.draw(io, 400.0, 400.0, Color.White)
-  canvas.drawText("frame {g.t}", 20.0, 500.0, 16.0, Color.White)
+  io.drawText("frame {g.t}", 20.0, 500.0, 16.0, Color.White)
-  canvas.drawRect(Float(g.t % 600), 600.0, 40.0, 6.0, Color.Yellow)
+  io.drawRect(Float(g.t % 600), 600.0, 40.0, 6.0, Color.Yellow)

compiler/game/web-test/fixtures/stress.plum CHANGED Viewed

@@ -19,36 +19,35 @@ primitive Scene =
   WorldW = 1600
   WorldH = 900
-struct Stress(Game(engine), sheet: Texture, mut t: Int) =
+struct Stress(sheet: Texture, t: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Stress =
-    self.t = self.t + 1
+    Stress(..self, t: self.t + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    drawStress(self.canvas, self.sheet, self.t)
+    drawStress(io, self.sheet, self.t)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Stress =
-  e := Engine.create(io)
-  Stress(engine: e, sheet: e.assets.texture("sprites.png"), t: 0)
+  Stress(sheet: Texture.load(io, "sprites.png"), t: 0)
 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)
-fun drawStress(canvas: Canvas, sheet: Texture, t: Int) =
+fun drawStress(io: Io, sheet: Texture, t: Int) =
-  canvas.clear(Color.rgb(0.05, 0.06, 0.1))
+  io.clear(Color.rgb(0.05, 0.06, 0.1))
-  canvas.setCamera(0.0, 0.0, 0.8)
+  io.setCamera(0.0, 0.0, 0.8)
   for i := range Scene.Sprites
     x := {i * 37 + t * {1 + i % 5}} % Scene.WorldW
     y := {i * 53 + t * {1 + i % 3}} % Scene.WorldH
     frame := {i + t / 6} % 4
-    canvas.drawTextureEx(sheet, Float(frame * 16), 0.0, 16.0, 16.0, Float(x), Float(y), 16.0, 16.0, Float(t) * 0.02 + Float(i), i % 2 == 0, Color.White)
+    io.drawTextureEx(sheet.id, Float(frame * 16), 0.0, 16.0, 16.0, Float(x), Float(y), 16.0, 16.0, Float(t) * 0.02 + Float(i), i % 2 == 0, Color.White)
   for i := range Scene.Rects
     x := {i * 61 + t * 2} % Scene.WorldW
     y := {i * 29} % Scene.WorldH
-    canvas.drawRect(Float(x), Float(y), 12.0, 8.0, hue(i))
+    io.drawRect(Float(x), Float(y), 12.0, 8.0, hue(i))
   for i := range Scene.Circles
     x := {i * 83 + t * 3} % Scene.WorldW
     y := {i * 47 + t} % Scene.WorldH
-    canvas.drawCircle(Float(x), Float(y), 6.0, hue(i + 3))
+    io.drawCircle(Float(x), Float(y), 6.0, hue(i + 3))
   for i := range Scene.Texts
-    canvas.drawText("n {t + i}", Float(i * 30 % Scene.WorldW), Float(i * 17 % Scene.WorldH), 14.0, Color.White)
+    io.drawText("n {t + i}", Float(i * 30 % Scene.WorldW), Float(i * 17 % Scene.WorldH), 14.0, Color.White)
-  canvas.resetCamera()
+  io.resetCamera()

compiler/game/web-test/fixtures/stress_pure_scene.plum DELETED Viewed

@@ -1,144 +0,0 @@
-# The stress scene of stress_scene.plum on the PURE scene graph (std/game/pure/PureScene):
-# 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
-# 1x1 white texture), 50 texts with a changing number, drawn through a camera. Every
-# node is a unique value: each frame changes the tree in place with Node.update. Group and
-# sprite spin comes from `forever(rotateBy(...))` actions; drifting and counting
-# actors do theirs in `act`.
-module stress_pure_scene
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Option
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/game/pure/Actions
-import std/game/pure/PureScene
-import std/game/pure/SceneInput
-import std/Io
-primitive Counts =
-  Sprites = 5000
-  Rects = 500
-  Circles = 200
-  Texts = 50
-  Groups = 50
-  WorldW = 1600
-  WorldH = 900
-struct World(sheet: Texture, mut stage: Stage)
-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)
-fun quad(canvas: Canvas, m: Affine, tint: Color, w: Float, h: Float, tex: Texture, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
-  sx := w * m.scaleX()
-  sy := h * m.scaleY()
-  c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
-  canvas.drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, tint)
-fun caption(canvas: Canvas, m: Affine, tint: Color, s: Str, size: Float) =
-  p := m.apply(Vec2(x: 0.0, y: 0.0))
-  canvas.drawText(s, p.x, p.y, size * m.scaleY(), tint)
-# A square of the white texture that moves by (dx, dy) per frame and wraps.
-struct Drifter(Actor, tex: Texture, dx: Float, dy: Float) =
-  override fun act(self, n: Node, dt: Float) -> Node =
-    x := n.x + self.dx
-    y := n.y + self.dy
-    if x > Float(Counts.WorldW)
-      x = x - Float(Counts.WorldW)
-    if y > Float(Counts.WorldH)
-      y = y - Float(Counts.WorldH)
-    Node(..n, x: x, y: y)
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    quad(canvas, m, tint, n.width, n.height, self.tex, 0.0, 0.0, 0.0, 0.0)
-# Shows "n <count>" and counts up each frame.
-struct CountLabel(Actor, n: Int, text: Str) =
-  override fun act(self, n: Node, dt: Float) -> Node =
-    k := self.n + 1
-    Node(..n, kind: Custom(CountLabel(n: k, text: "n {k}")))
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    caption(canvas, m, tint, self.text, 14.0)
-fun drifter(id: Int, tex: Texture, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Node =
-  d := Drifter(tex: tex, dx: dx, dy: dy)
-  me: Actor := d
-  n := Node.custom(id, x, y, w, h, me)
-  Node(..n, color: c)
-fun countLabel(id: Int, n: Int, x: Float, y: Float) -> Node =
-  l := CountLabel(n: n, text: "n {n}")
-  me: Actor := l
-  Node.custom(id, x, y, 60.0, 14.0, me)
-fun spinning(rate: Float) -> Slice[Action] =
-  acts := Slice[Action]()
-  acts.push(Action.forever(Action.rotateBy(rate, 1.0)))
-  acts
-fun dancer(id: Int, sheet: Texture, j: Int, i: Int) -> Node =
-  s := Node.sprite(id, sheet, Float({j * j * 13 + j * 37} % 150), Float({j * j * 29 + j * 53} % 170), 16.0, 16.0)
-  Node(..s, originX: 8.0, originY: 8.0, rotation: Float(i),
-    kind: Sprite(tex: sheet, srcX: Float(i % 4 * 16), srcY: 0.0, srcW: 16.0, srcH: 16.0), actions: spinning(1.2))
-fun buildWorld(sheet: Texture, white: Texture) -> World =
-  root := Slice[Node]()
-  per := Counts.Sprites / Counts.Groups
-  for gi := range Counts.Groups
-    kids := Slice[Node]()
-    for j := range per
-      i := gi * per + j
-      kids.push(dancer(1000 + i, sheet, j, i))
-    g := Node.group(100 + gi, Float(gi % 10 * 160), Float(gi / 10 * 180), 150.0, 170.0, kids)
-    root.push(Node(..g, originX: 75.0, originY: 85.0, actions: spinning(0.24)))
-  for i := range Counts.Rects
-    root.push(drifter(10000 + i, white, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
-  for i := range Counts.Circles
-    root.push(drifter(20000 + i, white, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
-  for i := range Counts.Texts
-    root.push(countLabel(30000 + i, i, Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
-  top := Node.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
-  cam := Affine(a: 0.8, b: 0.0, c: 0.0, d: 0.8, e: 0.0, f: 0.0)
-  World(sheet: sheet, stage: Stage(root: top, camera: cam, captured: None, focus: None))
-fun whiteTexture(canvas: Canvas) -> Texture =
-  t := canvas.createTexture(1, 1)
-  canvas.renderTarget(t)
-  canvas.clear(Color.White)
-  canvas.screenTarget()
-  t
-fun frameStage(s: Stage, dt: Float) -> Stage =
-  s.frame(dt, Slice[InputEvent]()).intoStage()
-fun advance(w: World, dt: Float) =
-  w.stage = frameStage(w.stage, dt)
-# The game around the world, so the test below needs no engine.
-struct PureGame(Game(engine), world: World) =
-  override fun update(self, dt: Float) =
-    advance(self.world, dt)
-  override fun draw(self) =
-    self.canvas.clear(Color.rgb(0.05, 0.06, 0.1))
-    self.world.stage.draw(self.canvas)
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  PureGame(engine: e, world: buildWorld(e.assets.texture("sprites.png"), whiteTexture(e.canvas)))
-test "ten frames of update run"
-  w := buildWorld(Texture(id: 0), Texture(id: 0))
-  for i := range 10
-    advance(w, 0.016)
-  if Some(k) := w.stage.root.children()
-    assert k.length() == 50 + 500 + 200 + 50
-    assert {k.at(50).x - 20.0}.abs() < 0.000001
-  else
-    assert false

compiler/game/web-test/fixtures/stress_scene.plum DELETED Viewed

@@ -1,117 +0,0 @@
-# The stress scene of stress.plum built as a Scene2D-like scene graph (std/game/imperative/Scene):
-# 5000 sprites in 50 slowly rotating groups, 500 rects, 200 circles and 50 texts
-# with a changing number, drawn through a camera. Every node moves in its own
-# `act`, so each frame runs ~5800 override-dispatched acts and a composed-transform draw.
-module stress_scene
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/game/Vec2
-import std/game/Color
-import std/game/Game
-import std/game/imperative/Scene
-import std/Io
-primitive Counts =
-  Sprites = 5000
-  Rects = 500
-  Circles = 200
-  Texts = 50
-  Groups = 50
-  WorldW = 1600
-  WorldH = 900
-struct Demo(Game(engine), sheet: Texture, stage: Stage) =
-  override fun update(self, dt: Float) =
-    self.stage.act(dt)
-  override fun draw(self) =
-    self.canvas.clear(Color.rgb(0.05, 0.06, 0.1))
-    self.stage.draw(self.canvas)
-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)
-# The actor kinds of this scene: structs embedding the Actor base struct (its subtypes), each with its own `act`.
-struct SpinGroup(Actor) =
-  fun init(self) =
-    self.originX = 75.0
-    self.originY = 85.0
-  override fun act(self, dt: Float) =
-    self.rotation = self.rotation + 0.004
-    self.actChildren(dt)
-# Turns the sprite; its frame follows the angle, advancing every 6 frames.
-struct Dancer(Actor, tex: Texture, mut srcX: Float) =
-  fun init(self) =
-    self.width = 16.0
-    self.height = 16.0
-    self.originX = 8.0
-    self.originY = 8.0
-  override fun act(self, dt: Float) =
-    self.rotation = self.rotation + 0.02
-    self.srcX = Float(Int(self.rotation * 50.0) / 6 % 4 * 16)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, self.srcX, 0.0, 16.0, 16.0)
-struct DriftRect(Actor(color)) =
-  fun init(self) =
-    self.width = 12.0
-    self.height = 8.0
-  override fun act(self, dt: Float) =
-    self.x = self.x + 2.0
-    if self.x > Float(Counts.WorldW)
-      self.x = self.x - Float(Counts.WorldW)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawRectBox(canvas, m, alpha, self.width, self.height, self.color)
-struct DriftCircle(Actor(color)) =
-  fun init(self) =
-    self.width = 12.0
-    self.height = 12.0
-  override fun act(self, dt: Float) =
-    self.x = self.x + 3.0
-    self.y = self.y + 1.0
-    if self.x > Float(Counts.WorldW)
-      self.x = self.x - Float(Counts.WorldW)
-    if self.y > Float(Counts.WorldH)
-      self.y = self.y - Float(Counts.WorldH)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawDisc(canvas, m, alpha, self.width / 2.0, self.color)
-# `n` is the number shown.
-struct CountText(Actor, mut n: Int, mut text: Str) =
-  fun init(self) =
-    self.width = 60.0
-    self.height = 14.0
-    self.text = "n {self.n}"
-  override fun act(self, dt: Float) =
-    self.n = self.n + 1
-    self.text = "n {self.n}"
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawLabel(canvas, m, alpha, self.text, 14.0, self.color)
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  sheet := e.assets.texture("sprites.png")
-  stage := Stage.create()
-  stage.camScale = 0.8
-  per := Counts.Sprites / Counts.Groups
-  for gi := range Counts.Groups
-    g := SpinGroup().at(Float(gi % 10 * 160), Float(gi / 10 * 180))
-    for j := range per
-      i := gi * per + j
-      s := Dancer(tex: sheet, srcX: Float(i % 4 * 16))
-      s.x = Float({j * j * 13 + j * 37} % 150)
-      s.y = Float({j * j * 29 + j * 53} % 170)
-      s.rotation = Float(i)
-      g.add(s)
-    stage.root.add(g)
-  for i := range Counts.Rects
-    stage.root.add(DriftRect(color: hue(i)).at(Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH)))
-  for i := range Counts.Circles
-    stage.root.add(DriftCircle(color: hue(i + 3)).at(Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH)))
-  for i := range Counts.Texts
-    stage.root.add(CountText(n: i, text: "").at(Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
-  Demo(engine: e, sheet: sheet, stage: stage)

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

@@ -22,9 +22,9 @@ import std/List
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/FunctionalScene
+import std/game/Scene
-import std/game/functional/Anim
+import std/game/Anim
-import std/game/functional/Ui
+import std/game/Ui
 import std/game/Input
 import std/Io
@@ -198,28 +198,28 @@ fun view(s: State) -> SceneNode[Int] =
   world: SceneNode[Int] := Group(transform: Scale(sx: 0.8, sy: 0.8), children: toNodes(s.spinners, |p| spinnerView(s.sheet, p), pulses))
   Group(transform: Identity, children: [world, buttonsView(s.ui)])
-fun whiteTexture(canvas: Canvas) -> Texture =
+fun whiteTexture(io: Io) -> Texture =
-  t := canvas.createTexture(1, 1)
+  t := Texture.create(io, 1, 1)
-  canvas.renderTarget(t)
+  t.renderTarget(io)
-  canvas.clear(Color.White)
+  io.clear(Color.White)
-  canvas.screenTarget()
+  Texture.screen(io)
   t
-struct World(Game(engine), mut state: State) =
+struct World(state: State, input: Input) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> World =
+    input := self.input.poll(io)
-    inputs := self.input.events()
+    inputs := input.events
     s := step(self.state, dt)
     for i := range inputs.length()
       s = stepUi(s, inputs.at(i))
-    self.state = s
+    World(state: s, input: input)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    self.canvas.clear(Color.rgb(0.05, 0.06, 0.1))
+    io.clear(Color.rgb(0.05, 0.06, 0.1))
-    view(self.state).draw(self.canvas)
+    view(self.state).draw(io)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> World =
-  e := Engine.create(io)
-  World(engine: e, state: newState(e.assets.texture("sprites.png"), whiteTexture(e.canvas)))
+  World(state: newState(Texture.load(io, "sprites.png"), whiteTexture(io)), input: Input.create())
 test "ten frames of step run"
   s := newState(Texture(id: 0), Texture(id: 0))

compiler/game/web-test/fixtures/stress_state_view_deep.plum CHANGED Viewed

@@ -17,7 +17,7 @@ import std/List
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/FunctionalScene
+import std/game/Scene
 import std/Io
 primitive Counts =
@@ -162,24 +162,23 @@ fun view(s: State) -> SceneNode[Int] =
   drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
   Group(transform: Scale(sx: 0.8, sy: 0.8), children: spinnerNodes(s.sheet, s.spinners, s.dancers, drifts))
-fun whiteTexture(canvas: Canvas) -> Texture =
+fun whiteTexture(io: Io) -> Texture =
-  t := canvas.createTexture(1, 1)
+  t := Texture.create(io, 1, 1)
-  canvas.renderTarget(t)
+  t.renderTarget(io)
-  canvas.clear(Color.White)
+  io.clear(Color.White)
-  canvas.screenTarget()
+  Texture.screen(io)
   t
-struct World(Game(engine), mut state: State) =
+struct World(state: State) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> World =
-    self.state = step(self.state, dt)
+    World(state: step(self.state, dt))
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    self.canvas.clear(Color.rgb(0.05, 0.06, 0.1))
+    io.clear(Color.rgb(0.05, 0.06, 0.1))
-    view(self.state).draw(self.canvas)
+    view(self.state).draw(io)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> World =
-  e := Engine.create(io)
-  World(engine: e, state: newState(e.assets.texture("sprites.png"), whiteTexture(e.canvas)))
+  World(state: newState(Texture.load(io, "sprites.png"), whiteTexture(io)))
 test "ten frames of step run"
   s := newState(Texture(id: 0), Texture(id: 0))

compiler/game/web-test/fixtures/stress_world.plum CHANGED Viewed

@@ -1,18 +1,19 @@
-# A large y-sorted world through the scene graph (std/game/imperative/Scene): 20000 sprites in one
+# A large y-sorted world as state and view: 20000 sprites in one world layer, about 2000
-# world layer, about 2000 of them in the 1280x720 view. Every frame a few hundred
+# of them in the 1280x720 view. Every frame a few hundred sprites walk, the whole list is
-# sprites walk, the layer is y-sorted with `sortChildren`, and (when `Culling` is
+# sorted by y, and only the sprites in the view become scene nodes. The state is the
-# 1) the camera view is set as the layer's culling area so only the visible
+# list, the frame number and the camera; `step` returns the next state and `view` builds
-# sprites are drawn. Set `Culling` to 0 to measure the same scene without culling.
+# the scene from it.
 module stress_world
 import std/Str
 import std/Int
 import std/Float
 import std/Math
+import std/List
 import std/Slice
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/imperative/Scene
+import std/game/Scene
 import std/Io
 primitive World =
@@ -22,59 +23,68 @@ primitive World =
   Height = 2300
   ViewW = 1280.0
   ViewH = 720.0
+# `walker` is the index among the walking sprites, or -1 for one that stands still.
-  Culling = 1
+struct Spr(x: Float, y: Float, srcX: Float, walker: Int)
-struct Demo(sheet: Texture, stage: Stage, layer: Group, mut frame: Int)
+struct State(sheet: Texture, sprites: List[Spr], frame: Int, camX: Float, camY: Float)
+fun walkerOf(i: Int) -> Int =
+  if i % 37 == 0 && i / 37 < World.Walkers then i / 37 else -1
-fun spriteAt(i: Int) -> Vec2 =
+fun spriteAt(i: Int) -> Spr =
-  Vec2(x: Float({i * 7919 + 13} % World.Width), y: Float({i * i * 31 / 7 + i * 1013} % World.Height))
+  Spr(x: Float({i * 7919 + 13} % World.Width), y: Float({i * i * 31 / 7 + i * 1013} % World.Height), srcX: Float(i % 4 * 16), walker: walkerOf(i))
+fun spritesFrom(i: Int) -> List[Spr] =
+  if i >= World.Sprites then Nil else Cons(head: spriteAt(i), tail: spritesFrom(i + 1))
-fun build(sheet: Texture) -> Demo =
+fun newState(sheet: Texture) -> State =
-  stage := Stage.create()
-  layer := Group()
-  for i := range World.Sprites
-    p := spriteAt(i)
-    layer.add(Sprite.create(sheet, Float(i % 4 * 16), 0.0, 16.0, 16.0, 16.0, 16.0).at(p.x, p.y))
-  stage.root.add(layer)
-  Demo(sheet: sheet, stage: stage, layer: layer, frame: 0)
+  State(sheet: sheet, sprites: spritesFrom(0), frame: 0, camX: 0.0, camY: 0.0)
+fun walk(frame: Int, s: Spr) -> Spr =
+  if s.walker < 0
+    s
+  else
+    Spr(..s, y: s.y + Math.sin(Float(frame) * 0.05 + Float(s.walker)))
-# One frame: the camera drifts, some sprites walk, the layer is sorted and culled.
+# One frame: the camera drifts, some sprites walk, the list is sorted by y.
-fun step(g: Demo) =
+fun step(s: State) -> State =
-  g.frame = g.frame + 1
+  frame := s.frame + 1
-  t := Float(g.frame) * 0.01
+  t := Float(frame) * 0.01
-  g.stage.camX = 1300.0 + 600.0 * Math.sin(t)
-  g.stage.camY = 800.0 + 350.0 * Math.cos(t * 0.7)
-  for i := range World.Walkers
-    k := g.layer.children.at(i * 37 % World.Sprites)
+  moved := s.sprites.map(|k| walk(frame, k))
-    k.y = k.y + Math.sin(Float(g.frame) * 0.05 + Float(i))
-  g.layer.sortChildren(|a, b| a.y < b.y)
+  sorted := List.fromSlice(moved.toSlice().sort(|a, b| a.y < b.y))
-  if World.Culling == 1
-    g.layer.setCullingArea(g.stage.camX, g.stage.camY, World.ViewW, World.ViewH)
+  State(..s, sprites: sorted, frame: frame, camX: 1300.0 + 600.0 * Math.sin(t), camY: 800.0 + 350.0 * Math.cos(t * 0.7))
+fun inView(s: State, k: Spr) -> Bool =
+  k.x + 16.0 >= s.camX && k.x <= s.camX + World.ViewW && k.y + 16.0 >= s.camY && k.y <= s.camY + World.ViewH
+fun visible(s: State) -> List[Spr] =
+  s.sprites.filter(|k| inView(s, k))
-# The game around the scene state, so the tests below need no engine.
+fun spriteNode(sheet: Texture, k: Spr) -> SceneNode[Int] =
+  Sprite(tex: sheet, x: k.x, y: k.y, w: 16.0, h: 16.0, srcX: k.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0, tint: Color.White)
+fun view(s: State) -> SceneNode[Int] =
+  Group(transform: Translate(dx: 0.0 - s.camX, dy: 0.0 - s.camY), children: visible(s).map(|k| spriteNode(s.sheet, k)))
-struct WorldGame(Game(engine), demo: Demo) =
+struct Demo(state: State) =
+  fun update(self, io: Io, dt: Float) -> Demo =
+    Demo(state: step(self.state))
-  override fun update(self, dt: Float) =
+  fun draw(self, io: Io) =
-    step(self.demo)
-  override fun draw(self) =
-    self.canvas.clear(Color.rgb(0.05, 0.06, 0.1))
+    io.clear(Color.rgb(0.05, 0.06, 0.1))
-    self.demo.stage.draw(self.canvas)
+    view(self.state).draw(io)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Demo =
-  e := Engine.create(io)
-  WorldGame(engine: e, demo: build(e.assets.texture("sprites.png")))
+  Demo(state: newState(Texture.load(io, "sprites.png")))
 # --- tests ---
 test "about 2000 of the 20000 sprites are in view, sorted by y"
-  g := build(Texture(id: -1))
+  s := step(newState(Texture(id: -1)))
-  step(g)
-  assert g.layer.children.length() == 20000
+  assert s.sprites.length() == 20000
+  all := s.sprites.toSlice()
   for i := range 19999
-    assert g.layer.children.at(i).y <= g.layer.children.at(i + 1).y
+    assert all.at(i).y <= all.at(i + 1).y
-  shown := flatten(g.stage.root).length() - 1
+  shown := visible(s).length()
   assert shown > 1500 && shown < 2600
-test "without a culling area every sprite is listed"
-  g := build(Texture(id: -1))
-  assert flatten(g.stage.root).length() == 20002

compiler/game/web-test/fixtures/text_sizes.plum CHANGED Viewed

@@ -10,26 +10,26 @@ import std/game/Color
 import std/game/Game
 import std/Io
-struct Sizes(Game(engine), mut t: Int) =
+struct Sizes(t: Int) =
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Sizes =
-    self.t = self.t + 1
+    Sizes(t: self.t + 1)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    drawSizes(self.canvas, self.t)
+    drawSizes(io, self.t)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Sizes =
-  Sizes(engine: Engine.create(io), t: 0)
+  Sizes(t: 0)
-fun drawSizes(canvas: Canvas, t: Int) =
+fun drawSizes(io: Io, t: Int) =
-  canvas.clear(Color.rgb(0.08, 0.09, 0.14))
+  io.clear(Color.rgb(0.08, 0.09, 0.14))
-  canvas.drawText("Size 8: The quick brown fox jumps over the lazy dog 0123456789", 10.0, 6.0, 8.0, Color.White)
+  io.drawText("Size 8: The quick brown fox jumps over the lazy dog 0123456789", 10.0, 6.0, 8.0, Color.White)
-  canvas.drawText("Size 16: The quick brown fox jumps over the lazy dog", 10.0, 24.0, 16.0, Color.White)
+  io.drawText("Size 16: The quick brown fox jumps over the lazy dog", 10.0, 24.0, 16.0, Color.White)
-  canvas.drawText("Size 48: Quick brown fox", 10.0, 52.0, 48.0, Color.Yellow)
+  io.drawText("Size 48: Quick brown fox", 10.0, 52.0, 48.0, Color.Yellow)
-  canvas.drawText("Size 128 Wg", 10.0, 112.0, 128.0, Color.rgb(0.5, 0.9, 1.0))
+  io.drawText("Size 128 Wg", 10.0, 112.0, 128.0, Color.rgb(0.5, 0.9, 1.0))
-  canvas.drawText("Latin-1: café naïve über ½ ©", 10.0, 250.0, 24.0, Color.White)
+  io.drawText("Latin-1: café naïve über ½ ©", 10.0, 250.0, 24.0, Color.White)
-  canvas.drawText("frame {t}", 700.0, 8.0, 16.0, Color.Green)
+  io.drawText("frame {t}", 700.0, 8.0, 16.0, Color.Green)
-  canvas.drawRect(Float(t % 400), 300.0, 60.0, 4.0, Color.Red)
+  io.drawRect(Float(t % 400), 300.0, 60.0, 4.0, Color.Red)
-  canvas.setCamera(0.0, 0.0, 3.0)
+  io.setCamera(0.0, 0.0, 3.0)
-  canvas.drawText("Zoomed x3: size 16", 10.0, 112.0, 16.0, Color.White)
+  io.drawText("Zoomed x3: size 16", 10.0, 112.0, 16.0, Color.White)
-  canvas.drawText("Zoomed x3: size 8", 10.0, 134.0, 8.0, Color.White)
+  io.drawText("Zoomed x3: size 8", 10.0, 134.0, 8.0, Color.White)
-  canvas.resetCamera()
+  io.resetCamera()

compiler/game/web-test/tests/web_check.rs CHANGED Viewed

@@ -2,17 +2,12 @@ use plum_web_test::{chromium_installed, repo_root, run, webkit_installed, Browse
 #[test]
 fn orb_run_renders_and_animates() {
-    orb_run("examples/games/imperative/game.plum");
+    orb_run("examples/games/orb_run.plum");
 }
 #[test]
-fn orb_run_scene_renders_and_animates() {
+fn balloon_pop_renders_and_animates() {
-    orb_run("examples/games/imperative/game_scene.plum");
-}
-#[test]
-fn pure_scene_renders_and_animates() {
-    orb_run("examples/games/pure/game_pure_scene.plum");
+    orb_run("examples/games/kids/balloon_pop.plum");
 }
 #[test]
@@ -20,11 +15,6 @@ fn state_view_renders_and_animates() {
     orb_run("compiler/game/web-test/fixtures/stress_state_view.plum");
 }
-#[test]
-fn scene_run_renders_and_animates() {
-    orb_run("examples/games/imperative/scene.plum");
-}
 #[test]
 fn stats_json_is_one_object() {
     use plum_web_test::{stats_json, FrameStats, Options};
@@ -55,7 +45,7 @@ fn chromium_runs_without_module_introspection() {
     }
     let opts = Options { no_module_introspection: true, ..Options::default() };
     let rt = tokio::runtime::Runtime::new().unwrap();
-    let report = rt.block_on(run(&repo_root().join("examples/games/imperative/game.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
+    let report = rt.block_on(run(&repo_root().join("examples/games/orb_run.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
     println!("{report}");
 }
@@ -67,7 +57,7 @@ fn webkit_runs_without_module_introspection() {
     }
     let opts = Options { browser: Browser::Webkit, no_module_introspection: true, ..Options::default() };
     let rt = tokio::runtime::Runtime::new().unwrap();
-    let report = rt.block_on(run(&repo_root().join("examples/games/imperative/game.plum"), &opts)).unwrap_or_else(|e| {
+    let report = rt.block_on(run(&repo_root().join("examples/games/orb_run.plum"), &opts)).unwrap_or_else(|e| {
         assert!(!e.contains("unable to produce import descriptors"), "{e}");
         panic!("{e}")
     });
@@ -82,7 +72,7 @@ fn webkit_without_webgpu_loads_the_wasm_and_says_so() {
     }
     let opts = Options { browser: Browser::Webkit, expect_unsupported_webgpu: true, no_module_introspection: true, ..Options::default() };
     let rt = tokio::runtime::Runtime::new().unwrap();
-    let report = rt.block_on(run(&repo_root().join("examples/games/imperative/game.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
+    let report = rt.block_on(run(&repo_root().join("examples/games/orb_run.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
     assert!(report.contains("plum.wasm load probe: ok"), "{report}");
 }

compiler/game/web/plum_bridge.js CHANGED Viewed

@@ -1216,8 +1216,8 @@ fn shade(i: VOut) -> vec4f {
     const instance = await instantiatePlum(host);
     ctx.plum = instance.exports;
     const ex = ctx.plum;
-    // A game's entry is `main`, which returns the game.
+    // A game's entry is `main`, which returns the game; `update` returns the next state.
-    const state = ex.main();
+    let state = ex.main();
     let last = performance.now();
     function frame(now) {
@@ -1229,7 +1229,7 @@ fn shade(i: VOut) -> vec4f {
         b.beginFrame(view.w, view.h, view.dpr);
         const m = globalThis.__plumMeasure; // set by plum-web-test --measure; null otherwise
         const t0 = m ? performance.now() : 0;
-        ex.update(state, dt);
+        state = ex.update(state, dt);
         const t1 = m ? performance.now() : 0;
         ex.draw(state);
         const t2 = m ? performance.now() : 0;

compiler/lsp/src/main.rs CHANGED Viewed

@@ -835,7 +835,7 @@ mod tests {
             "sequences.plum",
             "match.plum",
             "unions.plum",
-            "games/imperative/game_loop.plum",
+            "games/game_loop.plum",
         ] {
             let path = repoRoot().join("examples").join(f);
             let text = std::fs::read_to_string(&path).unwrap();
@@ -974,7 +974,7 @@ mod tests {
             ("Testing", "std/Testing"),
             ("Http", "std/Http"),
             ("Int", "std/Int"),
-            ("Stage", "std/game/imperative/Scene"),
+            ("SceneNode", "std/game/Scene"),
             ("Io", "std/Io"),
             ("Key", "std/game/Game"),
             ("Vec2", "std/game/Vec2"),

compiler/wasm-codegen/src/lib.rs CHANGED Viewed

@@ -76,30 +76,15 @@ pub struct Output {
     pub fn_keys: Vec<String>,
     /// With `opts.tests`: each test's display name, in the order of its `"test#<name>"` export.
     pub test_names: Vec<String>,
-    /// `main` returns `Game` or a struct embedding it first: the module exports
+    /// `main` returns a type with `update(self, io, dt) -> T` and `draw(self, io)`: the module
-    /// `update(state, dt)` and `draw(state)` for the host, and `main` builds the state.
+    /// exports `update(state, dt) -> state` and `draw(state)` for the host, and `main` builds the state.
     pub isGame: bool,
 }
-/// Is `main` declared `-> T` with `T` the std/game `Game` struct or a subtype of it?
-pub fn isGame(source: &ast::Source) -> bool {
-    // A user's own struct named `Game` is not std/game's: its frame entry points are missing.
-    let hasEntryPoints = GAME_EXPORTS.iter().all(|(inner, _)| {
-        source.items.iter().any(|i| matches!(i, ast::Item::Fn(f) if f.name == *inner && f.type_param.is_none()))
-    });
-    hasEntryPoints && source.items.iter().any(|i| match i {
-        ast::Item::Fn(f) if f.name == "main" && f.type_param.is_none() => f
-            .returns
-            .as_ref()
-            .is_some_and(|t| plum_core::subtyping::isSubtype(source, &t.name, "Game")),
-        _ => false,
-    })
-}
-const GAME_EXPORTS: [(&str, &str); 2] = [("gameUpdate", "update"), ("gameDraw", "draw")];
+const GAME_EXPORTS: [(&str, &str); 2] = [(plum_core::game_entry::GAME_UPDATE, "update"), (plum_core::game_entry::GAME_DRAW, "draw")];
-fn gameExports(source: &ast::Source) -> Vec<(String, String)> {
+fn gameExports(game: bool) -> Vec<(String, String)> {
-    if !isGame(source) {
+    if !game {
         return Vec::new();
     }
     GAME_EXPORTS.iter().map(|(i, e)| (i.to_string(), e.to_string())).collect()
@@ -107,8 +92,11 @@ fn gameExports(source: &ast::Source) -> Vec<(String, String)> {
 /// The one compile entry: type-checks `source` (passes per `opts.passes`) and compiles it.
 /// With `opts.tests`, `test` blocks are first lowered to ordinary fns (see
-/// `plum_core::tests_lower`) and exported.
+/// `plum_core::tests_lower`) and exported. A game's frame entry points are added first.
 pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, Vec<Diagnostic>> {
+    let mut gameSource = source.clone();
+    let game = plum_core::game_entry::lowerGame(&mut gameSource).map_err(|d| vec![d])?;
+    let source = &gameSource;
     if opts.passes.explain {
         for line in explainLayouts(source) {
             eprintln!("{line}");
@@ -118,13 +106,13 @@ pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, Ve
         let prog = plum_core::tests_lower::lowerTests(source);
         let typed = plum_driver::check(&prog.source, &opts.passes)?;
         let mut extra = prog.extraExports.clone();
-        extra.extend(gameExports(&prog.source));
+        extra.extend(gameExports(game));
         let (wasm, fn_keys) = compileSourceInner(&prog.source, &extra, typed).map_err(codegenDiag)?;
-        Ok(Output { wasm, fn_keys, test_names: prog.names, isGame: isGame(&prog.source) })
+        Ok(Output { wasm, fn_keys, test_names: prog.names, isGame: game })
     } else {
         let typed = plum_driver::check(source, &opts.passes)?;
-        let (wasm, fn_keys) = compileSourceInner(source, &gameExports(source), typed).map_err(codegenDiag)?;
+        let (wasm, fn_keys) = compileSourceInner(source, &gameExports(game), typed).map_err(codegenDiag)?;
-        Ok(Output { wasm, fn_keys, test_names: Vec::new(), isGame: isGame(source) })
+        Ok(Output { wasm, fn_keys, test_names: Vec::new(), isGame: game })
     }
 }

compiler/wasm-codegen/tests/wasm_codegen/fusion_alloc_test.rs CHANGED Viewed

@@ -215,7 +215,7 @@ fn list_pipeline_loop_has_no_cons_alloc() {
 /// `List.map(|o| o.render(..))` children (each `render` resolved by its receiver type).
 #[test]
 fn state_view_draw_has_no_scenenode_alloc() {
-    let g = loadFile(&repoRoot().join("examples/games/functional/game_state_view.plum"));
+    let g = loadFile(&repoRoot().join("examples/games/orb_run.plum"));
     let ns = notes(&g);
     say(format!("state_view: fusion notes {ns:?}"));
     let w = compile(&g, true);

docs/plans/2026-11-06-simpler-language.benchmark.md CHANGED Viewed

@@ -108,3 +108,7 @@ Five probes: `for` with a `total =` accumulator, `while`, a tail-recursive `fold
 - Under the default build, `find` reads 0 ms because fusion moves the pure `findFirst` call past the timer, to where its answer is printed. The answer is printed in the fixed file, and with `--no-fusion` the call runs at the right place and takes 14 ms, the same as the others. Use the `--no-fusion` figure for `find`.
 - All five forms take 13 to 15 ms for 50 million iterations (about 0.28 ns each), so the compiler flattens `for`, `while`, the closure fold and the struct state loop to the same code on this machine. Timer resolution is 1 ms. The earlier "loops +75%" figure does not show up in these probes.
 - Spread is 1 to 2 ms, which is about 10%; the forms cannot be told apart.
+## Branch fixtures after T2 (plain games, one scene)
+On `simpler-language` the fixtures under `compiler/game/web-test/fixtures` are all plain games (`main` returns a type with `update(self, io, dt) -> Self` and `draw(self, io)`). `stress_scene` and `stress_pure_scene` are deleted (the baseline keeps the originals); `stress_state_view` is the functional twin of both, drawing the same 5000/500/200/50 scene. `stress_world` is ported to state and view with the same 20000 sprites, 500 walkers, camera drift, per-frame y-sort of the whole list and a 1280x720 cull. One difference: the old version walked `children.at(i * 37 % 20000)` after each re-sort, so which sprites walked changed every frame; the port gives walker `w` the fixed sprite `37 * w`. The view builds scene nodes only for the visible sprites. Nothing is tuned for speed; T14 measures.

examples/games/{imperative/game_loop.plum → game_loop.plum} RENAMED Viewed

File without changes

examples/games/imperative/game.plum DELETED Viewed

@@ -1,435 +0,0 @@
-# Orb Run: a small arcade game for the game host (`plum run examples/games/imperative/game.plum`).
-# Steer the ship with the arrow keys or WASD, collect the drifting orbs and avoid
-# the mines. Three lives; Enter or R restarts after the game is over. The music
-# loops from `main`; orbs, mines and the end of a run each play a sound.
-#
-# All rules are methods of `World` (plus a few free helpers) that never call the host, so
-# the `test` blocks below run under `plum test`; only `OrbRun`, the `Game` struct over a
-# `World`, and `main` talk to the host.
-module game
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Math
-import std/Random
-import std/game/Vec2
-import std/game/Color
-import std/game/Game
-import std/game/Input
-import std/Io
-primitive Rules =
-  ArenaW = 800.0
-  ArenaH = 600.0
-  ShipRadius = 10.0
-  OrbRadius = 10.0
-  MineRadius = 11.0
-  Thrust = 900.0
-  Drag = 2.2
-  OrbCount = 3
-  StartLives = 3
-  HurtTime = 1.5
-  OrbPoints = 10
-  Cell = 16.0
-  Zoom = 3.0
-# A moving circle. `angle` is the ship's heading or a mine's spin, in radians clockwise.
-struct Body(mut x: Float, mut y: Float, mut vx: Float, mut vy: Float, mut angle: Float)
-struct World(
-  ship: Body,
-  orbs: Slice[Body],
-  mines: Slice[Body],
-  mut rng: Random,
-  mut score: Int,
-  mut best: Int,
-  mut lives: Int,
-  mut hurt: Float,
-  mut clock: Float,
-  mut over: Bool) =
-  fun create(seed: Int) -> World =
-    ship := Body(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, angle: 0.0)
-    w := World(
-      ship: ship, orbs: Slice[Body](), mines: Slice[Body](), rng: Random.seeded(seed), score: 0, best: 0,
-      lives: Rules.StartLives, hurt: 0.0, clock: 0.0, over: false)
-    for i := range Rules.OrbCount
-      sp := spawn(w.rng, ship, 120.0, 40.0)
-      w.rng = sp.rng
-      w.orbs.push(sp.at)
-    for i := range mineCount(0)
-      sp := spawn(w.rng, ship, 220.0, 90.0)
-      w.rng = sp.rng
-      w.mines.push(sp.at)
-    w
-  # A world with the orbs and mines moved out of the way.
-  fun empty() -> World =
-    w := World.create(7)
-    for i := range w.orbs.length()
-      w.orbs.at(i).x = 5000.0
-      w.orbs.at(i).vx = 0.0
-      w.orbs.at(i).vy = 0.0
-    for i := range w.mines.length()
-      w.mines.at(i).x = 5000.0
-      w.mines.at(i).vx = 0.0
-      w.mines.at(i).vy = 0.0
-    w
-  # Starts a fresh game, keeping the best score and the random stream.
-  fun restart(self) =
-    self.best = self.best.max(self.score)
-    self.score = 0
-    self.lives = Rules.StartLives
-    self.hurt = 0.0
-    self.over = false
-    self.ship.x = Rules.ArenaW / 2.0
-    self.ship.y = Rules.ArenaH / 2.0
-    self.ship.vx = 0.0
-    self.ship.vy = 0.0
-    for i := range self.orbs.length()
-      sp := spawn(self.rng, self.ship, 120.0, 40.0)
-      self.rng = sp.rng
-      moved := sp.at
-      self.orbs.at(i).x = moved.x
-      self.orbs.at(i).y = moved.y
-      self.orbs.at(i).vx = moved.vx
-      self.orbs.at(i).vy = moved.vy
-    while self.mines.length() > mineCount(0)
-      _ := self.mines.pop()!
-    for i := range self.mines.length()
-      sp := spawn(self.rng, self.ship, 220.0, 90.0)
-      self.rng = sp.rng
-      moved := sp.at
-      self.mines.at(i).x = moved.x
-      self.mines.at(i).y = moved.y
-      self.mines.at(i).vx = moved.vx
-      self.mines.at(i).vy = moved.vy
-  # One simulation step. Does nothing once the game is over.
-  fun step(self, ax: Float, ay: Float, dt: Float) =
-    self.clock = self.clock + dt
-    if self.over
-      return
-    self.hurt = {self.hurt - dt}.max(0.0)
-    steer(self.ship, ax, ay, dt)
-    for i := range self.orbs.length()
-      orb := self.orbs.at(i)
-      drift(orb, Rules.OrbRadius, dt)
-      if overlaps(self.ship, Rules.ShipRadius, orb, Rules.OrbRadius)
-        self.score = self.score + Rules.OrbPoints
-        sp := spawn(self.rng, self.ship, 120.0, 40.0)
-        self.rng = sp.rng
-        moved := sp.at
-        orb.x = moved.x
-        orb.y = moved.y
-        orb.vx = moved.vx
-        orb.vy = moved.vy
-    while self.mines.length() < mineCount(self.score)
-      sp := spawn(self.rng, self.ship, 220.0, 90.0)
-      self.rng = sp.rng
-      self.mines.push(sp.at)
-    for i := range self.mines.length()
-      mine := self.mines.at(i)
-      drift(mine, Rules.MineRadius, dt)
-      mine.angle = mine.angle + 2.0 * dt
-      if self.hurt <= 0.0 && overlaps(self.ship, Rules.ShipRadius, mine, Rules.MineRadius)
-        self.lives = self.lives - 1
-        self.hurt = Rules.HurtTime
-        if self.lives <= 0
-          self.over = true
-          self.best = self.best.max(self.score)
-# The game: a `World` and the host parts it plays and draws with.
-struct OrbRun(Game(engine), world: World, sheet: Texture, pickupSound: Sound, hitSound: Sound, overSound: Sound, musicSound: Sound) =
-  # Restarts the music loop from the top.
-  fun startMusic(self) =
-    self.audio.stop(self.musicSound)
-    self.audio.loop(self.musicSound, musicVolume())
-  # Draws frame `frame` of sheet row `row`, centred on (x, y), at `Rules.Zoom` times its size.
-  fun sprite(self, row: Int, frame: Int, x: Float, y: Float, angle: Float, tint: Color) =
-    size := Rules.Cell * Rules.Zoom
-    self.canvas.drawTextureEx(
-      self.sheet, Float(frame) * Rules.Cell, Float(row) * Rules.Cell, Rules.Cell, Rules.Cell,
-      x - size / 2.0, y - size / 2.0, size, size, angle, false, tint)
-  fun drawStars(self) =
-    for i := range 40
-      sx := Float({i * 7919} % 800)
-      sy := Float({i * 104729} % 600)
-      twinkle := 0.25 + 0.2 * Math.sin(self.world.clock * 2.0 + Float(i))
-      self.canvas.drawCircle(sx, sy, 1.0 + Float(i % 3) * 0.5, Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
-  # Enter or R restarts a finished game, the held keys steer.
-  override fun update(self, dt: Float) =
-    w := self.world
-    inputs := self.input.events()
-    for i := range inputs.length()
-      match inputs.at(i)
-        KeyDown(k) =>
-          if w.over && {k == Key.Enter || k == Key.KeyR}
-            w.restart()
-            self.startMusic()
-        _ => 0
-    left := self.input.isKeyDown(Key.Left) || self.input.isKeyDown(Key.KeyA)
-    right := self.input.isKeyDown(Key.Right) || self.input.isKeyDown(Key.KeyD)
-    up := self.input.isKeyDown(Key.Up) || self.input.isKeyDown(Key.KeyW)
-    down := self.input.isKeyDown(Key.Down) || self.input.isKeyDown(Key.KeyS)
-    score := w.score
-    lives := w.lives
-    w.step(axis(left, right), axis(up, down), dt)
-    if w.score > score
-      self.audio.play(self.pickupSound, 0.8)
-    if w.lives < lives
-      if w.over
-        self.audio.stop(self.musicSound)
-        self.audio.play(self.overSound, 1.0)
-      else
-        self.audio.play(self.hitSound, 1.0)
-  override fun draw(self) =
-    w := self.world
-    canvas := self.canvas
-    sw := canvas.width()
-    sh := canvas.height()
-    zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
-    canvas.clear(Color.rgb(0.04, 0.05, 0.1))
-    canvas.setCamera(0.0 - {sw / zoom - Rules.ArenaW} / 2.0, 0.0 - {sh / zoom - Rules.ArenaH} / 2.0, zoom)
-    canvas.drawRect(0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16))
-    self.drawStars()
-    for i := range w.orbs.length()
-      orb := w.orbs.at(i)
-      canvas.blendMode(Blend.Add)
-      canvas.drawCircle(orb.x, orb.y, 26.0, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5))
-      canvas.drawCircle(orb.x, orb.y, 17.0, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
-      canvas.blendMode(Blend.Normal)
-      self.sprite(1, frameOf(w.clock + Float(i) * 0.1, 4, 8.0), orb.x, orb.y, 0.0, Color.White)
-    for i := range w.mines.length()
-      mine := w.mines.at(i)
-      self.sprite(2, frameOf(w.clock, 4, 4.0), mine.x, mine.y, mine.angle, Color.White)
-    blink := w.hurt > 0.0 && frameOf(w.clock, 2, 10.0) == 0
-    if !w.over && !blink
-      flame := frameOf(w.clock, 4, 14.0)
-      canvas.drawCircle(w.ship.x, w.ship.y, 17.0, Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12))
-      self.sprite(0, flame, w.ship.x, w.ship.y, w.ship.angle, Color.White)
-    canvas.drawText("Score {w.score}", 16.0, 12.0, 28.0, Color.White)
-    canvas.drawText("Best {w.best.max(w.score)}", 16.0, 44.0, 20.0, Color.Yellow)
-    for i := range w.lives
-      canvas.drawTextureEx(
-        self.sheet, 0.0, 0.0, Rules.Cell, Rules.Cell,
-        Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0, 0.0, false, Color.White)
-    if w.over
-      canvas.drawRect(0.0, 240.0, Rules.ArenaW, 120.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6))
-      canvas.drawText("Game over", 300.0, 258.0, 48.0, Color.Red)
-      canvas.drawText("Press Enter to play again", 270.0, 316.0, 24.0, Color.White)
-    canvas.resetCamera()
-fun distance(a: Body, b: Body) -> Float =
-  Math.hypot(a.x - b.x, a.y - b.y)
-fun overlaps(a: Body, ra: Float, b: Body, rb: Float) -> Bool =
-  distance(a, b) < ra + rb
-# Which of `count` animation frames is showing after `clock` seconds at `fps` frames per second.
-fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
-  Int(clock * fps) % count
-# A body at a random spot at least `gap` away from `avoid`, drifting at up to `speed`.
-# A Body and the generator to continue from.
-struct Spawned(at: Body, rng: Random)
-fun spawn(rng: Random, avoid: Body, gap: Float, speed: Float) -> Spawned =
-  margin := 30.0
-  b := Body(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0, angle: 0.0)
-  r := rng
-  tries := 0
-  while tries < 20
-    dx := r.nextFloat()
-    dy := dx.rng.nextFloat()
-    r = dy.rng
-    b.x = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    b.y = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
-    if distance(b, avoid) >= gap
-      break
-    tries = tries + 1
-  dh := r.nextFloat()
-  dp := dh.rng.nextFloat()
-  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * dp.value}
-  b.vx = Math.cos(heading) * pace
-  b.vy = Math.sin(heading) * pace
-  Spawned(at: b, rng: dp.rng)
-# How many mines are out: more as the score grows.
-fun mineCount(score: Int) -> Int =
-  {3 + score / 50}.min(8)
-# Accelerates the ship by input axes (-1..1), applies drag and keeps it in the arena.
-fun steer(ship: Body, ax: Float, ay: Float, dt: Float) =
-  ship.vx = ship.vx + ax * Rules.Thrust * dt
-  ship.vy = ship.vy + ay * Rules.Thrust * dt
-  keep := {1.0 - Rules.Drag * dt}.max(0.0)
-  ship.vx = ship.vx * keep
-  ship.vy = ship.vy * keep
-  ship.x = ship.x + ship.vx * dt
-  ship.y = ship.y + ship.vy * dt
-  r := Rules.ShipRadius
-  if ship.x < r
-    ship.x = r
-    ship.vx = 0.0
-  if ship.x > Rules.ArenaW - r
-    ship.x = Rules.ArenaW - r
-    ship.vx = 0.0
-  if ship.y < r
-    ship.y = r
-    ship.vy = 0.0
-  if ship.y > Rules.ArenaH - r
-    ship.y = Rules.ArenaH - r
-    ship.vy = 0.0
-  if ship.vx * ship.vx + ship.vy * ship.vy > 400.0
-    ship.angle = Math.atan2(ship.vx, 0.0 - ship.vy)
-# Moves a drifter and bounces it off the arena walls.
-fun drift(b: Body, r: Float, dt: Float) =
-  b.x = b.x + b.vx * dt
-  b.y = b.y + b.vy * dt
-  if b.x < r || b.x > Rules.ArenaW - r
-    b.vx = 0.0 - b.vx
-    b.x = b.x.max(r).min(Rules.ArenaW - r)
-  if b.y < r || b.y > Rules.ArenaH - r
-    b.vy = 0.0 - b.vy
-    b.y = b.y.max(r).min(Rules.ArenaH - r)
-# --- host glue: input, drawing ---
-fun musicVolume() -> Float =
-  0.3
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  game := OrbRun(
-    engine: e, world: World.create(io.randomSeed()), sheet: e.assets.texture("sprites.png"),
-    pickupSound: e.assets.sound("pickup.wav"), hitSound: e.assets.sound("hit.wav"),
-    overSound: e.assets.sound("gameover.wav"), musicSound: e.assets.sound("music.wav"))
-  game.startMusic()
-  game
-fun axis(negative: Bool, positive: Bool) -> Float =
-  if negative && !positive
-    -1.0
-  else if positive && !negative
-    1.0
-  else
-    0.0
-# --- tests ---
-fun still(x: Float, y: Float) -> Body =
-  Body(x: x, y: y, vx: 0.0, vy: 0.0, angle: 0.0)
-test "steering accelerates and drag slows the ship"
-  ship := still(400.0, 300.0)
-  steer(ship, 1.0, 0.0, 0.1)
-  assert ship.vx > 0.0
-  assert ship.x > 400.0
-  fast := ship.vx
-  for i := range 30
-    steer(ship, 0.0, 0.0, 0.1)
-  assert ship.vx < fast / 4.0
-test "the ship stops at the arena walls"
-  ship := still(20.0, 20.0)
-  for i := range 20
-    steer(ship, -1.0, -1.0, 0.1)
-  assert ship.x == Rules.ShipRadius
-  assert ship.y == Rules.ShipRadius
-  assert ship.vx == 0.0
-test "drifters bounce off the walls"
-  b := Body(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0, angle: 0.0)
-  drift(b, 10.0, 0.1)
-  assert b.vx == -100.0
-  assert b.x == Rules.ArenaW - 10.0
-test "collecting an orb scores and respawns it elsewhere"
-  w := World.empty()
-  orb := w.orbs.at(0)
-  orb.x = w.ship.x
-  orb.y = w.ship.y
-  w.step(0.0, 0.0, 0.016)
-  assert w.score == Rules.OrbPoints
-  assert distance(orb, w.ship) >= 120.0
-  assert orb.x < 5000.0
-test "a mine costs one life, then the ship is briefly safe"
-  w := World.empty()
-  mine := w.mines.at(0)
-  mine.x = w.ship.x
-  mine.y = w.ship.y
-  w.step(0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-  assert w.hurt > 0.0
-  w.step(0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-  mine.x = 5000.0
-  for i := range 100
-    w.step(0.0, 0.0, 0.016)
-  assert w.hurt == 0.0
-test "the game ends at zero lives and then ignores steps"
-  w := World.empty()
-  w.lives = 1
-  w.score = 40
-  mine := w.mines.at(0)
-  mine.x = w.ship.x
-  mine.y = w.ship.y
-  w.step(0.0, 0.0, 0.016)
-  assert w.over
-  assert w.lives == 0
-  assert w.best == 40
-  x := w.ship.x
-  w.step(1.0, 0.0, 0.5)
-  assert w.ship.x == x
-test "restart resets the run and keeps the best score"
-  w := World.empty()
-  w.score = 90
-  w.lives = 0
-  w.over = true
-  w.restart()
-  assert !w.over
-  assert w.score == 0
-  assert w.best == 90
-  assert w.lives == Rules.StartLives
-  assert w.ship.x == Rules.ArenaW / 2.0
-  assert w.mines.length() == mineCount(0)
-test "more mines appear as the score grows"
-  assert mineCount(0) == 3
-  assert mineCount(100) == 5
-  assert mineCount(10000) == 8
-  w := World.empty()
-  w.score = 100
-  w.step(0.0, 0.0, 0.016)
-  assert w.mines.length() == 5
-test "the same seed plays out the same way"
-  a := World.create(11)
-  b := World.create(11)
-  for i := range 120
-    a.step(1.0, -1.0, 0.016)
-    b.step(1.0, -1.0, 0.016)
-  assert a.ship.x == b.ship.x
-  assert a.score == b.score
-  assert a.mines.at(0).x == b.mines.at(0).x
-  assert World.create(12).orbs.at(0).x != a.orbs.at(0).x
-test "animation frames cycle"
-  assert frameOf(0.0, 4, 8.0) == 0
-  assert frameOf(0.13, 4, 8.0) == 1
-  assert frameOf(0.5, 4, 8.0) == 0
-  assert axis(true, false) == -1.0
-  assert axis(true, true) == 0.0

examples/games/imperative/game_scene.plum DELETED Viewed

@@ -1,663 +0,0 @@
-# Orb Run on the scene graph (`plum run examples/games/imperative/game_scene.plum`): the same game as
-# game.plum (same arena, rules, sprites, sounds, keys and scoring), rebuilt in retained
-# mode on std/game/imperative/Scene. Steer the ship with the arrow keys or WASD, collect the
-# drifting orbs and avoid the mines. Three lives; Enter or R restarts after the game
-# is over.
-#
-# What differs from game.plum. There, one `World` record holds plain `Body` values,
-# `step` is the only place that moves anything and `draw` issues every call by hand.
-# Here each kind is a struct embedding the scene's `Actor` base struct (`Ship`, `Orb`,
-# `Mine`, `Star`) with its own `act` (motion, spin, blink, twinkle) and `draw`
-# (its sprite frames), and the world is a tree: layer Groups under `world.root`
-# (backdrop, stars, mines, orbs, ship, HUD), so `world.act(dt)` and `world.draw()` do
-# the per-kind work and z-order is the order of the layers. Collisions, scoring,
-# spawning, lives and restart are methods of `World`.
-#
-# Prefer game.plum's immediate mode for a flat arcade game with a handful of kinds
-# where one state record and one pure `update` are easiest to test. Prefer this
-# retained mode when the game has layers, parent-relative transforms, hit-testing
-# or many things that each behave and draw differently.
-#
-# The rules never call the host, so the `test` blocks below run under `plum test`;
-# only `init`, `update` and `draw` talk to the host.
-module game_scene
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Option
-import std/Math
-import std/Random
-import std/game/Vec2
-import std/game/Color
-import std/game/Game
-import std/game/imperative/Scene
-import std/game/Input
-import std/Io
-primitive Rules =
-  ArenaW = 800.0
-  ArenaH = 600.0
-  ShipRadius = 10.0
-  OrbRadius = 10.0
-  MineRadius = 11.0
-  Thrust = 900.0
-  Drag = 2.2
-  OrbCount = 3
-  StartLives = 3
-  HurtTime = 1.5
-  OrbPoints = 10
-  Cell = 16.0
-  Zoom = 3.0
-# A position and velocity: what a spawn returns and what drifters are bounced with.
-struct Motion(mut x: Float, mut y: Float, mut vx: Float, mut vy: Float)
-# Which of `count` animation frames is showing after `clock` seconds at `fps` frames per second.
-fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
-  Int(clock * fps) % count
-# A random spot at least `gap` away from (ax, ay), drifting at up to `speed`.
-# A Motion and the generator to continue from.
-struct Spawned(at: Motion, rng: Random)
-fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawned =
-  margin := 30.0
-  b := Motion(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0)
-  r := rng
-  tries := 0
-  while tries < 20
-    dx := r.nextFloat()
-    dy := dx.rng.nextFloat()
-    r = dy.rng
-    b.x = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    b.y = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
-    if Math.hypot(b.x - ax, b.y - ay) >= gap
-      break
-    tries = tries + 1
-  dh := r.nextFloat()
-  dp := dh.rng.nextFloat()
-  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * dp.value}
-  b.vx = Math.cos(heading) * pace
-  b.vy = Math.sin(heading) * pace
-  Spawned(at: b, rng: dp.rng)
-# Moves a drifter and bounces it off the arena walls.
-fun drift(b: Motion, r: Float, dt: Float) =
-  b.x = b.x + b.vx * dt
-  b.y = b.y + b.vy * dt
-  if b.x < r || b.x > Rules.ArenaW - r
-    b.vx = 0.0 - b.vx
-    b.x = b.x.max(r).min(Rules.ArenaW - r)
-  if b.y < r || b.y > Rules.ArenaH - r
-    b.vy = 0.0 - b.vy
-    b.y = b.y.max(r).min(Rules.ArenaH - r)
-# How many mines are out: more as the score grows.
-fun mineCount(score: Int) -> Int =
-  {3 + score / 50}.min(8)
-# Actor kinds of this game. Each is a sprite-sized actor centred on its position (x, y)
-# (origin at the middle of the box, so `rotation` turns it about its centre).
-# The player. `ax` and `ay` are the input axes (-1..1) for the next `act`.
-struct Ship(Actor(x, y), tex: Texture, mut vx: Float, mut vy: Float, mut ax: Float, mut ay: Float, mut hurt: Float, mut clock: Float, mut live: Bool) =
-  fun init(self) =
-    self.width = Rules.Cell * Rules.Zoom
-    self.height = self.width
-    self.originX = self.width / 2.0
-    self.originY = self.height / 2.0
-  # Accelerates by the input axes, applies drag, keeps the ship in the arena and
-  # blinks it while it is hurt (the blink is just `visible`).
-  override fun act(self, dt: Float) =
-    self.clock = self.clock + dt
-    if !self.live
-      return
-    self.hurt = {self.hurt - dt}.max(0.0)
-    self.vx = self.vx + self.ax * Rules.Thrust * dt
-    self.vy = self.vy + self.ay * Rules.Thrust * dt
-    keep := {1.0 - Rules.Drag * dt}.max(0.0)
-    self.vx = self.vx * keep
-    self.vy = self.vy * keep
-    self.x = self.x + self.vx * dt
-    self.y = self.y + self.vy * dt
-    r := Rules.ShipRadius
-    if self.x < r
-      self.x = r
-      self.vx = 0.0
-    if self.x > Rules.ArenaW - r
-      self.x = Rules.ArenaW - r
-      self.vx = 0.0
-    if self.y < r
-      self.y = r
-      self.vy = 0.0
-    if self.y > Rules.ArenaH - r
-      self.y = Rules.ArenaH - r
-      self.vy = 0.0
-    if self.vx * self.vx + self.vy * self.vy > 400.0
-      self.rotation = Math.atan2(self.vx, 0.0 - self.vy)
-    self.visible = !{self.hurt > 0.0 && frameOf(self.clock, 2, 10.0) == 0}
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
-    canvas.drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * alpha))
-    frame := Float(frameOf(self.clock, 4, 14.0))
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
-# A glowing orb drifting about. `phase` offsets its animation from the other orbs.
-struct Orb(Actor(x, y), mut vx: Float, mut vy: Float, phase: Float, tex: Texture, mut clock: Float, mut live: Bool) =
-  fun init(self) =
-    self.width = Rules.Cell * Rules.Zoom
-    self.height = self.width
-    self.originX = self.width / 2.0
-    self.originY = self.height / 2.0
-  fun create(sheet: Texture, phase: Float, at: Motion) -> Orb =
-    Orb(x: at.x, y: at.y, vx: at.vx, vy: at.vy, phase: phase, tex: sheet, clock: 0.0, live: true)
-  fun motion(self) -> Motion =
-    Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
-  fun place(self, m: Motion) =
-    self.x = m.x
-    self.y = m.y
-    self.vx = m.vx
-    self.vy = m.vy
-  override fun act(self, dt: Float) =
-    self.clock = self.clock + dt
-    if !self.live
-      return
-    m := self.motion()
-    drift(m, Rules.OrbRadius, dt)
-    self.place(m)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
-    k := m.scaleX()
-    canvas.blendMode(Blend.Add)
-    canvas.drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * alpha))
-    canvas.drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * alpha))
-    canvas.blendMode(Blend.Normal)
-    frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
-# A spinning mine drifting about.
-struct Mine(Actor(x, y), mut vx: Float, mut vy: Float, tex: Texture, mut clock: Float, mut live: Bool) =
-  fun init(self) =
-    self.width = Rules.Cell * Rules.Zoom
-    self.height = self.width
-    self.originX = self.width / 2.0
-    self.originY = self.height / 2.0
-  fun create(sheet: Texture, at: Motion) -> Mine =
-    Mine(x: at.x, y: at.y, vx: at.vx, vy: at.vy, tex: sheet, clock: 0.0, live: true)
-  fun motion(self) -> Motion =
-    Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
-  fun place(self, m: Motion) =
-    self.x = m.x
-    self.y = m.y
-    self.vx = m.vx
-    self.vy = m.vy
-  override fun act(self, dt: Float) =
-    self.clock = self.clock + dt
-    if !self.live
-      return
-    m := self.motion()
-    drift(m, Rules.MineRadius, dt)
-    self.place(m)
-    self.rotation = self.rotation + 2.0 * dt
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    frame := Float(frameOf(self.clock, 4, 4.0))
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
-# A background star that twinkles.
-struct Star(Actor(x, y, width, height), seed: Float, mut clock: Float) =
-  fun create(i: Int) -> Star =
-    r := 1.0 + Float(i % 3) * 0.5
-    Star(
-      x: Float({i * 7919} % 800) - r, y: Float({i * 104729} % 600) - r, width: r * 2.0,
-      height: r * 2.0, seed: Float(i), clock: 0.0)
-  override fun act(self, dt: Float) =
-    self.clock = self.clock + dt
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    twinkle := 0.25 + 0.2 * Math.sin(self.clock * 2.0 + self.seed)
-    drawDisc(canvas, m, alpha, self.width / 2.0, Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
-# The whole game: it embeds the Stage (camera and root) and has its layers, typed handles to the actors the rules
-# touch, and the run's state. `mines` and `orbs` are the layer Groups; `mineList`
-# and `orbList` are the same actors, typed.
-# Enter or R going down.
-fun isRestartKey(e: InputEvent) -> Bool = match e
-  KeyDown(k) => k == Key.Enter || k == Key.KeyR
-  _ => false
-struct World(
-  Stage(camX, camY, camScale, focus),
-  ship: Ship,
-  mines: Group,
-  orbs: Group,
-  mineList: Slice[Mine],
-  orbList: Slice[Orb],
-  overlay: Group,
-  scoreText: Text,
-  bestText: Text,
-  lifeIcons: Slice[Sprite],
-  mut rng: Random,
-  mut score: Int,
-  mut best: Int,
-  mut lives: Int,
-  mut over: Bool,
-  mut clock: Float,
-  sheet: Texture) =
-  fun create(seed: Int, sheet: Texture) -> World =
-    ship := Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, tex: sheet, vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
-    stars := Group()
-    for i := range 40
-      stars.add(Star.create(i))
-    mines := Group()
-    orbs := Group()
-    hud := Group()
-    scoreText := Text.create("Score 0", 28.0, Color.White)
-    scoreText.x = 16.0
-    scoreText.y = 12.0
-    bestText := Text.create("Best 0", 20.0, Color.Yellow)
-    bestText.x = 16.0
-    bestText.y = 44.0
-    hud.add(scoreText)
-    hud.add(bestText)
-    icons := Slice[Sprite]()
-    for i := range Rules.StartLives
-      icon := Sprite.create(sheet, 0.0, 0.0, Rules.Cell, Rules.Cell, 32.0, 32.0)
-      icon.x = Rules.ArenaW - 40.0 - Float(i) * 36.0
-      icon.y = 12.0
-      hud.add(icon)
-      icons.push(icon)
-    overlay := Group()
-    overlay.visible = false
-    overlay.add(Rect.create(Rules.ArenaW, 120.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)).at(0.0, 240.0))
-    overlay.add(Text.create("Game over", 48.0, Color.Red).at(300.0, 258.0))
-    overlay.add(Text.create("Press Enter to play again", 24.0, Color.White).at(270.0, 316.0))
-    hud.add(overlay)
-    w := World(
-      camX: 0.0, camY: 0.0, camScale: 1.0, focus: None, ship: ship, mines: mines, orbs: orbs, mineList: Slice[Mine](), orbList: Slice[Orb](),
-      overlay: overlay, scoreText: scoreText, bestText: bestText, lifeIcons: icons,
-      rng: Random.seeded(seed), score: 0, best: 0, lives: Rules.StartLives, over: false, clock: 0.0, sheet: sheet)
-    w.root.add(Rect.create(Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)))
-    w.root.add(stars)
-    w.root.add(mines)
-    w.root.add(orbs)
-    w.root.add(ship)
-    w.root.add(hud)
-    for i := range Rules.OrbCount
-      sp := spawn(w.rng, ship.x, ship.y, 120.0, 40.0)
-      w.rng = sp.rng
-      orb := Orb.create(sheet, Float(i) * 0.1, sp.at)
-      orbs.add(orb)
-      w.orbList.push(orb)
-    for i := range mineCount(0)
-      w.addMine()
-    w
-  # A world with the orbs and mines moved out of the way.
-  fun empty() -> World =
-    w := World.create(7, Texture(id: -1))
-    for i := range w.orbList.length()
-      w.orbList.at(i).place(Motion(x: 5000.0, y: 0.0, vx: 0.0, vy: 0.0))
-    for i := range w.mineList.length()
-      w.mineList.at(i).place(Motion(x: 5000.0, y: 0.0, vx: 0.0, vy: 0.0))
-    w
-  # Adds one mine, far from the ship, to the mines layer.
-  fun addMine(self) =
-    sp := spawn(self.rng, self.ship.x, self.ship.y, 220.0, 90.0)
-    self.rng = sp.rng
-    mine := Mine.create(self.sheet, sp.at)
-    self.mines.add(mine)
-    self.mineList.push(mine)
-  # Starts a fresh game, keeping the best score and the random stream.
-  fun restart(self) =
-    self.best = self.best.max(self.score)
-    self.score = 0
-    self.lives = Rules.StartLives
-    self.over = false
-    ship := self.ship
-    ship.hurt = 0.0
-    ship.visible = true
-    ship.x = Rules.ArenaW / 2.0
-    ship.y = Rules.ArenaH / 2.0
-    ship.vx = 0.0
-    ship.vy = 0.0
-    for i := range self.orbList.length()
-      sp := spawn(self.rng, ship.x, ship.y, 120.0, 40.0)
-      self.rng = sp.rng
-      self.orbList.at(i).place(sp.at)
-    while self.mineList.length() > mineCount(0)
-      gone := self.mineList.pop()!
-      self.mines.remove(gone)
-    for i := range self.mineList.length()
-      sp := spawn(self.rng, ship.x, ship.y, 220.0, 90.0)
-      self.rng = sp.rng
-      self.mineList.at(i).place(sp.at)
-    self.sync()
-  # Copies the score, best score, lives and game-over panel into the HUD actors.
-  fun sync(self) =
-    self.scoreText.text = "Score {self.score}"
-    self.bestText.text = "Best {self.best.max(self.score)}"
-    for i := range self.lifeIcons.length()
-      self.lifeIcons.at(i).visible = i < self.lives
-    self.overlay.visible = self.over
-  # Lets the actors move (while the game runs) or only animate (once it is over).
-  fun setLive(self, live: Bool) =
-    self.ship.live = live
-    for i := range self.orbList.length()
-      self.orbList.at(i).live = live
-    for i := range self.mineList.length()
-      self.mineList.at(i).live = live
-  # One simulation step: every actor acts through the embedded Stage, then the rules look at
-  # the result. Once the game is over the actors only animate; nothing moves or scores.
-  fun step(self, ax: Float, ay: Float, dt: Float) =
-    self.clock = self.clock + dt
-    self.setLive(!self.over)
-    self.ship.ax = ax
-    self.ship.ay = ay
-    self.act(dt)
-    if self.over
-      return
-    ship := self.ship
-    for i := range self.orbList.length()
-      orb := self.orbList.at(i)
-      if overlaps(ship.x, ship.y, Rules.ShipRadius, orb.x, orb.y, Rules.OrbRadius)
-        self.score = self.score + Rules.OrbPoints
-        sp := spawn(self.rng, ship.x, ship.y, 120.0, 40.0)
-        self.rng = sp.rng
-        orb.place(sp.at)
-    while self.mineList.length() < mineCount(self.score)
-      self.addMine()
-    for i := range self.mineList.length()
-      mine := self.mineList.at(i)
-      if ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, mine.x, mine.y, Rules.MineRadius)
-        self.lives = self.lives - 1
-        ship.hurt = Rules.HurtTime
-        if self.lives <= 0
-          self.over = true
-          self.best = self.best.max(self.score)
-          ship.visible = false
-    self.sync()
-  # Fits the arena into a screen of `sw` by `sh` pixels, centred.
-  fun fit(self, sw: Float, sh: Float) =
-    zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
-    self.camScale = zoom
-    self.camX = 0.0 - {sw / zoom - Rules.ArenaW} / 2.0
-    self.camY = 0.0 - {sh / zoom - Rules.ArenaH} / 2.0
-  override fun draw(self, canvas: Canvas) =
-    self.fit(canvas.width(), canvas.height())
-    canvas.clear(Color.rgb(0.04, 0.05, 0.1))
-    self.Stage.draw(canvas)
-fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
-  Math.hypot(ax - bx, ay - by) < ra + rb
-# --- host glue: input, sound, drawing ---
-fun musicVolume() -> Float =
-  0.3
-# The game: a `World` and the host parts it plays with.
-struct OrbScene(Game(engine), world: World, pickupSound: Sound, hitSound: Sound, overSound: Sound, musicSound: Sound) =
-  # Restarts the music loop from the top.
-  fun startMusic(self) =
-    self.audio.stop(self.musicSound)
-    self.audio.loop(self.musicSound, musicVolume())
-  # Offers each input to the stage and handles what no actor consumed: Enter or R
-  # restarts a finished game.
-  override fun update(self, dt: Float) =
-    w := self.world
-    inputs := self.input.events()
-    for i := range inputs.length()
-      e := inputs.at(i)
-      if !w.input(e) && w.over && isRestartKey(e)
-        w.restart()
-        self.startMusic()
-    left := self.input.isKeyDown(Key.Left) || self.input.isKeyDown(Key.KeyA)
-    right := self.input.isKeyDown(Key.Right) || self.input.isKeyDown(Key.KeyD)
-    up := self.input.isKeyDown(Key.Up) || self.input.isKeyDown(Key.KeyW)
-    down := self.input.isKeyDown(Key.Down) || self.input.isKeyDown(Key.KeyS)
-    score := w.score
-    lives := w.lives
-    w.step(axis(left, right), axis(up, down), dt)
-    if w.score > score
-      self.audio.play(self.pickupSound, 0.8)
-    if w.lives < lives
-      if w.over
-        self.audio.stop(self.musicSound)
-        self.audio.play(self.overSound, 1.0)
-      else
-        self.audio.play(self.hitSound, 1.0)
-  override fun draw(self) =
-    self.world.draw(self.canvas)
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  game := OrbScene(
-    engine: e, world: World.create(io.randomSeed(), e.assets.texture("sprites.png")),
-    pickupSound: e.assets.sound("pickup.wav"), hitSound: e.assets.sound("hit.wav"),
-    overSound: e.assets.sound("gameover.wav"), musicSound: e.assets.sound("music.wav"))
-  game.startMusic()
-  game
-fun axis(negative: Bool, positive: Bool) -> Float =
-  if negative && !positive
-    -1.0
-  else if positive && !negative
-    1.0
-  else
-    0.0
-fun near(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.01
-test "steering accelerates and drag slows the ship"
-  ship := Ship(x: 400.0, y: 300.0, tex: Texture(id: -1), vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
-  ship.ax = 1.0
-  ship.act(0.1)
-  assert ship.vx > 0.0
-  assert ship.x > 400.0
-  fast := ship.vx
-  ship.ax = 0.0
-  for i := range 30
-    ship.act(0.1)
-  assert ship.vx < fast / 4.0
-test "the ship stops at the arena walls"
-  ship := Ship(x: 20.0, y: 20.0, tex: Texture(id: -1), vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, live: true)
-  ship.ax = -1.0
-  ship.ay = -1.0
-  for i := range 20
-    ship.act(0.1)
-  assert ship.x == Rules.ShipRadius
-  assert ship.y == Rules.ShipRadius
-  assert ship.vx == 0.0
-test "drifters bounce off the walls"
-  orb := Orb.create(Texture(id: -1), 0.0, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0))
-  orb.act(0.1)
-  assert orb.vx == -100.0
-  assert orb.x == Rules.ArenaW - 10.0
-test "a mine spins as it drifts"
-  mine := Mine.create(Texture(id: -1), Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0))
-  mine.act(0.5)
-  assert near(mine.rotation, 1.0)
-  assert near(mine.x, 405.0)
-test "the scene has a backdrop, stars, mines, orbs, ship and HUD layers"
-  w := World.create(7, Texture(id: -1))
-  assert w.root.children.length() == 6
-  assert w.root.children.at(1).children.length() == 40
-  assert w.mines.children.length() == mineCount(0)
-  assert w.orbs.children.length() == Rules.OrbCount
-  assert same(w.root.children.at(4), w.ship)
-  assert same(w.root.children.at(2), w.mines)
-  assert same(w.root.children.at(3), w.orbs)
-test "collecting an orb scores and respawns it elsewhere, still in the orbs layer"
-  w := World.empty()
-  orb := w.orbList.at(0)
-  orb.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  w.step(0.0, 0.0, 0.016)
-  assert w.score == Rules.OrbPoints
-  assert Math.hypot(orb.x - w.ship.x, orb.y - w.ship.y) >= 120.0
-  assert orb.x < 5000.0
-  assert w.orbs.children.length() == Rules.OrbCount
-  assert same(orb.parent.unwrap(), w.orbs)
-  assert w.scoreText.text == "Score 10"
-test "a mine costs one life and makes the ship flash through its own act"
-  w := World.empty()
-  mine := w.mineList.at(0)
-  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  w.step(0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-  assert w.ship.hurt > 0.0
-  assert !w.lifeIcons.at(2).visible
-  assert w.lifeIcons.at(1).visible
-  mine.place(Motion(x: 5000.0, y: 0.0, vx: 0.0, vy: 0.0))
-  hidden := 0
-  shown := 0
-  for i := range 100
-    w.step(0.0, 0.0, 0.016)
-    if w.ship.visible
-      shown = shown + 1
-    else
-      hidden = hidden + 1
-  assert hidden > 0
-  assert shown > 0
-  assert w.ship.hurt == 0.0
-  assert w.ship.visible
-  assert w.lives == Rules.StartLives - 1
-test "the ship is briefly safe after a hit"
-  w := World.empty()
-  mine := w.mineList.at(0)
-  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  w.step(0.0, 0.0, 0.016)
-  w.step(0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-test "the game ends at zero lives and then ignores steps"
-  w := World.empty()
-  w.lives = 1
-  w.score = 40
-  mine := w.mineList.at(0)
-  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  w.step(0.0, 0.0, 0.016)
-  assert w.over
-  assert w.lives == 0
-  assert w.best == 40
-  assert w.overlay.visible
-  assert !w.ship.visible
-  x := w.ship.x
-  w.step(1.0, 0.0, 0.5)
-  assert w.ship.x == x
-test "after game over nothing moves but the animations keep running"
-  w := World.empty()
-  w.lives = 1
-  mine := w.mineList.at(0)
-  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 10.0, vy: 0.0))
-  w.step(0.0, 0.0, 0.016)
-  assert w.over
-  x := mine.x
-  rot := mine.rotation
-  clock := mine.clock
-  orbClock := w.orbList.at(0).clock
-  star := Star.create(0)
-  w.root.children.at(1).add(star)
-  for i := range 10
-    w.step(1.0, 0.0, 0.1)
-  assert mine.x == x
-  assert mine.rotation == rot
-  assert w.ship.x == Rules.ArenaW / 2.0
-  assert !w.ship.visible
-  assert mine.clock > clock + 0.9
-  assert w.orbList.at(0).clock > orbClock + 0.9
-  assert star.clock > 0.9
-  assert w.score == 0
-test "restart resets the run and keeps the best score"
-  w := World.empty()
-  w.score = 90
-  w.lives = 0
-  w.over = true
-  w.overlay.visible = true
-  w.restart()
-  assert !w.over
-  assert !w.overlay.visible
-  assert w.ship.visible
-  assert w.score == 0
-  assert w.best == 90
-  assert w.lives == Rules.StartLives
-  assert w.ship.x == Rules.ArenaW / 2.0
-  assert w.mineList.length() == mineCount(0)
-  assert w.bestText.text == "Best 90"
-test "more mines appear as the score grows and restart removes them from the layer"
-  assert mineCount(0) == 3
-  assert mineCount(100) == 5
-  assert mineCount(10000) == 8
-  w := World.empty()
-  w.score = 100
-  w.step(0.0, 0.0, 0.016)
-  assert w.mineList.length() == 5
-  assert w.mines.children.length() == 5
-  w.restart()
-  assert w.mineList.length() == 3
-  assert w.mines.children.length() == 3
-test "the same seed plays out the same way"
-  a := World.create(11, Texture(id: -1))
-  b := World.create(11, Texture(id: -1))
-  for i := range 120
-    a.step(1.0, -1.0, 0.016)
-    b.step(1.0, -1.0, 0.016)
-  assert a.ship.x == b.ship.x
-  assert a.score == b.score
-  assert a.mineList.at(0).x == b.mineList.at(0).x
-  assert World.create(12, Texture(id: -1)).orbList.at(0).x != a.orbList.at(0).x
-test "fit centres the arena on the screen"
-  w := World.create(7, Texture(id: -1))
-  w.fit(1600.0, 600.0)
-  assert near(w.camScale, 1.0)
-  assert near(w.camX, -400.0)
-  assert near(w.camY, 0.0)
-test "animation frames cycle"
-  assert frameOf(0.0, 4, 8.0) == 0
-  assert frameOf(0.13, 4, 8.0) == 1
-  assert frameOf(0.5, 4, 8.0) == 0
-  assert axis(true, false) == -1.0
-  assert axis(true, true) == 0.0

examples/games/imperative/scene.plum DELETED Viewed

@@ -1,433 +0,0 @@
-# Clockwork: a scene-graph demo (`plum run examples/games/imperative/scene.plum`). A sun, four
-# planets and their moons orbit by nesting rotating groups (std/game/imperative/Scene): each orbit
-# is a group whose rotation carries everything inside it, so a moon only ever
-# says "I sit 40 units from my planet" and the maths composes the rest. Click a
-# body to select it (a halo and its name), click again or the background to clear;
-# Space pauses. A crowd of small walkers crosses the bottom of the screen: they are
-# y-sorted every frame with `sortChildren` (lower ones draw in front), culled
-# against the camera view with `setCullingArea`, and a clicked walker is brought
-# to the front with `toFront`.
-#
-# The scene is built and queried by plain functions that never call the host, so
-# the `test` blocks below run under `plum test`; only `Clockwork`, the `Game` struct
-# over a `Sky`, and `main` talk to the host.
-module scene
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Option
-import std/Math
-import std/game/Vec2
-import std/game/Color
-import std/game/Game
-import std/game/imperative/Scene
-import std/game/Input
-import std/Io
-import std/List
-primitive Layout =
-  Width = 800.0
-  Height = 600.0
-  CenterX = 400.0
-  CenterY = 300.0
-  Cell = 16.0
-  MapW = 160
-  MapH = 120
-  MapScale = 0.2
-  Planets = 4
-  Walkers = 60
-  WalkMin = 500.0
-  WalkMax = 1300.0
-# Actor kinds of this game: `struct X(Actor(width, height), ...)` embeds the scene's `Actor` struct first, so
-# an X is a subtype of Actor: it goes wherever an Actor is expected and its own `act` and `draw` run in the tree.
-# A group that turns `speed` radians per second and carries its children round.
-struct Orbit(Actor, speed: Float) =
-  override fun act(self, dt: Float) =
-    self.rotation = self.rotation + self.speed * dt
-    self.actChildren(dt)
-# A sprite that turns on its own axis, `speed` radians per second.
-struct Spinner(Actor(width, height, originX, originY), speed: Float, tex: Texture, mut srcX: Float, srcY: Float) =
-  fun init(self) =
-    self.srcW: Float = Layout.Cell
-    self.srcH: Float = Layout.Cell
-  fun create(sheet: Texture, sx: Float, sy: Float, size: Float, speed: Float) -> Spinner =
-    Spinner(
-      width: size, height: size, originX: size / 2.0, originY: size / 2.0, speed: speed, tex: sheet,
-      srcX: sx, srcY: sy)
-  override fun act(self, dt: Float) =
-    self.rotation = self.rotation + self.speed * dt
-    self.actChildren(dt)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
-# A walker: moves along x at `pace` and bobs on a wave of its x.
-struct Walker(Actor, pace: Float, phase: Float, tex: Texture, srcX: Float) =
-  fun init(self) =
-    self.width = 24.0
-    self.height = 24.0
-    self.srcY: Float = Layout.Cell
-    self.srcW: Float = Layout.Cell
-    self.srcH: Float = Layout.Cell
-  override fun act(self, dt: Float) =
-    nx := self.x + dt * self.pace
-    if nx > Layout.WalkMax
-      nx = 0.0 - Layout.WalkMin
-    if nx < 0.0 - Layout.WalkMin
-      nx = Layout.WalkMax
-    self.x = nx
-    self.y = 510.0 + 50.0 * Math.sin(nx / 90.0 + self.phase)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
-# Everything `update` and `draw` need. `bodies` and `names` are parallel (every
-# planet and moon, each planet followed by its moons), as are `halos` (the glow shown when selected).
-struct Sky(
-  stage: Stage,
-  bodies: Slice[Actor],
-  halos: Slice[Actor],
-  names: Slice[Str],
-  sun: Spinner,
-  label: Text,
-  crowd: Group,
-  mut front: Option[Actor],
-  mut selected: Int,
-  mut clock: Float,
-  mut paused: Bool,
-  map: Texture)
-# A body sprite and its (hidden) halo in a group `slot` centred on the group's own
-# origin. The caller places the slot; the sprite spins on its own axis.
-fun addBody(sky: Sky, sheet: Texture, name: Str, row: Int, frame: Int, size: Float, spin: Float) -> Actor =
-  slot := Group()
-  halo := Circle.create(size * 0.8, Color(r: 1.0, g: 0.9, b: 0.5, a: 0.35)).at(0.0 - size * 0.8, 0.0 - size * 0.8)
-  halo.visible = false
-  body := Spinner.create(sheet, Float(frame) * Layout.Cell, Float(row) * Layout.Cell, size, spin).at(0.0 - size / 2.0, 0.0 - size / 2.0)
-  slot.add(halo)
-  slot.add(body)
-  sky.halos.push(halo)
-  sky.bodies.push(body)
-  sky.names.push(name)
-  slot
-fun newSky(sheet: Texture, map: Texture) -> Sky =
-  stage := Stage.create()
-  backdrop := Rect.create(Layout.Width, Layout.Height, Color.rgb(0.04, 0.05, 0.1))
-  stage.root.add(backdrop)
-  for i := range 40
-    star := Circle.create(1.0 + Float(i % 3) * 0.5, Color(r: 0.7, g: 0.8, b: 1.0, a: 0.4)).at(Float({i * 7919} % 800), Float({i * 104729} % 600))
-    stage.root.add(star)
-  sun := Spinner.create(sheet, 0.0, Layout.Cell, 96.0, 0.3)
-  sun.x = Layout.CenterX - 48.0
-  sun.y = Layout.CenterY - 48.0
-  label := Text.create("Click a planet", 24.0, Color.White)
-  label.x = 16.0
-  label.y = 12.0
-  sky := Sky(
-    stage: stage, bodies: Slice[Actor](), halos: Slice[Actor](), names: Slice[Str](),
-    sun: sun, label: label, crowd: Group(), front: None, selected: -1, clock: 0.0, paused: false, map: map)
-  # faint orbit rings, added first so every body draws (and is hit) above them
-  for i := range Layout.Planets
-    r := 90.0 + Float(i) * 60.0
-    stage.root.add(Circle.create(r, Color(r: 1.0, g: 1.0, b: 1.0, a: 0.04)).at(Layout.CenterX - r, Layout.CenterY - r))
-  planetNames := ["Ember", "Cinder", "Ashen", "Glacier"].toSlice()
-  moons := [0, 1, 2, 1].toSlice()
-  for i := range Layout.Planets
-    orbit := Orbit(speed: 0.9 / Float(1 + i)).at(Layout.CenterX, Layout.CenterY)
-    planet := addBody(sky, sheet, planetNames.at(i), 2, i, 40.0, 1.5).at(90.0 + Float(i) * 60.0, 0.0)
-    orbit.add(planet)
-    for m := range moons.at(i)
-      moonOrbit := Orbit(speed: 2.0 + Float(m))
-      moon := addBody(sky, sheet, "{planetNames.at(i)} moon {m + 1}", 1, m, 18.0, 3.0).at(36.0 + Float(m) * 16.0, 0.0)
-      moonOrbit.add(moon)
-      planet.add(moonOrbit)
-    stage.root.add(orbit)
-  stage.root.add(sun)
-  for i := range Layout.Walkers
-    speed := 20.0 + Float(i % 7) * 9.0
-    if i % 2 == 0
-      speed = 0.0 - speed
-    walker := Walker(pace: speed, phase: Float(i), tex: sheet, srcX: Float(i % 3) * Layout.Cell).at(Layout.WalkMax - 1800.0 + Float(i * 61 % 1800), 510.0)
-    sky.crowd.add(walker)
-  stage.root.add(sky.crowd)
-  stage.root.add(label)
-  sky
-# Fits the 800 by 600 scene into a screen of `sw` by `sh` pixels, centred.
-fun fit(sky: Sky, sw: Float, sh: Float) =
-  zoom := {sw / Layout.Width}.min(sh / Layout.Height)
-  sky.stage.camScale = zoom
-  sky.stage.camX = 0.0 - {sw / zoom - Layout.Width} / 2.0
-  sky.stage.camY = 0.0 - {sh / zoom - Layout.Height} / 2.0
-  sky.crowd.setCullingArea(sky.stage.camX, sky.stage.camY, sw / zoom, sh / zoom)
-# The index of a body (or its halo) in `bodies`, or -1.
-fun indexOf(sky: Sky, n: Actor) -> Int =
-  for i := range sky.bodies.length()
-    if same(sky.bodies.at(i), n) || same(sky.halos.at(i), n)
-      return i
-  -1
-# Selects body `i` (or nothing for -1): shows its halo and name.
-fun select(sky: Sky, i: Int) =
-  sky.selected = i
-  for k := range sky.halos.length()
-    sky.halos.at(k).visible = k == i
-  if i < 0
-    sky.label.text = "Click a planet"
-  else
-    sky.label.text = sky.names.at(i)
-# A click at stage point (x, y): selects the body there, deselects it if it was
-# selected already, and clears the selection on empty space.
-fun clickAt(sky: Sky, x: Float, y: Float) =
-  i := -1
-  if Some(n) := sky.stage.hit(x, y)
-    i = indexOf(sky, n)
-    if Some(p) := n.parent
-      if p.children == sky.crowd.children
-        n.toFront()
-        sky.front = Some(n)
-  if i == sky.selected
-    i = -1
-  select(sky, i)
-# Where a body's centre is on the stage.
-fun centerOf(sky: Sky, i: Int) -> Vec2 =
-  b := sky.bodies.at(i)
-  b.localToStage(Vec2(x: b.width / 2.0, y: b.height / 2.0))
-# Advances the clock and every behaviour, and animates the sun's frames.
-fun tick(sky: Sky, dt: Float) =
-  if sky.paused
-    return
-  sky.clock = sky.clock + dt
-  sky.stage.act(dt)
-  sky.crowd.sortChildren(|a, b| a.y < b.y)
-  if Some(f) := sky.front
-    f.toFront()
-  sky.sun.srcX = Float(Int(sky.clock * 6.0) % 4) * Layout.Cell
-# --- host glue ---
-# The game: a `Sky` and the host parts. Space pauses, a press selects a body.
-struct Clockwork(Game(engine), sky: Sky) =
-  override fun update(self, dt: Float) =
-    inputs := self.input.events()
-    for i := range inputs.length()
-      match inputs.at(i)
-        KeyDown(k) =>
-          if k == Key.Space
-            self.sky.paused = !self.sky.paused
-        _ => 0
-    tick(self.sky, dt)
-    fit(self.sky, self.canvas.width(), self.canvas.height())
-    for i := range inputs.length()
-      match inputs.at(i)
-        PointerDown(x, y) =>
-          p := self.sky.stage.screenToStage(x, y)
-          clickAt(self.sky, p.x, p.y)
-        _ => 0
-  override fun draw(self) =
-    self.canvas.clear(Color.Black)
-    self.sky.stage.draw(self.canvas)
-    drawMinimap(self.canvas, self.sky)
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  sheet := e.assets.texture("sprites.png")
-  map := e.canvas.createTexture(Layout.MapW, Layout.MapH)
-  Clockwork(engine: e, sky: newSky(sheet, map))
-# Redraws the minimap texture (every body as a dot, the selected one highlighted)
-# and shows it in the bottom-right corner of the screen.
-fun drawMinimap(canvas: Canvas, sky: Sky) =
-  if sky.map.id < 0
-    return
-  k := Layout.MapScale
-  w := Float(Layout.MapW)
-  h := Float(Layout.MapH)
-  canvas.renderTarget(sky.map)
-  canvas.clear(Color(r: 0.05, g: 0.1, b: 0.2, a: 0.85))
-  canvas.drawRect(0.0, 0.0, w, 1.0, Color.White)
-  canvas.drawRect(0.0, h - 1.0, w, 1.0, Color.White)
-  canvas.drawRect(0.0, 0.0, 1.0, h, Color.White)
-  canvas.drawRect(w - 1.0, 0.0, 1.0, h, Color.White)
-  canvas.drawCircle(Layout.CenterX * k, Layout.CenterY * k, 5.0, Color.Yellow)
-  for i := range sky.bodies.length()
-    c := centerOf(sky, i)
-    dot := Color(r: 0.6, g: 0.8, b: 1.0, a: 1.0)
-    if i == sky.selected
-      dot = Color.Yellow
-    canvas.drawCircle(c.x * k, c.y * k, 2.0, dot)
-  canvas.screenTarget()
-  canvas.drawTexture(sky.map, canvas.width() - w - 8.0, canvas.height() - h - 8.0, Color.White)
-# --- tests ---
-# Test probes (the std library keeps its own tests free of extra Actor kinds).
-# A group that turns by dt each act and acts its children too.
-struct ProbeSpinner(Actor) =
-  override fun act(self, dt: Float) =
-    self.rotation = self.rotation + dt
-    self.actChildren(dt)
-# A walker: moves along x in its own `act` and counts the frames it draws itself in.
-struct ProbeWalker(Actor, speed: Float, mut drawn: Int) =
-  fun init(self) =
-    self.width = 10.0
-    self.height = 10.0
-  override fun act(self, dt: Float) =
-    self.x = self.x + self.speed * dt
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    self.drawn = self.drawn + 1
-fun near(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.01
-test "the scene has a sun, four planets and their moons"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  assert sky.bodies.length() == 8
-  assert sky.halos.length() == 8
-  assert sky.names.length() == 8
-  assert sky.names.at(0) == "Ember"
-  assert sky.names.at(2) == "Cinder moon 1"
-  assert sky.names.at(6) == "Glacier"
-  assert flatten(sky.stage.root).length() > 60
-test "planets start on the right of the sun and orbit clockwise"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  c := centerOf(sky, 0)
-  assert near(c.x, 490.0)
-  assert near(c.y, 300.0)
-  # planet 0 turns 0.9 rad/s: a quarter turn takes HalfPi / 0.9 seconds
-  tick(sky, Float.HalfPi / 0.9)
-  c = centerOf(sky, 0)
-  assert near(c.x, 400.0)
-  assert near(c.y, 390.0)
-test "a moon stays its orbit radius from its planet while both move"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  for i := range 50
-    tick(sky, 0.1)
-    pc := centerOf(sky, 3)
-    mc := centerOf(sky, 4)
-    assert near(pc.distance(mc), 36.0)
-    sc := Vec2(x: Layout.CenterX, y: Layout.CenterY)
-    assert near(sc.distance(pc), 210.0)
-test "clicking selects a body even after it has moved, and again to deselect"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  tick(sky, 3.0)
-  c := centerOf(sky, 1)
-  clickAt(sky, c.x, c.y)
-  assert sky.selected == 1
-  assert sky.label.text == "Cinder"
-  assert sky.halos.at(1).visible
-  assert !sky.halos.at(0).visible
-  clickAt(sky, c.x, c.y)
-  assert sky.selected == -1
-  assert !sky.halos.at(1).visible
-  assert sky.label.text == "Click a planet"
-test "clicking a moon or empty space"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  m := centerOf(sky, 2)
-  clickAt(sky, m.x, m.y)
-  assert sky.names.at(sky.selected) == "Cinder moon 1"
-  clickAt(sky, 2.0, 2.0)
-  assert sky.selected == -1
-test "pausing freezes the scene"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  sky.paused = true
-  tick(sky, 1.0)
-  c := centerOf(sky, 0)
-  assert near(c.x, 490.0)
-  assert sky.clock == 0.0
-test "fit centres the scene and screen points map back"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  fit(sky, 1600.0, 600.0)
-  assert near(sky.stage.camScale, 1.0)
-  assert near(sky.stage.camX, -400.0)
-  p := sky.stage.screenToStage(800.0, 300.0)
-  assert near(p.x, 400.0)
-  assert near(p.y, 300.0)
-test "the crowd is y-sorted every tick and culled against the view"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  tick(sky, 0.5)
-  tick(sky, 0.5)
-  kids := sky.crowd.children
-  assert kids.length() == 60
-  for i := range 59
-    assert kids.at(i).y <= kids.at(i + 1).y
-  fit(sky, 800.0, 600.0)
-  shown := flatten(sky.stage.root).length()
-  fit(sky, 100000.0, 600.0)
-  assert flatten(sky.stage.root).length() > shown
-  for i := range 60
-    assert kids.at(i).x >= 0.0 - 500.0 && kids.at(i).x <= 1300.0
-test "clicking a walker brings it to the front, even after the next sort"
-  sky := newSky(Texture(id: -1), Texture(id: -1))
-  fit(sky, 1800.0, 600.0)
-  w := sky.crowd.children.at(0)
-  p := w.localToStage(Vec2(x: 14.0, y: 14.0))
-  clickAt(sky, p.x, p.y)
-  assert w.zIndex() == 59
-  tick(sky, 0.1)
-  assert w.zIndex() == 59
-test "act runs behaviours depth first, including invisible actors"
-  stage := Stage.create()
-  g := ProbeSpinner()
-  stage.root.add(g)
-  k := ProbeSpinner()
-  g.add(k)
-  g.visible = false
-  stage.act(0.5)
-  stage.act(0.25)
-  assert near(g.rotation, 0.75)
-  assert near(k.rotation, 0.75)
-  assert stage.root.rotation == 0.0
-test "walker_record: a Walker in a Stage moves via its own act and draws via its own draw"
-  stage := Stage.create()
-  w := ProbeWalker(speed: 4.0, drawn: 0)
-  stage.root.add(w)
-  stage.root.add(Group())
-  canvas := Canvas(io: io)
-  stage.act(0.5)
-  stage.act(0.5)
-  assert near(w.x, 4.0)
-  assert w.drawn == 0
-  stage.root.drawTree(canvas, Affine.Identity, 1.0)
-  stage.root.drawTree(canvas, Affine.Identity, 1.0)
-  assert w.drawn == 2
-  w.visible = false
-  stage.root.drawTree(canvas, Affine.Identity, 1.0)
-  assert w.drawn == 2
-  w.visible = true
-  # a base-typed value reaches the same struct
-  a: Actor := w
-  a.act(1.0)
-  assert near(w.x, 8.0)
-  assert same(stage.hit(8.5, 5.0).unwrap(), w)

examples/games/{functional/kids → kids}/balloon_pop.plum RENAMED Viewed

@@ -1,4 +1,4 @@
-# Balloon Pop (`plum run examples/games/functional/kids/balloon_pop.plum`): a
+# Balloon Pop (`plum run examples/games/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
@@ -22,8 +22,8 @@ import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/FunctionalScene
+import std/game/Scene
-import std/game/functional/Anim
+import std/game/Anim
 import std/game/Input
 import std/Io
@@ -307,38 +307,36 @@ fun cloud(x: Float, y: Float) -> SceneNode[Msg] =
 # --- the host shell ---
-struct Balloons(Game(engine), mut state: State, popSound: Sound, partySound: Sound, musicSound: Sound) =
+struct Balloons(state: State, input: Input, popSound: Sound, partySound: Sound, musicSound: Sound) =
   # 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.
+  # pop and a fanfare when a party starts. Returns the game with the next state.
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> Balloons =
+    input := self.input.poll(io)
-    s := self.state.update(Resize(w: self.canvas.width(), h: self.canvas.height()))
+    s := self.state.update(Resize(w: io.screenWidth(), h: io.screenHeight()))
     before := s
-    inputs := self.input.events()
+    inputs := input.events
     for i := range inputs.length()
       s = s.update(Event(input: inputs.at(i)))
     if s.pops > before.pops
-      self.audio.play(self.popSound, 0.9)
+      self.popSound.play(io, 0.9)
     if s.partyAt != before.partyAt
-      self.audio.play(self.partySound, 0.6)
+      self.partySound.play(io, 0.6)
-    self.state = s.update(Tick(dt: dt))
+    Balloons(..self, state: s.update(Tick(dt: dt)), input: input)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    s := self.state
-    canvas := self.canvas
-    canvas.clear(Color.rgb(0.55, 0.8, 1.0))
+    io.clear(Color.rgb(0.55, 0.8, 1.0))
-    s.render().draw(canvas)
+    self.state.render().draw(io)
-fun main(io: Io) -> Game =
+fun main(io: Io) -> Balloons =
-  e := Engine.create(io)
   game := Balloons(
-    engine: e,
     state: State.start(io.randomSeed(), Rules.ArenaW, Rules.ArenaH),
+    input: Input.create(),
-    popSound: e.assets.sound("pickup.wav"),
+    popSound: Sound.load(io, "pickup.wav"),
-    partySound: e.assets.sound("gameover.wav"),
+    partySound: Sound.load(io, "gameover.wav"),
-    musicSound: e.assets.sound("music.wav")
+    musicSound: Sound.load(io, "music.wav")
   )
-  e.audio.loop(game.musicSound, 0.2)
+  game.musicSound.loop(io, 0.2)
   game
 # --- tests ---

examples/games/{functional/game_state_view.plum → orb_run.plum} RENAMED Viewed

@@ -1,6 +1,5 @@
-# Orb Run as components (`plum run examples/games/functional/game_state_view.plum`): the same
+# Orb Run as components (`plum run examples/games/orb_run.plum`), written in the
-# game as game_pure_scene.plum (same arena, rules, sprites, sounds, keys and scoring),
-# written in the component style of Elm and React but purely functional. Steer the ship
+# component style of Elm and React but purely functional. Steer the ship
 # with the arrow keys or WASD, collect the drifting orbs and avoid the mines. Three
 # lives; Enter, R or the "Again" button restarts after the game is over.
 #
@@ -20,9 +19,10 @@
 # message (`RestartClicked`): `Ui.messages` reads it from the picture, and it goes to
 # `State.update` like any other `Msg`. The picture is a `SceneNode[Msg]`.
 # The game-over title and the ship's hurt flash are `Anim`s of time since they began.
-# The `Game` struct below is the host shell: it holds the current `State`, turns the
+# `OrbGame` below is the host shell: `main` returns it, and its `update(self, io, dt)`
+# returns the next one. It holds the current `State`, turns the frame's input into
-# frame's input into messages, and plays sounds.
+# messages, and plays sounds.
-module game_state_view
+module orb_run
 import std/Str
 import std/Int
 import std/Float
@@ -34,9 +34,9 @@ import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/functional/FunctionalScene
+import std/game/Scene
-import std/game/functional/Anim
+import std/game/Anim
-import std/game/functional/Ui
+import std/game/Ui
 import std/game/Input
 import std/Io
@@ -523,57 +523,55 @@ fun isRestartKey(e: InputEvent) -> Bool = match e
 # --- the host shell ---
-struct OrbGame(Game(engine), mut state: State, pickupSound: Sound, hitSound: Sound, overSound: Sound, musicSound: Sound) =
+struct OrbGame(state: State, input: Input, pickupSound: Sound, hitSound: Sound, overSound: Sound, musicSound: Sound) =
   # Restarts the music loop from the top.
-  fun startMusic(self) =
+  fun startMusic(self, io: Io) =
-    self.audio.stop(self.musicSound)
+    self.musicSound.stop(io)
-    self.audio.loop(self.musicSound, musicVolume())
+    self.musicSound.loop(io, musicVolume())
-  # Sends the frame's inputs to the state, then one tick steered by the held keys;
+  # Polls the input once, sends its events to the state, then one tick steered by the
-  # plays sounds for what changed.
+  # held keys; plays sounds for what changed. Returns the game with the next state.
-  override fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) -> OrbGame =
+    input := self.input.poll(io)
-    s := self.state.update(Resize(w: self.canvas.width(), h: self.canvas.height()))
+    s := self.state.update(Resize(w: io.screenWidth(), h: io.screenHeight()))
     clicked := s
-    inputs := self.input.events()
+    inputs := input.events
     for i := range inputs.length()
       clicked = clicked.update(Event(input: inputs.at(i)))
     if s.over && !clicked.over
-      self.state = clicked
-      self.startMusic()
+      self.startMusic(io)
+      OrbGame(..self, state: clicked, input: input)
-      return
+    else
-    t := clicked.update(Tick(dt: dt, ax: clicked.axisX(), ay: clicked.axisY()))
+      t := clicked.update(Tick(dt: dt, ax: clicked.axisX(), ay: clicked.axisY()))
-    if t.score > clicked.score
+      if t.score > clicked.score
-      self.audio.play(self.pickupSound, 0.8)
+        self.pickupSound.play(io, 0.8)
-    if t.lives < clicked.lives
+      if t.lives < clicked.lives
-      if t.over
+        if t.over
-        self.audio.stop(self.musicSound)
+          self.musicSound.stop(io)
-        self.audio.play(self.overSound, 1.0)
+          self.overSound.play(io, 1.0)
-      else
+        else
-        self.audio.play(self.hitSound, 1.0)
+          self.hitSound.play(io, 1.0)
-    self.state = t
+      OrbGame(..self, state: t, input: input)
-  override fun draw(self) =
+  fun draw(self, io: Io) =
-    s := self.state
-    canvas := self.canvas
-    canvas.clear(Color.rgb(0.04, 0.05, 0.1))
+    io.clear(Color.rgb(0.04, 0.05, 0.1))
-    s.render().draw(canvas)
+    self.state.render().draw(io)
 fun musicVolume() -> Float =
   0.3
-fun main(io: Io) -> Game =
+fun main(io: Io) -> OrbGame =
-  e := Engine.create(io)
-  s := State.start(io.randomSeed(), 0, e.assets.texture("sprites.png"), e.canvas.createTexture(1600, 1200), Rules.ArenaW, Rules.ArenaH)
+  s := State.start(io.randomSeed(), 0, Texture.load(io, "sprites.png"), Texture.create(io, 1600, 1200), Rules.ArenaW, Rules.ArenaH)
   game := OrbGame(
-    engine: e,
     state: s,
+    input: Input.create(),
-    pickupSound: e.assets.sound("pickup.wav"),
+    pickupSound: Sound.load(io, "pickup.wav"),
-    hitSound: e.assets.sound("hit.wav"),
+    hitSound: Sound.load(io, "hit.wav"),
-    overSound: e.assets.sound("gameover.wav"),
+    overSound: Sound.load(io, "gameover.wav"),
-    musicSound: e.assets.sound("music.wav")
+    musicSound: Sound.load(io, "music.wav")
   )
-  game.startMusic()
+  game.startMusic(io)
   game
 fun axis(negative: Bool, positive: Bool) -> Float =

examples/games/pure/game_pure_scene.plum DELETED Viewed

@@ -1,880 +0,0 @@
-# Orb Run on the pure scene graph (`plum game examples/games/pure/game_pure_scene.plum`): the same
-# game as game_scene.plum (same arena, rules, sprites, sounds, keys and scoring), but the
-# scene is made of values. Steer the ship with the arrow keys or WASD, collect the
-# drifting orbs and avoid the mines. Three lives; Enter, R or the "Again" button
-# restarts after the game is over.
-#
-# What differs from game_scene.plum. There, actors are mutable objects that point at
-# their parent and `stage.act` changes them in place. Here the scene is made of `Node` values
-# (std `Group`, `Sprite`, `Label`, `Button` kinds, and `Custom` nodes whose behaviour is a
-# record embedding `Actor`: `Ship`, `Orb`, `Mine`, `Star`, `Panel`):
-# `act` returns the next node, `Stage.frame` returns a new `Stage`, and a change from the
-# rules ("this orb is collected", "show the game-over panel") is a `Node.modify`
-# on an actor id that returns a new tree. The `World` record below is the mutable shell the
-# host talks to: it keeps the current `Stage` and the run's state (score, lives, the ship's
-# velocity) and replaces its `stage` every frame. Nothing that a function was given
-# is ever changed; only `init`, `update` and `draw` talk to the host.
-module game_pure_scene
-import std/Str
-import std/Int
-import std/Float
-import std/Slice
-import std/Option
-import std/Math
-import std/Random
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/game/pure/Actions
-import std/game/pure/PureScene
-import std/game/pure/SceneInput
-import std/game/Input
-import std/Io
-import std/List
-primitive Rules =
-  ArenaW = 800.0
-  ArenaH = 600.0
-  ShipRadius = 10.0
-  OrbRadius = 10.0
-  MineRadius = 11.0
-  Thrust = 900.0
-  Drag = 2.2
-  OrbCount = 3
-  StartLives = 3
-  HurtTime = 1.5
-  OrbPoints = 10
-  Cell = 16.0
-  Size = 48.0
-  Half = 24.0
-# Actor ids: unique in the tree, so the rules can find an actor with `Node.modify`.
-primitive Id =
-  Root = 1
-  Backdrop = 2
-  StarLayer = 3
-  MineLayer = 4
-  OrbLayer = 5
-  Ship = 6
-  Hud = 7
-  Score = 8
-  Best = 9
-  Overlay = 20
-  OverlayPanel = 21
-  OverTitle = 22
-  OverHint = 23
-  Restart = 24
-  Icon = 30
-  Orb = 100
-  Mine = 200
-  Star = 1000
-# A position and velocity: what a spawn returns and what drifters are bounced with.
-struct Motion(x: Float, y: Float, vx: Float, vy: Float)
-# Which of `count` animation frames is showing after `clock` seconds at `fps` frames per second.
-fun frameOf(clock: Float, count: Int, fps: Float) -> Int =
-  Int(clock * fps) % count
-# A random spot at least `gap` away from (ax, ay), drifting at up to `speed`.
-# A Motion and the generator to continue from.
-struct Spawned(at: Motion, rng: Random)
-fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Spawned =
-  margin := 30.0
-  bx := 0.0
-  by := 0.0
-  r := rng
-  tries := 0
-  while tries < 20
-    dx := r.nextFloat()
-    dy := dx.rng.nextFloat()
-    r = dy.rng
-    bx = margin + dx.value * {Rules.ArenaW - 2.0 * margin}
-    by = margin + dy.value * {Rules.ArenaH - 2.0 * margin}
-    if Math.hypot(bx - ax, by - ay) >= gap
-      break
-    tries = tries + 1
-  dh := r.nextFloat()
-  dp := dh.rng.nextFloat()
-  heading := dh.value * Float.Tau
-  pace := speed * {0.4 + 0.6 * dp.value}
-  Spawned(at: Motion(x: bx, y: by, vx: Math.cos(heading) * pace, vy: Math.sin(heading) * pace), rng: dp.rng)
-# `b` moved for `dt` seconds and bounced off the arena walls; `b` itself is unchanged.
-fun driftOf(b: Motion, r: Float, dt: Float) -> Motion =
-  x := b.x + b.vx * dt
-  y := b.y + b.vy * dt
-  vx := b.vx
-  vy := b.vy
-  if x < r || x > Rules.ArenaW - r
-    vx = 0.0 - b.vx
-    x = x.max(r).min(Rules.ArenaW - r)
-  if y < r || y > Rules.ArenaH - r
-    vy = 0.0 - b.vy
-    y = y.max(r).min(Rules.ArenaH - r)
-  Motion(x: x, y: y, vx: vx, vy: vy)
-# How many mines are out: more as the score grows.
-fun mineCount(score: Int) -> Int =
-  {3 + score / 50}.min(8)
-# The ship's motion state. The ship actor in the tree only shows it.
-struct ShipState(x: Float, y: Float, vx: Float, vy: Float, rotation: Float, hurt: Float)
-# Accelerates by the input axes, applies drag and keeps the ship in the arena.
-fun shipStep(s: ShipState, ax: Float, ay: Float, dt: Float) -> ShipState =
-  hurt := {s.hurt - dt}.max(0.0)
-  keep := {1.0 - Rules.Drag * dt}.max(0.0)
-  vx := {s.vx + ax * Rules.Thrust * dt} * keep
-  vy := {s.vy + ay * Rules.Thrust * dt} * keep
-  x := s.x + vx * dt
-  y := s.y + vy * dt
-  r := Rules.ShipRadius
-  if x < r
-    x = r
-    vx = 0.0
-  if x > Rules.ArenaW - r
-    x = Rules.ArenaW - r
-    vx = 0.0
-  if y < r
-    y = r
-    vy = 0.0
-  if y > Rules.ArenaH - r
-    y = Rules.ArenaH - r
-    vy = 0.0
-  rotation := s.rotation
-  if vx * vx + vy * vy > 400.0
-    rotation = Math.atan2(vx, 0.0 - vy)
-  ShipState(x: x, y: y, vx: vx, vy: vy, rotation: rotation, hurt: hurt)
-fun newShip() -> ShipState =
-  ShipState(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
-# The centre of a node drawn as a sprite-sized box.
-fun cx(n: Node) -> Float =
-  n.x + n.width / 2.0
-fun cy(n: Node) -> Float =
-  n.y + n.height / 2.0
-# Actor kinds of this game. Each holds only its own fields; position and size live on
-# the `Node`. Each `create` returns a sprite-sized node; it takes the centre.
-# A filled rectangle; its colour is the node's.
-struct Panel(Actor) =
-  fun create(id: Int, x: Float, y: Float, w: Float, h: Float, c: Color) -> Node =
-    n := Node.custom(id, x, y, w, h, Panel())
-    Node(..n, color: c)
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    p := m.apply(Vec2(x: 0.0, y: 0.0))
-    canvas.drawRect(p.x, p.y, n.width * m.scaleX(), n.height * m.scaleY(), tint)
-# The player: only a picture that follows `ShipState`; `act` runs its animation clock.
-struct Ship(Actor, mut clock: Float, tex: Texture) =
-  fun create(sheet: Texture, s: ShipState) -> Node =
-    n := Node.custom(Id.Ship, s.x - Rules.Half, s.y - Rules.Half, Rules.Size, Rules.Size, Ship(clock: 0.0, tex: sheet))
-    Node(..n, originX: Rules.Half, originY: Rules.Half)
-  override fun act(self, n: Node, dt: Float) -> Node =
-    self.clock = self.clock + dt
-    n
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
-    canvas.drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * tint.a))
-    frame := Float(frameOf(self.clock, 4, 14.0))
-    Node.drawSprite(canvas, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
-# A glowing orb drifting about. `phase` offsets its animation from the other orbs.
-struct Orb(Actor, mut vx: Float, mut vy: Float, phase: Float, mut clock: Float, tex: Texture) =
-  fun create(sheet: Texture, phase: Float, id: Int, at: Motion) -> Node =
-    Orb.createAt(sheet, phase, id, at, 0.0)
-  # An orb that carries on an animation `clock`, so a respawn or freeze never jumps a frame.
-  fun createAt(sheet: Texture, phase: Float, id: Int, at: Motion, clock: Float) -> Node =
-    n := Node.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
-      Orb(vx: at.vx, vy: at.vy, phase: phase, clock: clock, tex: sheet))
-    Node(..n, originX: Rules.Half, originY: Rules.Half)
-  override fun act(self, n: Node, dt: Float) -> Node =
-    m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.OrbRadius, dt)
-    self.clock = self.clock + dt
-    self.vx = m.vx
-    self.vy = m.vy
-    Node(..n, x: m.x - Rules.Half, y: m.y - Rules.Half)
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
-    k := m.scaleX()
-    canvas.blendMode(Blend.Add)
-    canvas.drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * tint.a))
-    canvas.drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * tint.a))
-    canvas.blendMode(Blend.Normal)
-    frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
-    Node.drawSprite(canvas, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
-# A mine drifting about, turning `spin` radians per second (0 once the game is over).
-struct Mine(Actor, mut vx: Float, mut vy: Float, spin: Float, mut clock: Float, tex: Texture) =
-  fun create(sheet: Texture, id: Int, at: Motion, spin: Float) -> Node =
-    Mine.createAt(sheet, id, at, spin, 0.0)
-  fun createAt(sheet: Texture, id: Int, at: Motion, spin: Float, clock: Float) -> Node =
-    n := Node.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
-      Mine(vx: at.vx, vy: at.vy, spin: spin, clock: clock, tex: sheet))
-    Node(..n, originX: Rules.Half, originY: Rules.Half)
-  override fun act(self, n: Node, dt: Float) -> Node =
-    m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.MineRadius, dt)
-    self.clock = self.clock + dt
-    self.vx = m.vx
-    self.vy = m.vy
-    Node(..n, x: m.x - Rules.Half, y: m.y - Rules.Half, rotation: n.rotation + self.spin * dt)
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    frame := Float(frameOf(self.clock, 4, 4.0))
-    Node.drawSprite(canvas, m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
-# A background star that twinkles.
-struct Star(Actor, seed: Float, mut clock: Float) =
-  fun create(i: Int) -> Node =
-    r := 1.0 + Float(i % 3) * 0.5
-    Node.custom(Id.Star + i, Float({i * 7919} % 800) - r, Float({i * 104729} % 600) - r, r * 2.0, r * 2.0,
-      Star(seed: Float(i), clock: 0.0))
-  override fun act(self, n: Node, dt: Float) -> Node =
-    self.clock = self.clock + dt
-    n
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    twinkle := 0.25 + 0.2 * Math.sin(self.clock * 2.0 + self.seed)
-    r := n.width / 2.0
-    c := m.apply(Vec2(x: r, y: r))
-    canvas.drawCircle(c.x, c.y, r * m.scaleX(), Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle * tint.a))
-# --- reading and changing the tree ---
-# The child of `a` reached by `path` (not empty), borrowed from the tree.
-fun nodeAt(a: Node, path: Slice[Int], depth: Int) -> Node =
-  ks := kidsOf(a)
-  i := path.at(depth)
-  if depth + 1 >= path.length()
-    return ks.at(i)
-  nodeAt(ks.at(i), path, depth + 1)
-# The node with `id` below `root`, searched depth first, borrowed from the tree.
-fun find(root: Node, id: Int) -> Node =
-  path := root.findPath(id).unwrap()
-  nodeAt(root, path, 0)
-fun kidsOf(n: Node) -> Slice[Node] =
-  n.children().unwrap()
-fun setVisible(n: Node, v: Bool) -> Node =
-  Node(..n, visible: v)
-# The group `g` with `k` added as its last child.
-fun addKid(g: Node, k: Node) -> Node =
-  ks := kidsOf(g)
-  ks.push(k)
-  g
-fun actorClock(a: Actor) -> Float =
-  match a
-    Mine(_, _, _, clock, _) => clock
-    Orb(_, _, _, clock, _) => clock
-    Star(_, clock) => clock
-    _ => 0.0
-fun clockOf(n: Node) -> Float =
-  match n.kind
-    Custom(a) => actorClock(a)
-    _ => 0.0
-fun textOf(n: Node) -> Str =
-  match n.kind
-    Label(text, _) => text
-    _ => ""
-fun hudLabel(id: Int, text: Str, x: Float, y: Float, size: Float, c: Color) -> Node =
-  l := Node.label(id, text, x, y, size)
-  Node(..l, color: c)
-fun icon(sheet: Texture, i: Int) -> Node =
-  s := Node.sprite(Id.Icon + i, sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0)
-  Node(..s, kind: Sprite(tex: sheet, srcX: 0.0, srcY: 0.0, srcW: Rules.Cell, srcH: Rules.Cell))
-# The whole scene: backdrop, stars, mines, orbs, ship and HUD layers, in drawing order.
-# The layer groups are 0 x 0 so they never swallow a click; the HUD holds the
-# game-over overlay with its restart button.
-# The starting spots of the orbs and mines, and the generator to continue from.
-struct Spots(orbs: Slice[Motion], mines: Slice[Motion], rng: Random)
-fun startSpots(rng: Random, ship: ShipState) -> Spots =
-  orbs := Slice[Motion]()
-  mines := Slice[Motion]()
-  r := rng
-  for i := range Rules.OrbCount
-    sp := spawn(r, ship.x, ship.y, 120.0, 40.0)
-    r = sp.rng
-    orbs.push(sp.at)
-  for i := range mineCount(0)
-    sp := spawn(r, ship.x, ship.y, 220.0, 90.0)
-    r = sp.rng
-    mines.push(sp.at)
-  Spots(orbs: orbs, mines: mines, rng: r)
-fun buildRoot(spots: Spots, sheet: Texture, best: Int) -> Node =
-  ship := newShip()
-  stars := Slice[Node]()
-  for i := range 40
-    stars.push(Star.create(i))
-  mines := Slice[Node]()
-  orbs := Slice[Node]()
-  for i := range Rules.OrbCount
-    orbs.push(Orb.create(sheet, Float(i) * 0.1, Id.Orb + i, spots.orbs.at(i)))
-  for i := range mineCount(0)
-    mines.push(Mine.create(sheet, Id.Mine + i, spots.mines.at(i), 2.0))
-  b0 := Node.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
-  btn := Node(..b0, color: Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9), visible: false)
-  over := [
-    Panel.create(Id.OverlayPanel, 0.0, 230.0, Rules.ArenaW, 170.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
-    hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red),
-    hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White),
-    btn].toSlice()
-  o0 := Node.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
-  overlay := Node(..o0, visible: false)
-  hud := [
-    hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White),
-    hudLabel(Id.Best, "Best {best}", 16.0, 44.0, 20.0, Color.Yellow)].toSlice()
-  for i := range Rules.StartLives
-    hud.push(icon(sheet, i))
-  hud.push(overlay)
-  layers := [
-    Panel.create(Id.Backdrop, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)),
-    Node.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars),
-    Node.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines),
-    Node.group(Id.OrbLayer, 0.0, 0.0, 0.0, 0.0, orbs),
-    Ship.create(sheet, ship),
-    Node.group(Id.Hud, 0.0, 0.0, 0.0, 0.0, hud)].toSlice()
-  Node.group(Id.Root, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, layers)
-# --- the world ---
-# The host-facing shell: the current pure `Stage` plus the run's state. It is the
-# only thing that is replaced from frame to frame.
-struct World(
-  mut stage: Stage,
-  mut ship: ShipState,
-  mut rng: Random,
-  mut mines: Int,
-  mut score: Int,
-  mut best: Int,
-  mut lives: Int,
-  mut over: Bool,
-  mut clock: Float,
-  sheet: Texture)
-fun newWorld(seed: Int, sheet: Texture) -> World =
-  ship := newShip()
-  spots := startSpots(Random.seeded(seed), ship)
-  next := spots.rng
-  World(
-    stage: Stage.create(buildRoot(spots, sheet, 0)), ship: ship, rng: next, mines: mineCount(0), score: 0, best: 0,
-    lives: Rules.StartLives, over: false, clock: 0.0, sheet: sheet)
-fun modifyRoot(st: Stage, id: Int, f: fn(Node) -> Node) -> Stage =
-  match st
-    Stage(root, camera, captured, focus) => Stage(root: root.modify(id, f), camera: camera, captured: captured, focus: focus)
-fun withCamera(st: Stage, camera: Affine) -> Stage =
-  match st
-    Stage(root, _, captured, focus) => Stage(root: root, camera: camera, captured: captured, focus: focus)
-fun swap(w: World, id: Int, f: fn(Node) -> Node) =
-  w.stage = modifyRoot(w.stage, id, f)
-# Starts a fresh game, keeping the best score, the camera and the random stream.
-fun restart(w: World) =
-  w.best = w.best.max(w.score)
-  w.score = 0
-  w.lives = Rules.StartLives
-  w.over = false
-  w.ship = newShip()
-  w.mines = mineCount(0)
-  spots := startSpots(w.rng, w.ship)
-  next := spots.rng
-  w.rng = next
-  w.stage = Stage(root: buildRoot(spots, w.sheet, w.best), camera: w.stage.camera, captured: None, focus: None)
-# Copies the score, best score, lives and game-over panel into the HUD actors.
-fun syncHud(w: World) =
-  score := "Score {w.score}"
-  best := "Best {w.best.max(w.score)}"
-  swap(w, Id.Score, |a| hudLabel(Id.Score, score, 16.0, 12.0, 28.0, Color.White))
-  swap(w, Id.Best, |a| hudLabel(Id.Best, best, 16.0, 44.0, 20.0, Color.Yellow))
-  for i := range Rules.StartLives
-    shown := i < w.lives
-    swap(w, Id.Icon + i, |a| setVisible(a, shown))
-  over := w.over
-  swap(w, Id.Overlay, |a| setVisible(a, over))
-  swap(w, Id.Restart, |a| setVisible(a, over))
-# Stops every orb and mine: after game over they only animate.
-fun freeze(w: World) =
-  for i := range Rules.OrbCount
-    id := Id.Orb + i
-    phase := Float(i) * 0.1
-    sheet := w.sheet
-    swap(w, id, |a| orbKeepClock(sheet, phase, id, Motion(x: cx(a), y: cy(a), vx: 0.0, vy: 0.0), a))
-  for i := range w.mines
-    id := Id.Mine + i
-    sheet := w.sheet
-    swap(w, id, |a| stillMine(sheet, id, a))
-fun orbActor(sheet: Texture, phase: Float, id: Int, at: Motion) -> Node =
-  Orb.create(sheet, phase, id, at)
-# A new orb that carries on `old`'s animation clock, so a respawn or freeze never jumps a frame.
-fun orbKeepClock(sheet: Texture, phase: Float, id: Int, at: Motion, old: Node) -> Node =
-  Orb.createAt(sheet, phase, id, at, clockOf(old))
-fun mineActor(sheet: Texture, id: Int, at: Motion, spin: Float) -> Node =
-  Mine.create(sheet, id, at, spin)
-fun stillMine(sheet: Texture, id: Int, a: Node) -> Node =
-  m := Mine.createAt(sheet, id, Motion(x: cx(a), y: cy(a), vx: 0.0, vy: 0.0), 0.0, clockOf(a))
-  Node(..m, rotation: a.rotation)
-# Moves the ship node to the ship state; it blinks while it is hurt, and is hidden once the game is over.
-fun showShip(w: World) =
-  blink := w.ship.hurt > 0.0 && frameOf(w.clock, 2, 10.0) == 0
-  visible := !w.over && !blink
-  s := w.ship
-  swap(w, Id.Ship, |a| shipActor(a, s, visible))
-fun shipActor(a: Node, s: ShipState, visible: Bool) -> Node =
-  Node(..a, x: s.x - Rules.Half, y: s.y - Rules.Half, rotation: s.rotation, visible: visible)
-fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
-  Math.hypot(ax - bx, ay - by) < ra + rb
-# The stage after `inputs` and `dt`, appending the events it raised to `events`.
-fun frameInto(s: Stage, dt: Float, inputs: Slice[InputEvent], events: Slice[UiEvent]) -> Stage =
-  h := s.frame(dt, inputs)
-  for i := range h.events.length()
-    events.push(h.events.at(i))
-  h.intoStage()
-# One frame: the stage takes the pointer `inputs` and advances every actor by `dt`
-# (a click on the restart button restarts), then the rules look at the result. Once
-# the game is over the actors only animate. Returns true when it restarted.
-fun advance(w: World, ax: Float, ay: Float, dt: Float, inputs: Slice[InputEvent]) -> Bool =
-  w.clock = w.clock + dt
-  events := Slice[UiEvent]()
-  w.stage = frameInto(w.stage, dt, inputs, events)
-  for i := range events.length()
-    e := events.at(i)
-    if e.id == Id.Restart && e.kind == Click && w.over
-      restart(w)
-      return true
-  if w.over
-    return false
-  w.ship = shipStep(w.ship, ax, ay, dt)
-  ship := w.ship
-  changed := false
-  for i := range Rules.OrbCount
-    orb := find(w.stage.root, Id.Orb + i)
-    if overlaps(ship.x, ship.y, Rules.ShipRadius, cx(orb), cy(orb), Rules.OrbRadius)
-      w.score = w.score + Rules.OrbPoints
-      changed = true
-      sp := spawn(w.rng, ship.x, ship.y, 120.0, 40.0)
-      w.rng = sp.rng
-      at := sp.at
-      sheet := w.sheet
-      id := Id.Orb + i
-      phase := Float(i) * 0.1
-      swap(w, id, |a| orbKeepClock(sheet, phase, id, at, a))
-  while w.mines < mineCount(w.score)
-    sheet := w.sheet
-    id := Id.Mine + w.mines
-    sp := spawn(w.rng, ship.x, ship.y, 220.0, 90.0)
-    w.rng = sp.rng
-    at := sp.at
-    swap(w, Id.MineLayer, |g| addKid(g, Mine.create(sheet, id, at, 2.0)))
-    w.mines = w.mines + 1
-  for i := range w.mines
-    mine := find(w.stage.root, Id.Mine + i)
-    if w.ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, cx(mine), cy(mine), Rules.MineRadius)
-      w.lives = w.lives - 1
-      cur := w.ship
-      w.ship = ShipState(..cur, hurt: Rules.HurtTime)
-      changed = true
-      if w.lives <= 0
-        w.over = true
-        w.best = w.best.max(w.score)
-  if changed
-    syncHud(w)
-  if w.over
-    freeze(w)
-  showShip(w)
-  false
-# One simulation step without pointer input.
-fun step(w: World, ax: Float, ay: Float, dt: Float) -> Bool =
-  advance(w, ax, ay, dt, Slice[InputEvent]())
-# The camera that fits the arena into a screen of `sw` by `sh` pixels, centred.
-fun fitCamera(sw: Float, sh: Float) -> Affine =
-  zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
-  Affine(a: zoom, b: 0.0, c: 0.0, d: zoom, e: {sw - zoom * Rules.ArenaW} / 2.0, f: {sh - zoom * Rules.ArenaH} / 2.0)
-fun fit(w: World, sw: Float, sh: Float) =
-  w.stage = withCamera(w.stage, fitCamera(sw, sh))
-# --- host glue: input, sound, drawing ---
-fun musicVolume() -> Float =
-  0.3
-fun axis(negative: Bool, positive: Bool) -> Float =
-  if negative && !positive
-    -1.0
-  else if positive && !negative
-    1.0
-  else
-    0.0
-# Enter or R going down.
-fun isRestartKey(e: InputEvent) -> Bool = match e
-  KeyDown(k) => k == Key.Enter || k == Key.KeyR
-  _ => false
-# The host shell: the pure `World` plus the sounds. `update` reads the frame's inputs
-# from `self.input` (the only input read); the held keys steer the ship.
-struct PureGame(Game(engine), world: World, pickupSound: Sound, hitSound: Sound, overSound: Sound, musicSound: Sound) =
-  # Restarts the music loop from the top.
-  fun startMusic(self) =
-    self.audio.stop(self.musicSound)
-    self.audio.loop(self.musicSound, musicVolume())
-  override fun update(self, dt: Float) =
-    w := self.world
-    inputs := self.input.events()
-    for i := range inputs.length()
-      if w.over && isRestartKey(inputs.at(i))
-        restart(w)
-        self.startMusic()
-    left := self.input.isKeyDown(Key.Left) || self.input.isKeyDown(Key.KeyA)
-    right := self.input.isKeyDown(Key.Right) || self.input.isKeyDown(Key.KeyD)
-    up := self.input.isKeyDown(Key.Up) || self.input.isKeyDown(Key.KeyW)
-    down := self.input.isKeyDown(Key.Down) || self.input.isKeyDown(Key.KeyS)
-    score := w.score
-    lives := w.lives
-    restarted := advance(w, axis(left, right), axis(up, down), dt, inputs)
-    if restarted
-      self.startMusic()
-      return
-    if w.score > score
-      self.audio.play(self.pickupSound, 0.8)
-    if w.lives < lives
-      if w.over
-        self.audio.stop(self.musicSound)
-        self.audio.play(self.overSound, 1.0)
-      else
-        self.audio.play(self.hitSound, 1.0)
-  override fun draw(self) =
-    w := self.world
-    fit(w, self.canvas.width(), self.canvas.height())
-    self.canvas.clear(Color.rgb(0.04, 0.05, 0.1))
-    w.stage.draw(self.canvas)
-fun main(io: Io) -> Game =
-  e := Engine.create(io)
-  game := PureGame(
-    engine: e,
-    world: newWorld(io.randomSeed(), e.assets.texture("sprites.png")),
-    pickupSound: e.assets.sound("pickup.wav"),
-    hitSound: e.assets.sound("hit.wav"),
-    overSound: e.assets.sound("gameover.wav"),
-    musicSound: e.assets.sound("music.wav")
-  )
-  game.startMusic()
-  game
-# --- tests ---
-fun near(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.01
-fun placeOrb(w: World, i: Int, m: Motion) =
-  sheet := w.sheet
-  id := Id.Orb + i
-  swap(w, id, |a| orbActor(sheet, Float(i) * 0.1, id, m))
-fun placeMine(w: World, i: Int, m: Motion) =
-  sheet := w.sheet
-  id := Id.Mine + i
-  swap(w, id, |a| mineActor(sheet, id, m, 2.0))
-fun away() -> Motion =
-  Motion(x: 5000.0, y: 0.0, vx: 0.0, vy: 0.0)
-# A world with the orbs and mines moved out of the way.
-fun emptyWorld() -> World =
-  w := newWorld(7, Texture(id: -1))
-  for i := range Rules.OrbCount
-    placeOrb(w, i, away())
-  for i := range w.mines
-    placeMine(w, i, away())
-  w
-fun onShip(w: World) -> Motion =
-  Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0)
-fun forceOver(w: World) =
-  w.lives = 0
-  w.over = true
-  syncHud(w)
-test "steering accelerates and drag slows the ship"
-  s := shipStep(newShip(), 1.0, 0.0, 0.1)
-  assert s.vx > 0.0
-  assert s.x > Rules.ArenaW / 2.0
-  fast := s.vx
-  t := s
-  for i := range 30
-    t = shipStep(t, 0.0, 0.0, 0.1)
-  assert t.vx < fast / 4.0
-test "the ship stops at the arena walls"
-  s := ShipState(x: 20.0, y: 20.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
-  for i := range 20
-    s = shipStep(s, -1.0, -1.0, 0.1)
-  assert s.x == Rules.ShipRadius
-  assert s.y == Rules.ShipRadius
-  assert s.vx == 0.0
-test "shipStep leaves its input unchanged"
-  s := newShip()
-  _ := shipStep(s, 1.0, 1.0, 0.1)
-  assert s.vx == 0.0
-  assert s.x == Rules.ArenaW / 2.0
-test "drifters bounce off the walls"
-  b := driftOf(Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0), Rules.OrbRadius, 0.1)
-  assert b.vx == -100.0
-  assert b.x == Rules.ArenaW - 10.0
-  orb := Orb.create(Texture(id: -1), 0.0, Id.Orb, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0))
-  moved := orb.update(0.1)
-  assert near(cx(moved), Rules.ArenaW - 10.0)
-test "a mine spins as it drifts"
-  mine := Mine.create(Texture(id: -1), Id.Mine, Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0), 2.0)
-  next := mine.update(0.5)
-  assert near(next.rotation, 1.0)
-  assert near(cx(next), 405.0)
-test "the scene has a backdrop, stars, mines, orbs, ship and HUD layers"
-  w := newWorld(7, Texture(id: -1))
-  assert kidsOf(w.stage.root).length() == 6
-  assert kidsOf(kidsOf(w.stage.root).at(1)).length() == 40
-  assert kidsOf(kidsOf(w.stage.root).at(2)).length() == mineCount(0)
-  assert kidsOf(kidsOf(w.stage.root).at(3)).length() == Rules.OrbCount
-  assert kidsOf(w.stage.root).at(4).id == Id.Ship
-  assert kidsOf(w.stage.root).at(2).id == Id.MineLayer
-  assert kidsOf(w.stage.root).at(3).id == Id.OrbLayer
-  assert kidsOf(w.stage.root).at(5).id == Id.Hud
-test "collecting an orb scores and respawns it elsewhere, still in the orbs layer"
-  w := emptyWorld()
-  placeOrb(w, 0, onShip(w))
-  _ := step(w, 0.0, 0.0, 0.016)
-  orb := find(w.stage.root, Id.Orb)
-  assert w.score == Rules.OrbPoints
-  assert Math.hypot(cx(orb) - w.ship.x, cy(orb) - w.ship.y) >= 120.0
-  assert orb.x < 5000.0
-  assert kidsOf(find(w.stage.root, Id.OrbLayer)).length() == Rules.OrbCount
-  assert textOf(find(w.stage.root, Id.Score)) == "Score 10"
-test "a mine costs one life and makes the ship flash"
-  w := emptyWorld()
-  placeMine(w, 0, onShip(w))
-  _ := step(w, 0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-  assert w.ship.hurt > 0.0
-  assert !find(w.stage.root, Id.Icon + 2).visible
-  assert find(w.stage.root, Id.Icon + 1).visible
-  placeMine(w, 0, away())
-  hidden := 0
-  shown := 0
-  for i := range 100
-    _ := step(w, 0.0, 0.0, 0.016)
-    if find(w.stage.root, Id.Ship).visible
-      shown = shown + 1
-    else
-      hidden = hidden + 1
-  assert hidden > 0
-  assert shown > 0
-  assert w.ship.hurt == 0.0
-  assert find(w.stage.root, Id.Ship).visible
-  assert w.lives == Rules.StartLives - 1
-test "the ship is briefly safe after a hit"
-  w := emptyWorld()
-  placeMine(w, 0, onShip(w))
-  _ := step(w, 0.0, 0.0, 0.016)
-  _ := step(w, 0.0, 0.0, 0.016)
-  assert w.lives == Rules.StartLives - 1
-test "the game ends at zero lives and then ignores steps"
-  w := emptyWorld()
-  w.lives = 1
-  w.score = 40
-  placeMine(w, 0, onShip(w))
-  _ := step(w, 0.0, 0.0, 0.016)
-  assert w.over
-  assert w.lives == 0
-  assert w.best == 40
-  assert find(w.stage.root, Id.Overlay).visible
-  assert !find(w.stage.root, Id.Ship).visible
-  x := w.ship.x
-  _ := step(w, 1.0, 0.0, 0.5)
-  assert w.ship.x == x
-test "after game over nothing moves but the animations keep running"
-  w := emptyWorld()
-  w.lives = 1
-  placeMine(w, 0, Motion(x: w.ship.x, y: w.ship.y, vx: 10.0, vy: 0.0))
-  _ := step(w, 0.0, 0.0, 0.016)
-  assert w.over
-  mine := find(w.stage.root, Id.Mine)
-  x := mine.x
-  rot := mine.rotation
-  clock := clockOf(mine)
-  orbClock := clockOf(find(w.stage.root, Id.Orb))
-  for i := range 10
-    _ := step(w, 1.0, 0.0, 0.1)
-  after := find(w.stage.root, Id.Mine)
-  assert after.x == x
-  assert after.rotation == rot
-  assert w.ship.x == Rules.ArenaW / 2.0
-  assert !find(w.stage.root, Id.Ship).visible
-  assert clockOf(after) > clock + 0.9
-  assert clockOf(find(w.stage.root, Id.Orb)) > orbClock + 0.9
-  assert clockOf(find(w.stage.root, Id.Star)) > 0.9
-  assert w.score == 0
-test "restart resets the run and keeps the best score"
-  w := emptyWorld()
-  w.score = 90
-  forceOver(w)
-  restart(w)
-  assert !w.over
-  assert !find(w.stage.root, Id.Overlay).visible
-  assert find(w.stage.root, Id.Ship).visible
-  assert w.score == 0
-  assert w.best == 90
-  assert w.lives == Rules.StartLives
-  assert w.ship.x == Rules.ArenaW / 2.0
-  assert w.mines == mineCount(0)
-  assert textOf(find(w.stage.root, Id.Best)) == "Best 90"
-test "more mines appear as the score grows and restart removes them from the layer"
-  assert mineCount(0) == 3
-  assert mineCount(100) == 5
-  assert mineCount(10000) == 8
-  w := emptyWorld()
-  w.score = 100
-  _ := step(w, 0.0, 0.0, 0.016)
-  assert w.mines == 5
-  assert kidsOf(find(w.stage.root, Id.MineLayer)).length() == 5
-  restart(w)
-  assert w.mines == 3
-  assert kidsOf(find(w.stage.root, Id.MineLayer)).length() == 3
-test "the same seed plays out the same way"
-  a := newWorld(11, Texture(id: -1))
-  b := newWorld(11, Texture(id: -1))
-  for i := range 120
-    _ := step(a, 1.0, -1.0, 0.016)
-    _ := step(b, 1.0, -1.0, 0.016)
-  assert a.ship.x == b.ship.x
-  assert a.score == b.score
-  assert find(a.stage.root, Id.Mine).x == find(b.stage.root, Id.Mine).x
-  assert newWorld(12, Texture(id: -1)).stage.root.id == Id.Root
-  assert find(newWorld(12, Texture(id: -1)).stage.root, Id.Orb).x != find(a.stage.root, Id.Orb).x
-test "fit centres the arena on the screen"
-  w := newWorld(7, Texture(id: -1))
-  fit(w, 1600.0, 600.0)
-  assert near(w.stage.camera.a, 1.0)
-  assert near(w.stage.camera.e, 400.0)
-  assert near(w.stage.camera.f, 0.0)
-test "animation frames cycle"
-  assert frameOf(0.0, 4, 8.0) == 0
-  assert frameOf(0.13, 4, 8.0) == 1
-  assert frameOf(0.5, 4, 8.0) == 0
-  assert axis(true, false) == -1.0
-  assert axis(true, true) == 0.0
-test "restart_button_hidden_while_playing"
-  w := newWorld(7, Texture(id: -1))
-  assert !find(w.stage.root, Id.Restart).visible
-test "restart_button_click_restarts"
-  w := emptyWorld()
-  w.score = 30
-  forceOver(w)
-  assert find(w.stage.root, Id.Restart).visible
-  down := PointerDown(x: 400.0, y: 364.0)
-  up := PointerUp(x: 400.0, y: 364.0)
-  taps := Slice[InputEvent]()
-  taps.push(down)
-  taps.push(up)
-  restarted := advance(w, 0.0, 0.0, 0.016, taps)
-  assert restarted
-  assert w.lives == Rules.StartLives
-  assert w.score == 0
-  assert !w.over
-  assert !find(w.stage.root, Id.Restart).visible
-test "a click on the restart button while playing does nothing"
-  w := emptyWorld()
-  w.score = 30
-  taps := Slice[InputEvent]()
-  taps.push(PointerDown(x: 400.0, y: 364.0))
-  taps.push(PointerUp(x: 400.0, y: 364.0))
-  restarted := advance(w, 0.0, 0.0, 0.016, taps)
-  assert !restarted
-  assert w.score == 30
-test "world_update_is_pure"
-  w := emptyWorld()
-  x := find(w.stage.root, Id.Ship).x
-  _ := step(w, 1.0, 0.0, 0.1)
-  assert find(w.stage.root, Id.Ship).x > x
-test "freezing at game over keeps the orb and mine animation clocks"
-  w := emptyWorld()
-  for i := range 5
-    _ := step(w, 0.0, 0.0, 0.1)
-  orbClock := clockOf(find(w.stage.root, Id.Orb))
-  mineClock := clockOf(find(w.stage.root, Id.Mine))
-  assert orbClock > 0.4
-  w.lives = 1
-  placeMine(w, 1, onShip(w))
-  _ := step(w, 0.0, 0.0, 0.1)
-  assert w.over
-  assert clockOf(find(w.stage.root, Id.Orb)) > orbClock
-  assert clockOf(find(w.stage.root, Id.Mine)) > mineClock

std/game/{functional/Anim.plum → Anim.plum} RENAMED Viewed

File without changes

std/game/Game.plum CHANGED Viewed

@@ -6,17 +6,14 @@ import std/Str
 import std/game/Vec2
 import std/game/Color
 import std/Io
-import std/Map
-import std/Option
-import std/game/Input
-# The host API of a game: drawing, textures, sounds, files and input, all
+# The host API of a game: drawing, textures, sounds, files and input, all provided by
-# provided by the game host (`plum run`). A game is a struct embedding `Game`; the
+# the game host (`plum run`) as methods of `Io` (see std/Io). A game is any type that
+# `main(io: Io)` returns and that has `update(self, io: Io, dt: Float) -> Self` and
-# parts below (`Canvas`, `Audio`, `Assets`, `Clock`, `Input`) are what it draws, plays,
+# `draw(self, io: Io)`; the host calls `update` then `draw` every frame, and the state
-# loads and reads, so game code never needs `io`. Texture and sound handles are -1 on
+# `update` returns is the next frame's `self`. This file holds the key codes and the
-# failure. File, texture and sound paths are relative to the asset root; a path
+# `Texture` and `Sound` handles. A path that escapes the asset root fails like a
-# that escapes it fails like a missing file. Coordinates are world units once
+# missing file. Coordinates are world units once `io.setCamera` is set.
-# `setCamera` is set.
 # Key codes (GLFW numbering) for `isKeyDown` / `isKeyPressed`.
 # Letter keys are `KeyA`..`KeyZ` (a constant name needs two characters).
@@ -83,203 +80,76 @@ primitive Mouse =
   Right = 1
   Middle = 2
-# A texture handle; the id is the host's. Made by `Assets.texture` or `Canvas.createTexture`.
+# A texture handle; the id is the host's. A handle of -1 is no texture.
-struct Texture(id: Int)
+struct Texture(id: Int) =
-# A sound handle; the id is the host's. Made by `Assets.sound`.
-struct Sound(id: Int)
-# Name to host id, remembered. No host calls: `Assets` loads on a miss and keeps the id.
-struct NameIds(mut ids: Map[Str, Int]) =
-  fun create() -> NameIds =
-    NameIds(ids: Map.empty())
-  fun lookup(self, name: Str) -> Option[Int] =
-    self.ids.get(name)
-  fun remember(self, name: Str, id: Int) =
-    self.ids.set(name, id)
-fun missingAsset(kind: Str, name: Str) -> Str =
-  "missing {kind}: {name}"
-# Files, textures and sounds by name, relative to the asset root. A texture or sound is
+  # Loads an image relative to the asset root; crashes naming the file if it is missing.
-# loaded the first time its name is asked for and the same handle comes back after;
-# a missing file crashes with its name.
-struct Assets(io: Io, textures: NameIds, sounds: NameIds) =
-  fun create(io: Io) -> Assets =
-    Assets(io: io, textures: NameIds.create(), sounds: NameIds.create())
-  fun texture(self, name: Str) -> Texture =
+  fun load(io: Io, name: Str) -> Texture =
-    if Some(id) := self.textures.lookup(name)
-      return Texture(id: id)
-    id := self.io.textureLoad(name)
+    id := io.textureLoad(name)
     if id < 0
       crash missingAsset("texture", name)
-    self.textures.remember(name, id)
     Texture(id: id)
-  fun sound(self, name: Str) -> Sound =
-    if Some(id) := self.sounds.lookup(name)
-      return Sound(id: id)
-    id := self.io.soundLoad(name)
-    if id < 0
-      crash missingAsset("sound", name)
-    self.sounds.remember(name, id)
-    Sound(id: id)
-  fun exists(self, name: Str) -> Bool =
-    self.io.fileExists(name)
-  # The whole file as text; crashes naming the file if it is missing.
-  fun file(self, name: Str) -> Str =
-    if !self.io.fileExists(name)
-      crash missingAsset("file", name)
-    self.io.fileLoad(name)
-# Drawing. Coordinates are world units once `setCamera` is set. Draws go to the
-# screen unless `renderTarget` selects a texture made by `createTexture`.
-struct Canvas(io: Io) =
-  fun width(self) -> Float = self.io.screenWidth()
-  fun height(self) -> Float = self.io.screenHeight()
-  fun clear(self, c: Color) =
-    self.io.clear(c)
-  fun drawRect(self, x: Float, y: Float, w: Float, h: Float, c: Color) =
-    self.io.drawRect(x, y, w, h, c)
-  fun drawCircle(self, x: Float, y: Float, r: Float, c: Color) =
-    self.io.drawCircle(x, y, r, c)
-  fun drawLine(self, x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color) =
-    self.io.drawLine(x1, y1, x2, y2, thickness, c)
-  fun drawText(self, s: Str, x: Float, y: Float, size: Float, c: Color) =
-    self.io.drawText(s, x, y, size, c)
-  fun setCamera(self, x: Float, y: Float, scale: Float) =
-    self.io.setCamera(x, y, scale)
-  fun resetCamera(self) =
-    self.io.resetCamera()
-  # The texture at its natural size, top-left at (x, y).
-  fun drawTexture(self, t: Texture, x: Float, y: Float, tint: Color = Color.White) =
-    self.io.drawTexture(t.id, x, y, tint)
-  # The source rect (sx, sy, sw, sh) in texture pixels into the dest rect (x, y, w, h),
-  # rotated `rotation` radians clockwise about the dest centre.
-  fun drawTextureEx(self, t: Texture, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color) =
-    self.io.drawTextureEx(t.id, sx, sy, sw, sh, x, y, w, h, rotation, flipX, tint)
-  fun textureWidth(self, t: Texture) -> Int = self.io.textureWidth(t.id)
-  fun textureHeight(self, t: Texture) -> Int = self.io.textureHeight(t.id)
-  # Linear (true) or nearest (false, the default) filtering.
-  fun setSmooth(self, t: Texture, smooth: Bool) =
-    self.io.textureSetSmooth(t.id, smooth)
   # A blank transparent texture to draw into with `renderTarget`; crashes if a side is
   # below 1 or above 8192.
-  fun createTexture(self, w: Int, h: Int) -> Texture =
+  fun create(io: Io, w: Int, h: Int) -> Texture =
-    id := self.io.textureCreate(w, h)
+    id := io.textureCreate(w, h)
     if id < 0
       crash "cannot create a {w}x{h} texture"
     Texture(id: id)
-  # Sends the following draws into `t`; `screenTarget` goes back to the screen. Each
-  # target has its own camera, which starts as its pixels.
-  fun renderTarget(self, t: Texture) =
-    self.io.renderTarget(t.id)
-  fun screenTarget(self) =
-    self.io.renderTarget(-1)
-  # A `Blend` constant for the following draws; every frame starts with `Blend.Normal`.
-  fun blendMode(self, m: Int) =
-    self.io.blendMode(m)
-# Sound. Volume is 0..1.
-struct Audio(io: Io) =
-  fun play(self, s: Sound, volume: Float = 1.0) =
+  fun width(self, io: Io) -> Int = io.textureWidth(self.id)
-    self.io.soundPlay(s.id, volume)
-  fun loop(self, s: Sound, volume: Float = 1.0) =
+  fun height(self, io: Io) -> Int = io.textureHeight(self.id)
-    self.io.soundLoop(s.id, volume)
-  fun stop(self, s: Sound) =
+  # Linear (true) or nearest (false, the default) filtering.
-    self.io.soundStop(s.id)
-  fun volume(self, s: Sound, volume: Float) =
+  fun setSmooth(self, io: Io, smooth: Bool) =
-    self.io.soundSetVolume(s.id, volume)
+    io.textureSetSmooth(self.id, smooth)
-# Time: the seconds run so far, the frame count, and the last frame's length. The
-# host export calls `tick` once per frame before `update`.
-struct Clock(mut time: Float, mut frame: Int, mut dt: Float) =
-  fun create() -> Clock =
-    Clock(time: 0.0, frame: 0, dt: 0.0)
-  fun tick(self, dt: Float) =
-    self.time = self.time + dt
-    self.frame = self.frame + 1
-    self.dt = dt
+  # The texture at its natural size, top-left at (x, y).
+  fun draw(self, io: Io, x: Float, y: Float, tint: Color = Color.White) =
+    io.drawTexture(self.id, x, y, tint)
+  # Sends the following draws into this texture; `Texture.screen` goes back to the screen.
-# Everything a game reads and writes, made once from the host `Io`.
+  # Each target has its own camera, which starts as its pixels.
+  fun renderTarget(self, io: Io) =
+    io.renderTarget(self.id)
+  fun screen(io: Io) =
+    io.renderTarget(-1)
+# A sound handle; the id is the host's. Volume is 0..1.
+struct Sound(id: Int) =
-struct Engine(input: Input, canvas: Canvas, audio: Audio, assets: Assets, clock: Clock) =
+  # Loads a sound relative to the asset root; crashes naming the file if it is missing.
-  fun create(io: Io) -> Engine =
+  fun load(io: Io, name: Str) -> Sound =
+    id := io.soundLoad(name)
+    if id < 0
-    Engine(input: Input.create(io), canvas: Canvas(io: io), audio: Audio(io: io), assets: Assets.create(io), clock: Clock.create())
+      crash missingAsset("sound", name)
+    Sound(id: id)
-  # What the export does at the start of each frame: tick the clock, poll the input once.
-  fun beginFrame(self, dt: Float) =
+  fun play(self, io: Io, volume: Float = 1.0) =
-    self.clock.tick(dt)
-    self.input.beginFrame()
+    io.soundPlay(self.id, volume)
-# A game is a struct embedding `Game` with `update` and `draw`. The parts are
-# properties: `self.input`, `self.canvas`, `self.audio`, `self.assets`, `self.clock`.
-struct Game(engine: Engine) =
-  fun init(self) =
-    self.input: Input = self.engine.input
+  fun loop(self, io: Io, volume: Float = 1.0) =
-    self.canvas: Canvas = self.engine.canvas
-    self.audio: Audio = self.engine.audio
+    io.soundLoop(self.id, volume)
-    self.assets: Assets = self.engine.assets
-    self.clock: Clock = self.engine.clock
-  abstract fun update(self, dt: Float)
+  fun stop(self, io: Io) =
-  abstract fun draw(self)
+    io.soundStop(self.id)
-# The frame entry points the compiler exports as `update(state, dt)` and `draw(state)`
-# when `main` returns a `Game`: the clock ticks and the input is polled once, then the
-# game's own `update` runs. Not exported (and never compiled) for any other program.
-fun gameUpdate(g: Game, dt: Float) =
+  fun setVolume(self, io: Io, volume: Float) =
-  g.engine.beginFrame(dt)
+    io.soundSetVolume(self.id, volume)
-  g.update(dt)
+fun missingAsset(kind: Str, name: Str) -> Str =
-fun gameDraw(g: Game) =
+  "missing {kind}: {name}"
-  g.draw()
+# The whole file as text, relative to the asset root; crashes naming the file if it is missing.
-test "assets remember a name once"
+fun loadFile(io: Io, name: Str) -> Str =
-  ids := NameIds.create()
+  if !io.fileExists(name)
-  assert ids.lookup("a.png").isNone()
-  ids.remember("a.png", 7)
+    crash missingAsset("file", name)
-  assert ids.lookup("a.png").unwrapOr(-1) == 7
-  assert ids.lookup("b.png").isNone()
-  ids.remember("b.png", 8)
+  io.fileLoad(name)
-  assert ids.lookup("a.png").unwrapOr(-1) == 7
 test "a missing asset message names the file"
   assert missingAsset("texture", "ship.png") == "missing texture: ship.png"
-test "clock ticks time and frames"
-  c := Clock.create()
-  c.tick(0.5)
-  c.tick(0.25)
-  assert c.frame == 2
-  assert c.time == 0.75
-  assert c.dt == 0.25
 test "key and mouse constants use GLFW numbering"
   assert Key.KeyW == 87
   assert Key.Left == 263

std/game/Input.plum CHANGED Viewed

@@ -135,85 +135,62 @@ struct Held(mouse: Bool, keys: Slice[Int]) =
 # A poll's inputs and what is held after them (pass it to the next poll).
 struct Polled(inputs: Slice[InputEvent], held: Held)
-# A frame's input state, with no host calls: `accept` stores what one poll saw.
-# `Input.beginFrame` feeds it once per frame, so every read in that frame agrees.
-struct InputState(mut held: Held, mut events: Slice[InputEvent], mut pos: Vec2, mut wheel: Float) =
-  fun create() -> InputState =
-    InputState(held: Held.none(), events: Slice[InputEvent](), pos: Vec2(x: 0.0, y: 0.0), wheel: 0.0)
-  fun accept(self, p: Polled, pos: Vec2, wheel: Float) =
-    self.held = p.held
-    self.events = p.inputs
-    self.pos = pos
-    self.wheel = wheel
-  # True if this frame's events hold a key-down for `key`.
-  fun pressed(self, key: Int) -> Bool =
-    for i := range self.events.length()
-      if self.events.at(i).isKeyDownOf(key)
-        return true
-    false
-  fun pointerPressed(self) -> Bool =
-    for i := range self.events.length()
-      if self.events.at(i).isPointerDown()
-        return true
-    false
-  fun pointerReleased(self) -> Bool =
-    for i := range self.events.length()
-      if self.events.at(i).isPointerUp()
-        return true
-    false
 # The mouse or a single touch this frame (the bridge reports touch as the mouse):
 # its position in screen pixels, whether it is down, and whether it went down or
 # up this frame.
 struct Pointer(pos: Vec2, down: Bool, pressed: Bool, released: Bool)
-# The player's input, read once per frame. The host export calls `beginFrame` before
+# The player's input for one frame. A game holds one and calls `poll` at the start of
+# `update`: `self.input.poll(io)` reads the host once and returns the input of this frame,
-# `update`; `events()`, `isKeyDown` and the pointer reads then agree for the whole
+# so `events()`, `isKeyDown` and the pointer reads agree for the whole frame however
-# frame, however often they are called.
+# often they are called. `poll` is the only host read.
-struct Input(io: Io, state: InputState) =
+struct Input(held: Held, events: Slice[InputEvent], pos: Vec2, wheel: Float) =
-  fun create(io: Io) -> Input =
+  fun create() -> Input =
-    Input(io: io, state: InputState.create())
+    Input(held: Held.none(), events: Slice[InputEvent](), pos: Vec2(x: 0.0, y: 0.0), wheel: 0.0)
-  # Polls the host once and stores the result for this frame.
+  # The input of this frame: the host polled once and compared with what was held before.
-  fun beginFrame(self) =
+  fun poll(self, io: Io) -> Input =
-    p := InputEvent.poll(self.io, self.state.held)
+    p := InputEvent.poll(io, self.held)
-    self.state.accept(p, self.io.mousePos(), self.io.mouseWheel())
+    Input(held: p.held, events: p.inputs, pos: io.mousePos(), wheel: io.mouseWheel())
-  # This frame's inputs, as `InputEvent.poll` builds them. The same slice every call.
-  fun events(self) -> Slice[InputEvent] =
-    self.state.events
   # Held at the start of this frame (a `Key` code).
   fun isKeyDown(self, key: Int) -> Bool =
-    self.state.held.isDown(key)
+    self.held.isDown(key)
   # Went down this frame.
   fun isKeyPressed(self, key: Int) -> Bool =
+    for i := range self.events.length()
-    self.state.pressed(key)
+      if self.events.at(i).isKeyDownOf(key)
+        return true
+    false
-  # A `Mouse` button; the left button is the frame's pointer state.
+  # The left mouse button, or a touch.
-  fun isMouseDown(self, button: Int = Mouse.Left) -> Bool =
+  fun isMouseDown(self) -> Bool =
-    if button == Mouse.Left
-      return self.state.held.mouse
+    self.held.mouse
-    self.io.isMouseDown(button)
-  fun isMousePressed(self, button: Int = Mouse.Left) -> Bool =
+  fun isMousePressed(self) -> Bool =
-    if button == Mouse.Left
-      return self.state.pointerPressed()
+    self.pointerPressed()
-    self.io.isMousePressed(button)
   fun mousePos(self) -> Vec2 =
-    self.state.pos
+    self.pos
   fun mouseWheel(self) -> Float =
-    self.state.wheel
+    self.wheel
   fun pointer(self) -> Pointer =
-    Pointer(pos: self.state.pos, down: self.state.held.mouse, pressed: self.state.pointerPressed(), released: self.state.pointerReleased())
+    Pointer(pos: self.pos, down: self.held.mouse, pressed: self.pointerPressed(), released: self.pointerReleased())
+  fun pointerPressed(self) -> Bool =
+    for i := range self.events.length()
+      if self.events.at(i).isPointerDown()
+        return true
+    false
+  fun pointerReleased(self) -> Bool =
+    for i := range self.events.length()
+      if self.events.at(i).isPointerUp()
+        return true
+    false
 # What happened to a UI element: pressed on it, released after a press on it,
 # clicked (pressed and released on it), or the pointer entered or left it.
@@ -265,24 +242,17 @@ test "through_moves_pointers_only"
   assert !KeyDown(key: 5).isPointer()
   assert PointerMove(x: 0.0, y: 0.0).isPointer()
-test "input state agrees for the whole frame"
+test "input agrees for the whole frame"
-  st := InputState.create()
+  held := Held(mouse: true, keys: [Key.KeyA].toSlice())
-  p := Polled(inputs: [PointerDown(x: 3.0, y: 4.0), KeyDown(key: Key.KeyA)].toSlice(), held: Held(mouse: true, keys: [Key.KeyA].toSlice()))
+  st := Input(held: held, events: [PointerDown(x: 3.0, y: 4.0), KeyDown(key: Key.KeyA)].toSlice(), pos: Vec2(x: 3.0, y: 4.0), wheel: 1.5)
-  st.accept(p, Vec2(x: 3.0, y: 4.0), 1.5)
   assert st.events.length() == 2
   assert st.events.length() == 2
-  assert st.pressed(Key.KeyA)
+  assert st.isKeyPressed(Key.KeyA)
-  assert !st.pressed(Key.KeyB)
+  assert !st.isKeyPressed(Key.KeyB)
+  assert st.isKeyDown(Key.KeyA)
   assert st.pointerPressed()
   assert !st.pointerReleased()
-  assert st.held.mouse
+  assert st.isMouseDown()
-  assert st.wheel == 1.5
+  assert st.mouseWheel() == 1.5
-  assert st.pos.x == 3.0
+  assert st.mousePos().x == 3.0
-test "a new frame replaces the last frame's events"
-  st := InputState.create()
-  st.accept(Polled(inputs: [PointerDown(x: 0.0, y: 0.0)].toSlice(), held: Held(mouse: true, keys: Slice[Int]())), Vec2(x: 0.0, y: 0.0), 0.0)
-  st.accept(Polled(inputs: [PointerUp(x: 0.0, y: 0.0)].toSlice(), held: Held.none()), Vec2(x: 0.0, y: 0.0), 0.0)
-  assert !st.pointerPressed()
+  assert st.pointer().pressed
-  assert st.pointerReleased()
-  assert !st.held.mouse

std/game/{functional/FunctionalScene.plum → Scene.plum} RENAMED Viewed

@@ -10,6 +10,7 @@ import std/game/Vec2
 import std/game/Color
 import std/game/Affine
 import std/game/Game
+import std/Io
 import std/Option
 # The functional scene: a `SceneNode[M]` is plain data (shapes, sprites, text, groups
@@ -83,7 +84,7 @@ struct Rect(x: Float, y: Float, w: Float, h: Float) =
 # A Sprite is a texture region `w` by `h` with its top-left at (x, y).
 # A Filter draws its child into `target`, then composites it with the effect.
-# `target` is a texture the game creates ONCE at load with `textureCreate`; draw
+# `target` is a texture the game creates ONCE at load with `Texture.create`; draw
 # creates nothing, so a view does not leak a texture per frame. The size of
 # `target` bounds what the filter can show: child pixels beyond it are cut off.
 # A negative target draws nothing.
@@ -98,8 +99,8 @@ enum SceneNode[M] =
   | Clickable(id: Int, msg: M, child: SceneNode[M])
   # Draws the scene to the current target.
-  fun draw(self, canvas: Canvas) =
+  fun draw(self, io: Io) =
-    self.drawWith(canvas, Affine.Identity, 1.0, Texture(id: 0 - 1))
+    self.drawWith(io, Affine.Identity, 1.0, Texture(id: 0 - 1))
   # The bounding box of the scene in its own space (all zero when empty).
   fun bounds(self) -> Rect =
@@ -135,53 +136,53 @@ enum SceneNode[M] =
   # --- drawing ---
   # Draws under the parent matrix `m` and alpha into `target` (negative: the screen).
-  fun drawWith(self, canvas: Canvas, m: Affine, alpha: Float, target: Texture) = match self
+  fun drawWith(self, io: Io, m: Affine, alpha: Float, target: Texture) = match self
     RectShape(x, y, w, h, color) =>
       sx := w * m.scaleX()
       sy := h * m.scaleY()
       c := m.apply(Vec2(x: x + w / 2.0, y: y + h / 2.0))
-      canvas.drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(color.a * alpha))
+      io.drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(color.a * alpha))
     CircleShape(cx, cy, r, ccolor) =>
       cc := m.apply(Vec2(x: cx, y: cy))
-      canvas.drawCircle(cc.x, cc.y, r * m.scaleX(), ccolor.withAlpha(ccolor.a * alpha))
+      io.drawCircle(cc.x, cc.y, r * m.scaleX(), ccolor.withAlpha(ccolor.a * alpha))
     LineShape(x1, y1, x2, y2, th, lcolor) =>
       p := m.apply(Vec2(x: x1, y: y1))
       q := m.apply(Vec2(x: x2, y: y2))
-      canvas.drawLine(p.x, p.y, q.x, q.y, th * m.scaleX(), lcolor.withAlpha(lcolor.a * alpha))
+      io.drawLine(p.x, p.y, q.x, q.y, th * m.scaleX(), lcolor.withAlpha(lcolor.a * alpha))
     Sprite(tex, sx0, sy0, sw0, sh0, srcX, srcY, srcW, srcH, tint) =>
       sw := sw0 * m.scaleX()
       sh := sh0 * m.scaleY()
       sc := m.apply(Vec2(x: sx0 + sw0 / 2.0, y: sy0 + sh0 / 2.0))
-      canvas.drawTextureEx(tex, srcX, srcY, srcW, srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, tint.withAlpha(tint.a * alpha))
+      io.drawTextureEx(tex.id, srcX, srcY, srcW, srcH, sc.x - sw / 2.0, sc.y - sh / 2.0, sw, sh, m.rotation(), false, tint.withAlpha(tint.a * alpha))
     Text(txt, tx, ty, size, tcolor) =>
       tp := m.apply(Vec2(x: tx, y: ty))
-      canvas.drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
+      io.drawText(txt, tp.x, tp.y, size * m.scaleY(), tcolor.withAlpha(tcolor.a * alpha))
-    Group(tr, kids) => SceneNode.drawKids(canvas, kids, m.mul(tr.matrix()), alpha, target)
+    Group(tr, kids) => SceneNode.drawKids(io, kids, m.mul(tr.matrix()), alpha, target)
-    Filter(effect, child, tex) => SceneNode.drawFiltered(canvas, effect, child, tex, m, alpha, target)
+    Filter(effect, child, tex) => SceneNode.drawFiltered(io, effect, child, tex, m, alpha, target)
-    Clickable(_, _, child) => child.drawWith(canvas, m, alpha, target)
+    Clickable(_, _, child) => child.drawWith(io, m, alpha, target)
-  fun drawKids(canvas: Canvas, kids: List[SceneNode[M]], m: Affine, alpha: Float, target: Texture) = match kids
+  fun drawKids(io: Io, kids: List[SceneNode[M]], m: Affine, alpha: Float, target: Texture) = match kids
     Nil => 0
     Cons(head, tail) =>
-      head.drawWith(canvas, m, alpha, target)
+      head.drawWith(io, m, alpha, target)
-      SceneNode.drawKids(canvas, tail, m, alpha, target)
+      SceneNode.drawKids(io, tail, m, alpha, target)
-  fun drawFiltered(canvas: Canvas, effect: Effect, child: SceneNode[M], tex: Texture, m: Affine, alpha: Float, target: Texture) = match effect
+  fun drawFiltered(io: Io, effect: Effect, child: SceneNode[M], tex: Texture, m: Affine, alpha: Float, target: Texture) = match effect
     BlendFx(mode) =>
-      canvas.blendMode(mode)
+      io.blendMode(mode)
-      child.drawWith(canvas, m, alpha, target)
+      child.drawWith(io, m, alpha, target)
-      canvas.blendMode(Blend.Normal)
+      io.blendMode(Blend.Normal)
     _ =>
       if Some(b) := child.boundsWith(m)
         if tex.id >= 0
-          w := {Int(b.w) + 1}.min(canvas.textureWidth(tex))
+          w := {Int(b.w) + 1}.min(io.textureWidth(tex.id))
-          h := {Int(b.h) + 1}.min(canvas.textureHeight(tex))
+          h := {Int(b.h) + 1}.min(io.textureHeight(tex.id))
-          canvas.renderTarget(tex)
+          io.renderTarget(tex.id)
-          canvas.clear(Color.Transparent)
+          io.clear(Color.Transparent)
           shift := Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: 0.0 - b.x, f: 0.0 - b.y)
-          child.drawWith(canvas, shift.mul(m), 1.0, tex)
+          child.drawWith(io, shift.mul(m), 1.0, tex)
-          canvas.renderTarget(target)
+          io.renderTarget(target.id)
-          canvas.drawTextureEx(tex, 0.0, 0.0, Float(w), Float(h), b.x, b.y, Float(w), Float(h), 0.0, false, effect.tint(alpha))
+          io.drawTextureEx(tex.id, 0.0, 0.0, Float(w), Float(h), b.x, b.y, Float(w), Float(h), 0.0, false, effect.tint(alpha))
   # --- bounds ---

std/game/{functional/Ui.plum → Ui.plum} RENAMED Viewed

@@ -7,7 +7,7 @@ import std/Slice
 import std/List
 import std/Option
 import std/game/Color
-import std/game/functional/FunctionalScene
+import std/game/Scene
 import std/game/Input
 # A pure UI layer for the functional scene style. `Ui.step` takes the previous
@@ -15,7 +15,7 @@ import std/game/Input
 # the current view) and returns the new state plus the UiEvents it raised.
 # `Ui.messages` turns the Clicks among them into the game's own messages, read from
 # the `Clickable` nodes of that view. Same
-# button rules as PureScene: Down captures the pressed id; while captured only
+# button rules as the old pure scene: Down captures the pressed id; while captured only
 # that id gets Enter/Exit; Up releases (Click only when still over it).
 struct UiState(x: Float, y: Float, down: Bool, hot: Option[Int], captured: Option[Int])

std/game/imperative/Scene.plum DELETED Viewed

@@ -1,851 +0,0 @@
-module std
-import std/Int
-import std/Float
-import std/Str
-import std/Slice
-import std/Option
-import std/Math
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/game/Input
-import std/List
-# A Scene2D-like scene graph: a tree of actors under a `Stage`. `Actor` is a base
-# struct; every kind of actor is a struct that embeds it FIRST, which makes it a
-# subtype of `Actor` (`Group`, `Sprite`, `Rect`, `Circle`, `Text` here, your own
-# `struct Walker(Actor, speed: Float)` in a game). An `Actor` slot holds any of them.
-# An actor has a position, size, origin (the pivot of its rotation and scale),
-# scale, rotation (radians, clockwise), colour, visibility and children. Children
-# are placed in their parent's coordinates, so moving, turning or scaling a group
-# moves everything in it. Colour alpha multiplies down the tree and an invisible
-# actor hides its whole subtree.
-#
-# A struct overrides the default methods `act(dt)` (its behaviour), `draw(m, alpha)`
-# (what it paints, with its stage transform `m`) and `hit(p)` (whether a point in
-# its own coordinates is on it). The default `act` runs the children's `act`; an
-# override that has children calls `self.actChildren(dt)` itself.
-#
-#   stage := Stage.create()
-#   ring := Group()
-#   stage.root.add(ring)
-#   ring.add(Rect.create(40.0, 20.0, Color.Red).at(10.0, 5.0))
-#   stage.act(dt)   # runs every actor's `act`, depth first
-#   stage.draw()    # draws through `std/game/Game`
-#
-# Actors are compared with `same(a, b)`, which is just `==`: an actor is a heap
-# struct and `==` on it is identity (an actor is never a copy of another). Every
-# `Actor` field has a default (a fresh `children` list per construction), so a
-# subtype sets only what differs.
-#
-# The transform maths (`Affine`, `localMatrix`, `worldMatrix`, `flatten`,
-# `hitNode`) never calls the host, so it runs under `plum test`.
-#
-# Limitations: a sprite is drawn with the composed centre, size and rotation.
-# A rect, circle or text under a rotated or non-uniformly scaled parent is drawn
-# axis-aligned at its transformed centre (text: top-left) with the composed
-# scale, since the host has no rotated shapes. Non-uniform scale under rotation
-# (skew) is not supported for drawing; hit testing handles it exactly.
-struct Actor(
-  mut x: Float, mut y: Float, mut width: Float, mut height: Float,
-  mut originX: Float, mut originY: Float,
-  mut scaleX: Float, mut scaleY: Float,
-  mut rotation: Float,
-  mut color: Color,
-  mut visible: Bool,
-  mut children: Slice[Actor],
-  mut parent: Option[Actor],
-  mut scratch: Slice[Actor],
-  mut cull: Bool, mut cullX: Float, mut cullY: Float, mut cullW: Float, mut cullH: Float) =
-  # Runs for every construction, before the subtype's own `init`. A subtype's header
-  # exposes the fields a caller may pass (`Actor(width, height)`); init sets the rest.
-  fun init(self) =
-    self.x = 0.0
-    self.y = 0.0
-    self.width = 0.0
-    self.height = 0.0
-    self.originX = 0.0
-    self.originY = 0.0
-    self.scaleX = 1.0
-    self.scaleY = 1.0
-    self.rotation = 0.0
-    self.color = Color.White
-    self.visible = true
-    self.children = Slice[Actor]()
-    self.parent = None
-    self.scratch = Slice[Actor]()
-    self.cull = false
-    self.cullX = 0.0
-    self.cullY = 0.0
-    self.cullW = 0.0
-    self.cullH = 0.0
-  # This actor's behaviour. The default acts the children; an override that keeps
-  # children calls `self.actChildren(dt)` too.
-  fun act(self, dt: Float) =
-    self.actChildren(dt)
-  fun actChildren(self, dt: Float) =
-    i := 0
-    while i < self.children.length()
-      self.children.at(i).act(dt)
-      i = i + 1
-  # Paints this actor only, given its stage transform `m` and accumulated alpha.
-  # The default paints nothing (a group).
-  fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    return
-  # Whether `p`, a point in this actor's own coordinates, is on it: inside its
-  # width by height box. A group with no size is never hit itself.
-  fun hit(self, p: Vec2) -> Bool =
-    self.width > 0.0 && self.height > 0.0 && p.x >= 0.0 && p.x <= self.width && p.y >= 0.0 && p.y <= self.height
-  # Handles `e`, with a pointer position in this actor's own coordinates. Return true
-  # to consume it; otherwise it goes on to the parent. The default ignores it.
-  fun onInput(self, e: InputEvent) -> Bool =
-    false
-  fun at(self, x: Float, y: Float) -> Actor =
-    self.x = x
-    self.y = y
-    self
-  fun setOrigin(self, ox: Float, oy: Float) -> Actor =
-    self.originX = ox
-    self.originY = oy
-    self
-  fun centerOrigin(self) -> Actor =
-    self.originX = self.width / 2.0
-    self.originY = self.height / 2.0
-    self
-  # The index of `c` among this actor's children, -1 if it is not one.
-  fun childIndex(self, c: Actor) -> Int =
-    for i := range self.children.length()
-      if self.children.at(i) == c
-        return i
-    -1
-  # Appends a child (taking it from its previous parent) so it draws after its siblings.
-  fun add(self, child: Actor) =
-    if Some(p) := child.parent
-      p.detach(child)
-    child.parent = Some(self)
-    self.children.push(child)
-  fun detach(self, child: Actor) =
-    i := self.childIndex(child)
-    if i >= 0
-      self.children.removeAt(i)
-  fun remove(self, child: Actor) =
-    if Some(p) := child.parent
-      if p == self
-        self.detach(child)
-        child.parent = None
-  fun clear(self) =
-    for i := range self.children.length()
-      self.children.at(i).parent = None
-    self.children.clear()
-  # The actor's index among its siblings (its draw order), -1 without a parent.
-  fun zIndex(self) -> Int =
-    if Some(p) := self.parent
-      return p.childIndex(self)
-    -1
-  # Moves the actor to index `i` of its parent's children (clamped to the valid
-  # range), shifting the siblings in between. Without a parent it does nothing.
-  fun setZIndex(self, i: Int) =
-    if Some(p) := self.parent
-      src := self.zIndex()
-      dst := i
-      if dst < 0
-        dst = 0
-      if dst > p.children.length() - 1
-        dst = p.children.length() - 1
-      d := p.children.data
-      base := p.children.start
-      me: Actor := self
-      while src < dst
-        d.set(base + src, d.get(base + src + 1))
-        src = src + 1
-      while src > dst
-        d.set(base + src, d.get(base + src - 1))
-        src = src - 1
-      d.set(base + dst, me)
-  # Draws last (on top) and is hit first.
-  fun toFront(self) =
-    if Some(p) := self.parent
-      self.setZIndex(p.children.length() - 1)
-  # Draws first (underneath) and is hit last.
-  fun toBack(self) =
-    self.setZIndex(0)
-  # Reorders the children in place so that `before(a, b)` puts a ahead of b;
-  # equal children (neither before the other) keep their order. A natural merge
-  # sort: it finds the ascending runs, then merges neighbouring runs, trimming
-  # the part of each merge that is already in place by binary search. A list that
-  # is already sorted costs n - 1 comparisons, a nearly sorted one about 2n (one
-  # scan to find the runs, one to confirm the merge) plus the distance each
-  # displaced child moves; the worst case is O(n log n). The merge buffer
-  # is the actor's own `scratch` list, which keeps its capacity between calls, so
-  # sorting every frame allocates nothing once it has grown.
-  fun sortChildren(self, before: fn(Actor, Actor) -> Bool) =
-    n := self.children.length()
-    d := self.children.data
-    base := self.children.start
-    runs := 2
-    while runs > 1
-      runs = 0
-      i := 0
-      while i < n
-        a := sortRunEnd(d, base, i, n, before)
-        runs = runs + 1
-        if a >= n
-          i = n
-        else
-          b := sortRunEnd(d, base, a, n, before)
-          runs = runs + 1
-          sortMerge(self.scratch, d, base, i, a, b, before)
-          i = b
-      runs = {runs + 1} / 2
-  # Culls this actor's direct children against the rectangle (x, y, w, h), in this
-  # actor's own coordinates: a child whose box (position and size, scaled about its
-  # origin; rotation ignored) misses it is neither drawn nor hit, with its whole
-  # subtree. A child with no size (a plain group) is never culled.
-  fun setCullingArea(self, x: Float, y: Float, w: Float, h: Float) =
-    self.cull = true
-    self.cullX = x
-    self.cullY = y
-    self.cullW = w
-    self.cullH = h
-  fun clearCullingArea(self) =
-    self.cull = false
-  # The transform into the parent's coordinates: translate to the position,
-  # rotate and scale about the origin.
-  fun local(self) -> Affine =
-    cs := Math.cos(self.rotation)
-    sn := Math.sin(self.rotation)
-    a := cs * self.scaleX
-    b := sn * self.scaleX
-    c := 0.0 - sn * self.scaleY
-    d := cs * self.scaleY
-    Affine(
-      a: a, b: b, c: c, d: d,
-      e: self.x + self.originX - {a * self.originX + c * self.originY},
-      f: self.y + self.originY - {b * self.originX + d * self.originY})
-  # Whether this actor's box (in its parent's coordinates) lies outside the
-  # rectangle (ax, ay, aw, ah). An actor with no size is never outside.
-  fun outside(self, ax: Float, ay: Float, aw: Float, ah: Float) -> Bool =
-    if self.width == 0.0 && self.height == 0.0
-      return false
-    w := self.width * self.scaleX
-    h := self.height * self.scaleY
-    x := self.x + self.originX - self.originX * self.scaleX
-    y := self.y + self.originY - self.originY * self.scaleY
-    if w < 0.0
-      x = x + w
-      w = 0.0 - w
-    if h < 0.0
-      y = y + h
-      h = 0.0 - h
-    x > ax + aw || x + w < ax || y > ay + ah || y + h < ay
-  # Whether this actor culls its child `c`.
-  fun culls(self, c: Actor) -> Bool =
-    self.cull && c.outside(self.cullX, self.cullY, self.cullW, self.cullH)
-  # Draws this actor and then its children, given the parent's stage transform.
-  fun drawTree(self, canvas: Canvas, parent: Affine, alpha: Float) =
-    if !self.visible
-      return
-    m := parent * self.local()
-    a := alpha * self.color.a
-    self.draw(canvas, m, a)
-    n := self.children.length()
-    for i := range n
-      kid := self.children.at(i)
-      if !self.culls(kid)
-        kid.drawTree(canvas, m, a)
-  fun collect(self, parent: Affine, alpha: Float, out: Slice[Drawn]) =
-    if !self.visible
-      return
-    m := parent * self.local()
-    a := alpha * self.color.a
-    me: Actor := self
-    out.push(Drawn(node: me, m: m, alpha: a))
-    n := self.children.length()
-    for i := range n
-      kid := self.children.at(i)
-      if !self.culls(kid)
-        kid.collect(m, a, out)
-  # The topmost visible actor under `p`, a point in the parent's coordinates:
-  # children before the actor itself, later siblings before earlier ones.
-  fun hitTree(self, p: Vec2) -> Option[Actor] =
-    if !self.visible
-      return None
-    q := self.local().inverse().apply(p)
-    n := self.children.length()
-    for i := range n
-      child := self.children.at(n - 1 - i)
-      if !self.culls(child)
-        if Some(found) := child.hitTree(q)
-          return Some(found)
-    if self.hit(q)
-      me: Actor := self
-      return Some(me)
-    None
-  # A point in this actor's coordinates, in the stage's.
-  fun localToStage(self, p: Vec2) -> Vec2 =
-    me: Actor := self
-    worldMatrix(me).apply(p)
-  # A point in the stage's coordinates, in this actor's.
-  fun stageToLocal(self, p: Vec2) -> Vec2 =
-    me: Actor := self
-    worldMatrix(me).inverse().apply(p)
-# Whether two actor values are the same actor (`==` is identity on a heap struct).
-fun same(a: Actor, b: Actor) -> Bool =
-  a == b
-# An actor that only holds children.
-struct Group(Actor)
-# A texture region (srcX, srcY, srcW, srcH in texture pixels) drawn width by height.
-struct Sprite(Actor(width, height), tex: Texture, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
-  fun create(tex: Texture, sx: Float, sy: Float, sw: Float, sh: Float, w: Float, h: Float) -> Sprite =
-    Sprite(width: w, height: h, tex: tex, srcX: sx, srcY: sy, srcW: sw, srcH: sh)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawSpriteFrame(canvas, m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
-struct Rect(Actor(width, height, color)) =
-  fun create(w: Float, h: Float, c: Color) -> Rect =
-    Rect(width: w, height: h, color: c)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawRectBox(canvas, m, alpha, self.width, self.height, self.color)
-struct Circle(Actor(width, height, color)) =
-  # A circle of radius r whose bounding box has its top-left at the actor's position.
-  fun create(r: Float, c: Color) -> Circle =
-    Circle(width: r * 2.0, height: r * 2.0, color: c)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawDisc(canvas, m, alpha, self.width / 2.0, self.color)
-struct Text(Actor(width, height, color), mut text: Str, size: Float) =
-  # Text with its top-left at the actor's position; the size is an estimate of the extent.
-  fun create(s: Str, size: Float, c: Color) -> Text =
-    Text(width: size * 0.6 * Float(s.length()), height: size, color: c, text: s, size: size)
-  override fun draw(self, canvas: Canvas, m: Affine, alpha: Float) =
-    drawLabel(canvas, m, alpha, self.text, self.size, self.color)
-# Draws a `w` by `h` rectangle at the transform `m`, for your own rect-like records.
-fun drawRectBox(canvas: Canvas, m: Affine, alpha: Float, w: Float, h: Float, color: Color) =
-  sx := w * m.scaleX()
-  sy := h * m.scaleY()
-  c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
-  canvas.drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, color.withAlpha(alpha))
-# Draws a circle of radius `r` whose bounding box has its top-left at the transform `m`.
-fun drawDisc(canvas: Canvas, m: Affine, alpha: Float, r: Float, color: Color) =
-  c := m.apply(Vec2(x: r, y: r))
-  canvas.drawCircle(c.x, c.y, r * m.scaleX(), color.withAlpha(alpha))
-# Draws text with its top-left at the transform `m`.
-fun drawLabel(canvas: Canvas, m: Affine, alpha: Float, s: Str, size: Float, color: Color) =
-  p := m.apply(Vec2(x: 0.0, y: 0.0))
-  canvas.drawText(s, p.x, p.y, size * m.scaleY(), color.withAlpha(alpha))
-# Draws a texture region `w` by `h` at the transform `m`: for your own sprite-like records.
-fun drawSpriteFrame(canvas: Canvas, m: Affine, alpha: Float, w: Float, h: Float, color: Color, tex: Texture, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
-  sx := w * m.scaleX()
-  sy := h * m.scaleY()
-  c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
-  canvas.drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, color.withAlpha(alpha))
-# The end of the ascending run of `d` starting at `i` (exclusive), within n.
-fun sortRunEnd(d: Array[Actor], base: Int, i: Int, n: Int, before: fn(Actor, Actor) -> Bool) -> Int =
-  j := i + 1
-  while j < n && !before(d.get(base + j), d.get(base + j - 1))
-    j = j + 1
-  j
-# Merges the sorted runs [lo, a) and [a, b) of `d`, stably. The left elements that
-# already precede the first right one and the right elements that already follow
-# the last left one are found by binary search and left alone.
-fun sortMerge(scratch: Slice[Actor], d: Array[Actor], base: Int, lo: Int, a: Int, b: Int, before: fn(Actor, Actor) -> Bool) =
-  first := d.get(base + a)
-  l := lo
-  h := a
-  while l < h
-    mid := {l + h} / 2
-    if before(first, d.get(base + mid))
-      h = mid
-    else
-      l = mid + 1
-  lo2 := l
-  if lo2 >= a
-    return
-  last := d.get(base + a - 1)
-  l = a
-  h = b
-  while l < h
-    mid := {l + h} / 2
-    if before(d.get(base + mid), last)
-      l = mid + 1
-    else
-      h = mid
-  hi := l
-  scratch.clear()
-  for k := range a - lo2
-    scratch.push(d.get(base + lo2 + k))
-  ln := a - lo2
-  i := 0
-  j := a
-  o := lo2
-  while i < ln && j < hi
-    r := d.get(base + j)
-    s := scratch.at(i)
-    if before(r, s)
-      d.set(base + o, r)
-      j = j + 1
-    else
-      d.set(base + o, s)
-      i = i + 1
-    o = o + 1
-  while i < ln
-    d.set(base + o, scratch.at(i))
-    i = i + 1
-    o = o + 1
-# The actor's transform into its parent's coordinates.
-fun localMatrix(n: Actor) -> Affine =
-  n.local()
-# The actor's transform into stage coordinates.
-fun worldMatrix(n: Actor) -> Affine =
-  if Some(p) := n.parent
-    worldMatrix(p) * n.local()
-  else
-    n.local()
-# One entry of the draw list: a visible actor, its stage transform and its alpha.
-struct Drawn(node: Actor, m: Affine, alpha: Float)
-# What `draw` would draw, in order: a parent before its children, siblings in
-# list order, invisible and culled subtrees left out.
-fun flatten(root: Actor) -> Slice[Drawn] =
-  out := Slice[Drawn]()
-  root.collect(Affine.Identity, 1.0, out)
-  out
-fun drawNode(canvas: Canvas, n: Actor, parent: Affine, alpha: Float) =
-  n.drawTree(canvas, parent, alpha)
-fun actNode(n: Actor, dt: Float) =
-  n.act(dt)
-# The topmost visible actor under `p`, a point in the actor's parent's coordinates.
-fun hitNode(n: Actor, p: Vec2) -> Option[Actor] =
-  n.hitTree(p)
-# A root actor plus a camera (the world point at the screen's top-left and the
-# pixels per world unit, as in `setCamera`).
-struct Stage(mut camX: Float, mut camY: Float, mut camScale: Float, mut focus: Option[Actor]) =
-  fun init(self) =
-    self.root: Actor = Group()
-  fun create() -> Stage =
-    Stage(camX: 0.0, camY: 0.0, camScale: 1.0, focus: None)
-  # Runs every actor's `act`, parents before children, in insertion order.
-  fun act(self, dt: Float) =
-    self.root.act(dt)
-  fun draw(self, canvas: Canvas) =
-    canvas.setCamera(self.camX, self.camY, self.camScale)
-    self.root.drawTree(canvas, Affine.Identity, 1.0)
-    canvas.resetCamera()
-  # The topmost visible actor at a stage point.
-  fun hit(self, x: Float, y: Float) -> Option[Actor] =
-    self.root.hitTree(Vec2(x: x, y: y))
-  # Delivers one input and says whether an actor consumed it. A pointer input goes
-  # to the topmost actor under it, then each parent in turn until one's `onInput`
-  # returns true; a press also gives that actor the keyboard focus. A key goes to the
-  # focused actor, then its parents. Unconsumed input is the game's to handle.
-  fun input(self, e: InputEvent) -> Bool =
-    if Some(p) := e.position()
-      sp := self.screenToStage(p.x, p.y)
-      target := self.hit(sp.x, sp.y)
-      match e
-        PointerDown(_, _) =>
-          self.focus = target
-        _ => 0
-      if Some(a) := target
-        return Stage.bubble(a, InputEvent.pointerAt(e, sp))
-      return false
-    if Some(f) := self.focus
-      return Stage.bubble(f, e)
-    false
-  # Offers `e` (in stage coordinates) to `a`, then each parent, until one consumes it.
-  fun bubble(a: Actor, e: InputEvent) -> Bool =
-    cur: Option[Actor] := Some(a)
-    while Some(c) := cur
-      if c.onInput(e.through(worldMatrix(c).inverse()))
-        return true
-      cur = c.parent
-    false
-  # A screen pixel in stage coordinates under this camera.
-  fun screenToStage(self, sx: Float, sy: Float) -> Vec2 =
-    Vec2(x: sx / self.camScale + self.camX, y: sy / self.camScale + self.camY)
-# --- tests ---
-# Counts the inputs it is offered and the last pointer x it saw; consumes them if `eat`.
-struct Catcher(Actor(width, height), mut got: Int, mut lastX: Float, eat: Bool) =
-  override fun onInput(self, e: InputEvent) -> Bool =
-    self.got = self.got + 1
-    if Some(p) := e.position()
-      self.lastX = p.x
-    self.eat
-fun sceneNear(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.0001
-fun sceneNearV(p: Vec2, x: Float, y: Float) -> Bool =
-  sceneNear(p.x, x) && sceneNear(p.y, y)
-fun sceneKids(n: Int) -> Group =
-  g := Group()
-  for i := range n
-    g.add(Rect.create(1.0, 1.0, Color.Red).at(Float(i), 0.0))
-  g
-fun sceneOrder(g: Actor) -> Str =
-  s := ""
-  for i := range g.children.length()
-    s = "{s}{Int(g.children.at(i).x)},"
-  s
-test "an actor translates; rotation and scale pivot about the origin"
-  n := Rect.create(10.0, 10.0, Color.Red).at(100.0, 50.0)
-  assert sceneNearV(localMatrix(n).apply(Vec2(x: 0.0, y: 0.0)), 100.0, 50.0)
-  n.originX = 5.0
-  n.originY = 5.0
-  n.rotation = Float.HalfPi
-  assert sceneNearV(localMatrix(n).apply(Vec2(x: 5.0, y: 5.0)), 105.0, 55.0)
-  assert sceneNearV(localMatrix(n).apply(Vec2(x: 10.0, y: 5.0)), 105.0, 60.0)
-  n.rotation = 0.0
-  n.scaleX = 2.0
-  assert sceneNearV(localMatrix(n).apply(Vec2(x: 10.0, y: 10.0)), 115.0, 60.0)
-test "matrices compose, and inverse undoes them"
-  g := Group().at(100.0, 0.0)
-  g.rotation = Float.HalfPi
-  g.scaleX = 2.0
-  g.scaleY = 2.0
-  k := Rect.create(10.0, 10.0, Color.Red).at(10.0, 0.0)
-  g.add(k)
-  w := worldMatrix(k)
-  assert sceneNearV(w.apply(Vec2(x: 0.0, y: 0.0)), 100.0, 20.0)
-  assert sceneNearV(w.apply(Vec2(x: 10.0, y: 10.0)), 80.0, 40.0)
-  assert sceneNear(w.scaleX(), 2.0)
-  assert sceneNear(w.rotation(), Float.HalfPi)
-  back := w.inverse().apply(w.apply(Vec2(x: 3.0, y: 7.0)))
-  assert sceneNearV(back, 3.0, 7.0)
-  assert sceneNearV(k.localToStage(Vec2(x: 10.0, y: 10.0)), 80.0, 40.0)
-  assert sceneNearV(k.stageToLocal(Vec2(x: 80.0, y: 40.0)), 10.0, 10.0)
-test "add reparents, remove and clear detach"
-  a := Group()
-  b := Group()
-  k := Group()
-  a.add(k)
-  assert a.children.length() == 1
-  b.add(k)
-  assert a.children.length() == 0
-  assert b.children.length() == 1
-  assert same(k.parent.unwrap(), b)
-  b.remove(k)
-  assert b.children.length() == 0
-  assert k.parent.isNone()
-  b.add(k)
-  extra := Group()
-  b.add(extra)
-  b.clear()
-  assert b.children.length() == 0
-  assert k.parent.isNone()
-test "draw order is parent first, then children in insertion order"
-  root := Group()
-  a := Group()
-  root.add(a)
-  b := Group()
-  root.add(b)
-  a1 := Rect.create(1.0, 1.0, Color.Red)
-  a.add(a1)
-  a2 := Rect.create(1.0, 1.0, Color.Red)
-  a.add(a2)
-  b1 := Rect.create(1.0, 1.0, Color.Red)
-  b.add(b1)
-  list := flatten(root)
-  assert list.length() == 6
-  assert same(list.at(0).node, root)
-  assert same(list.at(1).node, a)
-  assert same(list.at(2).node, a1)
-  assert same(list.at(3).node, a2)
-  assert same(list.at(4).node, b)
-  assert same(list.at(5).node, b1)
-test "invisible subtrees are skipped and alpha multiplies down"
-  root := Group()
-  root.color = Color.White.withAlpha(0.5)
-  g := Group()
-  root.add(g)
-  g.color = Color.White.withAlpha(0.5)
-  k := Rect.create(1.0, 1.0, Color.Red)
-  g.add(k)
-  hidden := Group()
-  root.add(hidden)
-  hidden.visible = false
-  hidden.add(Rect.create(1.0, 1.0, Color.Red))
-  list := flatten(root)
-  assert list.length() == 3
-  assert sceneNear(list.at(2).alpha, 0.25)
-  g.visible = false
-  assert flatten(root).length() == 1
-test "hit finds the topmost actor through rotated and scaled groups"
-  root := Group()
-  g := Group().at(100.0, 0.0)
-  root.add(g)
-  g.rotation = Float.HalfPi
-  g.scaleX = 2.0
-  g.scaleY = 2.0
-  low := Rect.create(30.0, 30.0, Color.Red)
-  g.add(low)
-  top := Rect.create(10.0, 10.0, Color.Blue).at(10.0, 0.0)
-  g.add(top)
-  stage := Stage.create()
-  stage.root.add(g)
-  assert same(stage.hit(90.0, 30.0).unwrap(), top)
-  assert same(stage.hit(70.0, 10.0).unwrap(), low)
-  assert same(stage.hit(60.0, 30.0).unwrap(), low)
-  assert stage.hit(10.0, 10.0).isNone()
-  assert stage.hit(150.0, 30.0).isNone()
-  top.visible = false
-  assert same(stage.hit(90.0, 30.0).unwrap(), low)
-  g.visible = false
-  assert stage.hit(90.0, 30.0).isNone()
-test "hit prefers later siblings and a child over its parent"
-  stage := Stage.create()
-  a := Rect.create(50.0, 50.0, Color.Red)
-  stage.root.add(a)
-  b := Rect.create(50.0, 50.0, Color.Blue).at(25.0, 0.0)
-  stage.root.add(b)
-  inner := Rect.create(10.0, 10.0, Color.Green)
-  b.add(inner)
-  assert same(stage.hit(10.0, 10.0).unwrap(), a)
-  assert same(stage.hit(30.0, 5.0).unwrap(), inner)
-  assert same(stage.hit(60.0, 40.0).unwrap(), b)
-  assert same(stage.hit(40.0, 10.0).unwrap(), b)
-test "the default act runs the children's act, invisible ones included"
-  stage := Stage.create()
-  g := Group()
-  stage.root.add(g)
-  g.add(Rect.create(1.0, 1.0, Color.Red))
-  g.visible = false
-  stage.act(0.5)
-  assert stage.root.rotation == 0.0
-  assert g.children.length() == 1
-test "the screen maps to the stage through the camera"
-  stage := Stage.create()
-  stage.camX = 100.0
-  stage.camY = 50.0
-  stage.camScale = 2.0
-  p := stage.screenToStage(40.0, 20.0)
-  assert sceneNearV(p, 120.0, 60.0)
-test "sizes of sprites, circles and text"
-  assert Circle.create(5.0, Color.Red).width == 10.0
-  s := Sprite.create(Texture(id: 3), 16.0, 0.0, 16.0, 16.0, 32.0, 32.0)
-  assert s.tex.id == 3
-  assert s.width == 32.0
-  assert Text.create("ab", 10.0, Color.White).height == 10.0
-test "setZIndex, toFront and toBack reorder the siblings"
-  g := sceneKids(4)
-  a := g.children.at(0)
-  b := g.children.at(1)
-  d := g.children.at(3)
-  assert a.zIndex() == 0
-  assert d.zIndex() == 3
-  a.toFront()
-  assert sceneOrder(g) == "1,2,3,0,"
-  assert a.zIndex() == 3
-  d.toBack()
-  assert sceneOrder(g) == "3,1,2,0,"
-  b.setZIndex(2)
-  assert sceneOrder(g) == "3,2,1,0,"
-  b.setZIndex(99)
-  assert sceneOrder(g) == "3,2,0,1,"
-  b.setZIndex(-5)
-  assert sceneOrder(g) == "1,3,2,0,"
-  assert Group().zIndex() == -1
-  Group().toFront()
-  assert g.children.length() == 4
-test "sortChildren is stable and keeps ties in order"
-  g := Group()
-  for i := range 10
-    k := Rect.create(1.0, 1.0, Color.Red).at(Float(i), Float(i * 7 % 3))
-    g.add(k)
-  g.sortChildren(|a, b| a.y < b.y)
-  assert sceneOrder(g) == "0,3,6,9,1,4,7,2,5,8,"
-  g.sortChildren(|a, b| a.y < b.y)
-  assert sceneOrder(g) == "0,3,6,9,1,4,7,2,5,8,"
-test "sortChildren sorts 5000 random actors and updates hit order"
-  g := Group()
-  for i := range 5000
-    g.add(Rect.create(1.0, 1.0, Color.Red).at(Float(i), Float({i * 7919 + 13} % 5003)))
-  g.sortChildren(|a, b| a.y < b.y)
-  assert g.children.length() == 5000
-  for i := range 4999
-    assert g.children.at(i).y <= g.children.at(i + 1).y
-  assert same(g.children.at(10).parent.unwrap(), g)
-test "sorting a nearly sorted list takes about n comparisons and reuses the scratch buffer"
-  g := Group()
-  for i := range 5000
-    g.add(Rect.create(1.0, 1.0, Color.Red).at(0.0, Float(i)))
-  c := [0].toSlice()
-  less: fn(Actor, Actor) -> Bool := |a, b|
-    _ := c.set(0, c.at(0) + 1)
-    a.y < b.y
-  g.sortChildren(less)
-  assert c.at(0) == 4999
-  g.children.at(2500).y = 2498.5
-  g.children.at(100).y = 105.5
-  _ := c.set(0, 0)
-  g.sortChildren(less)
-  assert c.at(0) < 10100
-  for i := range 4999
-    assert g.children.at(i).y <= g.children.at(i + 1).y
-  scratch := g.scratch
-  cap := scratch.cap
-  assert cap > 0
-  scratch.clear()
-  g.children.at(3000).y = 2990.5
-  g.sortChildren(less)
-  assert scratch.length() > 0
-  assert scratch.cap == cap
-  _ := c.set(0, 0)
-  g.children.clear()
-  for i := range 5000
-    g.add(Rect.create(1.0, 1.0, Color.Red).at(0.0, Float({i * 7919 + 13} % 5003)))
-  g.sortChildren(less)
-  assert c.at(0) < 130000
-test "culling skips children outside the area in flatten and draw order"
-  g := Group()
-  inside := Rect.create(10.0, 10.0, Color.Red).at(20.0, 20.0)
-  outside := Rect.create(10.0, 10.0, Color.Red).at(500.0, 20.0)
-  g.add(inside)
-  g.add(outside)
-  outside.add(Rect.create(5.0, 5.0, Color.Red))
-  assert flatten(g).length() == 4
-  g.setCullingArea(0.0, 0.0, 100.0, 100.0)
-  list := flatten(g)
-  assert list.length() == 2
-  assert same(list.at(1).node, inside)
-  g.setCullingArea(0.0, 100.0, 100.0, 100.0)
-  assert flatten(g).length() == 1
-  g.clearCullingArea()
-  assert flatten(g).length() == 4
-test "hit does not return culled children, and a scaled child near the edge is kept"
-  stage := Stage.create()
-  k := Rect.create(10.0, 10.0, Color.Red).at(105.0, 5.0)
-  stage.root.add(k)
-  stage.root.setCullingArea(0.0, 0.0, 100.0, 100.0)
-  assert stage.hit(107.0, 7.0).isNone()
-  k.scaleX = 4.0
-  k.originX = 10.0
-  assert same(stage.hit(90.0, 7.0).unwrap(), k)
-  assert flatten(stage.root).length() == 2
-  k.scaleX = 1.0
-  k.originX = 0.0
-  assert stage.hit(107.0, 7.0).isNone()
-  stage.root.clearCullingArea()
-  assert same(stage.hit(107.0, 7.0).unwrap(), k)
-test "a child without a size is never culled"
-  g := Group()
-  slot := Group().at(900.0, 900.0)
-  g.add(slot)
-  slot.add(Rect.create(10.0, 10.0, Color.Red).at(-890.0, -890.0))
-  g.setCullingArea(0.0, 0.0, 100.0, 100.0)
-  assert flatten(g).length() == 3
-test "input bubbles from the hit actor to its parents until consumed"
-  stage := Stage.create()
-  outer := Catcher(width: 100.0, height: 100.0, got: 0, lastX: 0.0, eat: true)
-  inner := Catcher(width: 10.0, height: 10.0, got: 0, lastX: 0.0, eat: false)
-  inner.x = 20.0
-  outer.add(inner)
-  stage.root.add(outer)
-  assert stage.input(PointerDown(x: 25.0, y: 5.0))
-  assert inner.got == 1
-  assert inner.lastX == 5.0
-  assert outer.got == 1
-  assert outer.lastX == 25.0
-  assert !stage.input(PointerDown(x: 500.0, y: 5.0))
-test "a press gives the keyboard focus; keys bubble from it"
-  stage := Stage.create()
-  outer := Catcher(width: 100.0, height: 100.0, got: 0, lastX: 0.0, eat: false)
-  inner := Catcher(width: 10.0, height: 10.0, got: 0, lastX: 0.0, eat: false)
-  outer.add(inner)
-  stage.root.add(outer)
-  assert !stage.input(KeyDown(key: Key.KeyA))
-  assert inner.got == 0
-  _ := stage.input(PointerDown(x: 5.0, y: 5.0))
-  assert !stage.input(KeyDown(key: Key.KeyA))
-  assert inner.got == 2
-  assert outer.got == 2

std/game/pure/Actions.plum DELETED Viewed

@@ -1,402 +0,0 @@
-module std
-import std/Slice
-import std/Int
-import std/Float
-import std/List
-import std/Option
-# scene2d-style actions as plain data plus a step method. `Action.step`
-# steps an action IN PLACE on its own record (a running action allocates nothing:
-# the result is a struct, flattened into multi-value returns) and reports the new
-# pose, the part of `dt` it did not use and whether it finished. `stepAll` drops
-# finished actions by compacting the Slice in place. Sequences hand the spare time
-# to the next step, so chained and looping animations do not drift. A `Forever`
-# restarts a lap from a fresh copy of its template (one allocation per lap).
-# The animated part of an actor's transform.
-struct Pose(x: Float, y: Float, rotation: Float, scaleX: Float, scaleY: Float)
-# One action. `elapsed` and `current` (the running lap of a `Forever`, None
-# before it starts) are the mutable state; `kind` is the immutable description.
-# A `Forever`'s `template` is the pristine action restarted each lap.
-struct Action(mut elapsed: Float, mut current: Option[Action], kind: ActionKind) =
-  fun moveBy(dx: Float, dy: Float, secs: Float) -> Action =
-    Action(elapsed: 0.0, current: None, kind: MoveBy(dx: dx, dy: dy, duration: secs))
-  fun rotateBy(radians: Float, secs: Float) -> Action =
-    Action(elapsed: 0.0, current: None, kind: RotateBy(radians: radians, duration: secs))
-  fun delay(secs: Float) -> Action =
-    Action(elapsed: 0.0, current: None, kind: Delay(duration: secs))
-  fun sequence(steps: Slice[Action]) -> Action =
-    Action(elapsed: 0.0, current: None, kind: Sequence(steps: steps))
-  fun parallel(steps: Slice[Action]) -> Action =
-    Action(elapsed: 0.0, current: None, kind: Parallel(steps: steps))
-  fun forever(a: Action) -> Action =
-    Action(elapsed: 0.0, current: Some(a), kind: Forever(template: a.fresh()))
-  # An unstarted copy (elapsed 0, all steps present).
-  fun fresh(self) -> Action =
-    match self.kind
-      MoveBy(dx, dy, duration) => Action.moveBy(dx, dy, duration)
-      RotateBy(radians, duration) => Action.rotateBy(radians, duration)
-      Delay(duration) => Action.delay(duration)
-      Sequence(steps) =>
-        out := Slice[Action]()
-        for i := range steps.length()
-          out.push(steps.at(i).fresh())
-        Action.sequence(out)
-      Parallel(steps) =>
-        out := Slice[Action]()
-        for i := range steps.length()
-          out.push(steps.at(i).fresh())
-        Action.parallel(out)
-      Forever(template) => Action(elapsed: 0.0, current: Some(template.fresh()), kind: Forever(template: template))
-  # Steps this action by `dt` in place, from pose `p`.
-  fun step(self, p: Pose, dt: Float) -> Step =
-    a := self
-    match a.kind
-      MoveBy(dx, dy, duration) =>
-        k := Tick.of(duration, a.elapsed, dt)
-        a.elapsed = a.elapsed + k.used
-        q := Pose(x: p.x + dx * k.frac, y: p.y + dy * k.frac, rotation: p.rotation, scaleX: p.scaleX, scaleY: p.scaleY)
-        Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      RotateBy(radians, duration) =>
-        k := Tick.of(duration, a.elapsed, dt)
-        a.elapsed = a.elapsed + k.used
-        q := Pose(x: p.x, y: p.y, rotation: p.rotation + radians * k.frac, scaleX: p.scaleX, scaleY: p.scaleY)
-        Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      Delay(duration) =>
-        k := Tick.of(duration, a.elapsed, dt)
-        a.elapsed = a.elapsed + k.used
-        Step(pose: p, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      Sequence(steps) =>
-        if steps.length() == 0
-          return Step(pose: p, spare: dt, done: true)
-        s := steps.at(0).step(p, dt)
-        if !s.done
-          return Step(pose: s.pose, spare: 0.0, done: false)
-        # The rest starts in this same frame with the time left over; the list
-        # is one shorter on every call, so this terminates.
-        steps.removeAt(0)
-        a.step(s.pose, s.spare)
-      Parallel(steps) => Action.stepAll(p, steps, dt)
-      Forever(template) =>
-        # Restarts at most once per step, with the spare time, so a zero-length
-        # template cannot spin forever inside one step.
-        if a.current.isNone()
-          a.current = Some(template.fresh())
-        lap := template
-        if Some(c) := a.current
-          lap = c
-        s := lap.step(p, dt)
-        if !s.done
-          return Step(pose: s.pose, spare: 0.0, done: false)
-        next := template.fresh()
-        r := next.step(s.pose, s.spare)
-        if r.done
-          a.current = Some(template.fresh())
-        else
-          a.current = Some(next)
-        Step(pose: r.pose, spare: 0.0, done: false)
-  # Steps every action side by side in place and drops the finished ones by
-  # compacting `acts`. `spare` is the smallest spare time among the finished
-  # ones, 0 while any action is left.
-  fun stepAll(p: Pose, acts: Slice[Action], dt: Float) -> Step =
-    pose := p
-    spare := dt
-    w := 0
-    for i := range acts.length()
-      s := acts.at(i).step(pose, dt)
-      pose = s.pose
-      if !s.done
-        if w != i
-          acts.putAt(w, acts.takeAt(i))
-        w = w + 1
-      else
-        spare = spare.min(s.spare)
-    while acts.length() > w
-      acts.removeAt(acts.length() - 1)
-    if w > 0
-      spare = 0.0
-    Step(pose: pose, spare: spare, done: w == 0)
-enum ActionKind =
-  | MoveBy(dx: Float, dy: Float, duration: Float)
-  | RotateBy(radians: Float, duration: Float)
-  | Delay(duration: Float)
-  | Sequence(steps: Slice[Action])
-  | Parallel(steps: Slice[Action])
-  | Forever(template: Action)
-# How much of a timed action one step covers. A zero-length action finishes at
-# once and applies all of itself (no 0/0).
-struct Tick(used: Float, frac: Float, done: Bool) =
-  # One step of `dt` on an action `duration` long that has run for `elapsed`.
-  fun of(duration: Float, elapsed: Float, dt: Float) -> Tick =
-    if duration <= 0.0
-      return Tick(used: 0.0, frac: 1.0, done: true)
-    used := dt.min(duration - elapsed)
-    Tick(used: used, frac: used / duration, done: elapsed + used >= duration)
-# The result of one step: the pose, the unused part of dt (0 while running) and
-# whether the action(s) finished. For `stepAll`, `done` means none are left.
-struct Step(pose: Pose, spare: Float, done: Bool)
-fun actNear(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.000001
-fun actSeqLen(a: Action) -> Int =
-  match a.kind
-    Sequence(steps) => steps.length()
-    _ => 0 - 1
-fun actElapsed(a: Action) -> Float =
-  match a.kind
-    MoveBy(_, _, _) => a.elapsed
-    _ => 0.0 - 1.0
-fun actPose0() -> Pose =
-  Pose(x: 0.0, y: 0.0, rotation: 0.0, scaleX: 1.0, scaleY: 1.0)
-# Golden values for actions, taken from the previous (pure, allocating) implementation
-# (`git show e04834f:std/game/Actions.plum`) run on the same inputs: pose, spare
-# time and done flag at fixed checkpoints, stepping a fresh action with dt 0.016 x N
-# and some large dts that span several sub-actions.
-struct GoldRun(a: Action, p: Pose, spare: Float, done: Bool)
-fun goldRun(a: Action) -> GoldRun =
-  GoldRun(a: a, p: actPose0(), spare: 0.0, done: false)
-fun goldAdv(r0: GoldRun, n: Int, dt: Float) -> GoldRun =
-  r := r0
-  for i := range n
-    if !r.done
-      s := r.a.step(r.p, dt)
-      r = GoldRun(..r, p: s.pose, spare: s.spare, done: s.done)
-  r
-fun goldNear(a: Float, b: Float) -> Bool =
-  {a - b}.abs() < 0.00001
-fun goldWant(r: GoldRun, x: Float, y: Float, rotation: Float, spare: Float, done: Bool) =
-  assert goldNear(r.p.x, x)
-  assert goldNear(r.p.y, y)
-  assert goldNear(r.p.rotation, rotation)
-  assert goldNear(r.spare, spare)
-  assert r.done == done
-fun goldMove() =
-  r := goldRun(Action.moveBy(10.0, 5.0, 1.0))
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 0.16, 0.08, 0.0, 0.0, false)
-  r = goldAdv(r, 29, 0.016)
-  goldWant(r, 4.8, 2.4, 0.0, 0.0, false)
-  r = goldAdv(r, 32, 0.016)
-  goldWant(r, 9.92, 4.96, 0.0, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 10.0, 5.0, 0.0, 0.008, true)
-fun goldRotate() =
-  r := goldRun(Action.rotateBy(2.0, 0.5))
-  r = goldAdv(r, 10, 0.016)
-  goldWant(r, 0.0, 0.0, 0.64, 0.0, false)
-  r = goldAdv(r, 21, 0.016)
-  goldWant(r, 0.0, 0.0, 1.984, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 0.0, 0.0, 2.0, 0.012, true)
-fun goldDelay() =
-  r := goldRun(Action.delay(0.1))
-  r = goldAdv(r, 6, 0.016)
-  goldWant(r, 0.0, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 0.0, 0.0, 0.0, 0.012, true)
-fun goldSequence() =
-  r := goldRun(Action.sequence([Action.moveBy(10.0, 0.0, 0.2), Action.delay(0.1), Action.rotateBy(1.0, 0.2)].toSlice()))
-  r = goldAdv(r, 12, 0.016)
-  goldWant(r, 9.6, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 10.0, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 6, 0.016)
-  goldWant(r, 10.0, 0.0, 0.02, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 10.0, 0.0, 0.1, 0.0, false)
-  r = goldAdv(r, 5, 0.016)
-  goldWant(r, 10.0, 0.0, 0.5, 0.0, false)
-  r = goldAdv(r, 10, 0.016)
-  goldWant(r, 10.0, 0.0, 1.0, 0.012, true)
-  r = goldAdv(r, 5, 0.016)
-  goldWant(r, 10.0, 0.0, 1.0, 0.012, true)
-fun goldParallel() =
-  r := goldRun(Action.parallel([Action.moveBy(10.0, 0.0, 0.3), Action.rotateBy(1.0, 0.1), Action.delay(0.2)].toSlice()))
-  r = goldAdv(r, 5, 0.016)
-  goldWant(r, 2.666667, 0.0, 0.8, 0.0, false)
-  r = goldAdv(r, 2, 0.016)
-  goldWant(r, 3.733333, 0.0, 1.0, 0.0, false)
-  r = goldAdv(r, 5, 0.016)
-  goldWant(r, 6.4, 0.0, 1.0, 0.0, false)
-  r = goldAdv(r, 7, 0.016)
-  goldWant(r, 10.0, 0.0, 1.0, 0.004, true)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 10.0, 0.0, 1.0, 0.004, true)
-fun goldForever() =
-  r := goldRun(Action.forever(Action.sequence([Action.moveBy(1.0, 0.0, 0.1), Action.delay(0.05)].toSlice())))
-  r = goldAdv(r, 9, 0.016)
-  goldWant(r, 1.0, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 91, 0.016)
-  goldWant(r, 11.0, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 900, 0.016)
-  goldWant(r, 107.0, 0.0, 0.0, 0.0, false)
-fun goldNested() =
-  inner := Action.parallel([Action.moveBy(4.0, 0.0, 0.1), Action.delay(0.2)].toSlice())
-  loop := Action.forever(Action.parallel([Action.rotateBy(1.0, 0.1), Action.moveBy(0.0, 1.0, 0.3)].toSlice()))
-  r := goldRun(Action.sequence([inner, loop].toSlice()))
-  r = goldAdv(r, 6, 0.016)
-  goldWant(r, 3.84, 0.0, 0.0, 0.0, false)
-  r = goldAdv(r, 7, 0.016)
-  goldWant(r, 4.0, 0.026667, 0.08, 0.0, false)
-  r = goldAdv(r, 20, 0.016)
-  goldWant(r, 4.0, 1.093333, 1.28, 0.0, false)
-  r = goldAdv(r, 200, 0.016)
-  goldWant(r, 4.0, 11.76, 12.0, 0.0, false)
-fun goldLargeDt() =
-  r := goldRun(Action.sequence([Action.moveBy(1.0, 0.0, 0.1), Action.moveBy(0.0, 1.0, 0.1), Action.rotateBy(1.0, 0.1), Action.delay(0.1)].toSlice()))
-  r = goldAdv(r, 1, 0.25)
-  goldWant(r, 1.0, 1.0, 0.5, 0.0, false)
-  r = goldAdv(r, 1, 0.05)
-  goldWant(r, 1.0, 1.0, 1.0, 0.0, false)
-  r = goldAdv(r, 1, 0.5)
-  goldWant(r, 1.0, 1.0, 1.0, 0.4, true)
-fun goldLargeDtParallel() =
-  r := goldRun(Action.parallel([Action.moveBy(2.0, 0.0, 0.1), Action.sequence([Action.delay(0.1), Action.rotateBy(1.0, 0.1)].toSlice()), Action.delay(0.3)].toSlice()))
-  r = goldAdv(r, 1, 0.15)
-  goldWant(r, 2.0, 0.0, 0.5, 0.0, false)
-  r = goldAdv(r, 1, 0.1)
-  goldWant(r, 2.0, 0.0, 1.0, 0.0, false)
-  r = goldAdv(r, 1, 0.4)
-  goldWant(r, 2.0, 0.0, 1.0, 0.35, true)
-fun goldLargeDtForever() =
-  r := goldRun(Action.forever(Action.sequence([Action.moveBy(1.0, 0.0, 0.1), Action.rotateBy(1.0, 0.1)].toSlice())))
-  r = goldAdv(r, 1, 0.25)
-  goldWant(r, 1.5, 0.0, 1.0, 0.0, false)
-  r = goldAdv(r, 1, 0.5)
-  goldWant(r, 3.0, 0.0, 3.0, 0.0, false)
-  r = goldAdv(r, 1, 0.016)
-  goldWant(r, 3.16, 0.0, 3.0, 0.0, false)
-test "stepAll moves partway and keeps the action"
-  acts := [Action.moveBy(10.0, 0.0, 1.0)].toSlice()
-  r := Action.stepAll(actPose0(), acts, 0.5)
-  assert actNear(r.pose.x, 5.0)
-  assert acts.length() == 1
-  assert actNear(r.spare, 0.0)
-test "stepAll finishes every action and reports no spare"
-  acts := [Action.moveBy(10.0, 0.0, 1.0), Action.rotateBy(1.0, 0.5)].toSlice()
-  r := Action.stepAll(actPose0(), acts, 1.0)
-  assert actNear(r.pose.x, 10.0)
-  assert actNear(r.pose.rotation, 1.0)
-  assert acts.length() == 0
-  assert actNear(r.spare, 0.0)
-test "stepAll with no actions is a no-op"
-  acts := Slice[Action]()
-  r := Action.stepAll(actPose0(), acts, 0.016)
-  assert acts.length() == 0
-  assert actNear(r.spare, 0.016)
-  assert actNear(r.pose.x, 0.0)
-test "zero_length_move_applies_at_once"
-  r := Action.moveBy(10.0, 0.0, 0.0).step(actPose0(), 0.016)
-  assert actNear(r.pose.x, 10.0)
-  assert r.done
-  assert actNear(r.spare, 0.016)
-test "forever_rotate_no_drift"
-  a := Action.forever(Action.rotateBy(1.0, 1.0))
-  p := actPose0()
-  for i := range 625
-    r := a.step(p, 0.016)
-    p = r.pose
-    assert !r.done
-  assert actNear(p.rotation, 10.0)
-test "sequence_spills_spare_time"
-  a := Action.sequence([Action.moveBy(10.0, 0.0, 0.5), Action.moveBy(0.0, 10.0, 0.5)].toSlice())
-  r := a.step(actPose0(), 0.75)
-  assert actNear(r.pose.x, 10.0)
-  assert actNear(r.pose.y, 5.0)
-  assert actNear(r.spare, 0.0)
-  assert !r.done
-  assert actSeqLen(a) == 1
-test "empty_sequence_finishes_with_full_spare"
-  r := Action.sequence(Slice[Action]()).step(actPose0(), 0.3)
-  assert r.done
-  assert actNear(r.spare, 0.3)
-test "parallel_spare_is_min_of_finished"
-  r := Action.parallel([Action.delay(0.2), Action.delay(0.5)].toSlice()).step(actPose0(), 1.0)
-  assert r.done
-  assert actNear(r.spare, 0.5)
-test "forever_zero_length_template_terminates"
-  r := Action.forever(Action.delay(0.0)).step(actPose0(), 1.0)
-  assert !r.done
-test "forever of a nested sequence keeps looping"
-  a := Action.forever(Action.sequence([Action.moveBy(1.0, 0.0, 0.1), Action.delay(0.1)].toSlice()))
-  p := actPose0()
-  for i := range 100
-    r := a.step(p, 0.05)
-    p = r.pose
-  assert actNear(p.x, 25.0)
-test "step_moves_the_action_in_place"
-  a := Action.moveBy(10.0, 0.0, 1.0)
-  r := a.step(actPose0(), 0.5)
-  assert actNear(r.pose.x, 5.0)
-  assert actElapsed(a) == 0.5
-# Steady state: the held MoveBy and RotateBy are the very records stepped (their
-# elapsed moves, no replacement lists or actions), and the slice keeps its length.
-# The wasm of this path has no struct.new (checked with wasm-tools print).
-test "step_all_no_alloc_steady_state"
-  m := Action.moveBy(100.0, 0.0, 100.0)
-  r := Action.rotateBy(1.0, 100.0)
-  acts := [m, r].toSlice()
-  p := actPose0()
-  for i := range 10
-    s := Action.stepAll(p, acts, 0.5)
-    p = s.pose
-    assert !s.done
-  assert acts.length() == 2
-  assert actNear(actElapsed(m), 5.0)
-  assert actNear(p.x, 5.0)
-  assert actNear(p.rotation, 0.05)
-test "actions_golden_values"
-  goldMove()
-  goldRotate()
-  goldDelay()
-  goldSequence()
-  goldParallel()
-  goldForever()
-  goldNested()
-  goldLargeDt()
-  goldLargeDtParallel()
-  goldLargeDtForever()

std/game/pure/PureScene.plum DELETED Viewed

@@ -1,689 +0,0 @@
-module std
-import std/Int
-import std/Float
-import std/Str
-import std/Slice
-import std/Option
-import std/Math
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/game/pure/Actions
-import std/game/Input
-import std/List
-# A pure scene graph: a node is a record (`Node`) holding a `Transform` and
-# an `enum Kind`. Group, Sprite, Label and Button are built in; games add their
-# own behaviour with `Custom(actor: Actor)`, a base struct their structs
-# embed (like Rust's `Box<dyn Actor>`). A node is a unique value: `update`,
-# `onInput`, `modify` and `route` take it, change it in place and hand it back;
-# readers borrow. Only `drawTree` talks to the host, through `std/game/Game`.
-# InputEvent is the shared `InputEvent` of std/game/Input; `route` delivers it along a hit
-# path, child first, then each ancestor, until a node consumes it.
-enum Touchable =
-  | Enabled
-  | Disabled
-  | ChildrenOnly
-# The node's position, size, origin, scale and rotation.
-struct Transform(x: Float, y: Float, width: Float, height: Float, originX: Float, originY: Float, scaleX: Float, scaleY: Float, rotation: Float) =
-  # The transform into the parent's coordinates: translate to the position,
-  # rotate and scale about the origin.
-  fun localMatrix(self) -> Affine =
-    cs := Math.cos(self.rotation)
-    sn := Math.sin(self.rotation)
-    ma := cs * self.scaleX
-    mb := sn * self.scaleX
-    mc := 0.0 - sn * self.scaleY
-    md := cs * self.scaleY
-    Affine(
-      a: ma,
-      b: mb,
-      c: mc,
-      d: md,
-      e: self.x + self.originX - {ma * self.originX + mc * self.originY},
-      f: self.y + self.originY - {mb * self.originX + md * self.originY}
-    )
-  # Whether `p`, in the node's own coordinates, is inside its box.
-  fun contains(self, p: Vec2) -> Bool =
-    p.x >= 0.0 && p.x <= self.width && p.y >= 0.0 && p.y <= self.height
-struct Node(
-  Transform(x, y, width, height, originX, originY, scaleX, scaleY, rotation),
-  id: Int,
-  color: Color,
-  visible: Bool,
-  touchable: Touchable,
-  actions: Slice[Action],
-  kind: Kind
-) =
-  # --- building ---
-  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Node]) -> Node =
-    Node.make(id, x, y, w, h, Enabled, Group(children: children))
-  fun sprite(id: Int, tex: Texture, x: Float, y: Float, w: Float, h: Float) -> Node =
-    Node.make(id, x, y, w, h, Enabled, Sprite(tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0))
-  fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Node =
-    Node.make(id, x, y, size * 0.6 * Float(text.length()), size, Disabled, Label(text: text, size: size))
-  fun button(id: Int, text: Str, upTex: Texture, downTex: Texture, x: Float, y: Float, w: Float, h: Float) -> Node =
-    Node.make(id, x, y, w, h, Enabled, Button(text: text, upTex: upTex, downTex: downTex, pressed: false, over: false))
-  fun custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node =
-    Node.make(id, x, y, w, h, Disabled, Custom(actor: actor))
-  fun make(id: Int, x: Float, y: Float, w: Float, h: Float, touchable: Touchable, kind: Kind) -> Node =
-    Node(
-      x: x,
-      y: y,
-      width: w,
-      height: h,
-      originX: 0.0,
-      originY: 0.0,
-      scaleX: 1.0,
-      scaleY: 1.0,
-      rotation: 0.0,
-      id: id,
-      color: Color.White,
-      visible: true,
-      touchable: touchable,
-      actions: Slice[Action](),
-      kind: kind
-    )
-  # --- reading ---
-  # The children of a group, or None for anything else.
-  fun children(self) -> Option[Slice[Node]] =
-    match self.kind
-      Group(children) => Some(children)
-      _ => None
-  # The actor of a Custom node, or None for anything else.
-  fun actor(self) -> Option[Actor] =
-    match self.kind
-      Custom(actor) => Some(actor)
-      _ => None
-  # Whether `p`, in the node's own coordinates, is on it.
-  fun hit(self, p: Vec2) -> Bool =
-    self.touchable == Enabled && self.contains(p)
-  # The path (child indexes from this node) to the topmost actor under `p`, which
-  # is in the coordinates of the parent; `parent` is that parent's stage matrix.
-  fun findHit(self, parent: Affine, p: Vec2) -> Option[Slice[Int]] =
-    if !self.visible || self.touchable == Disabled
-      return None
-    m := parent * self.localMatrix()
-    inv := m.invert()
-    if inv.isNone()
-      return None
-    lp := Vec2(x: 0.0, y: 0.0)
-    if Some(q) := inv
-      lp = q.apply(p)
-    match self.kind
-      Group(ks) =>
-        i := ks.length() - 1
-        while i >= 0
-          sub := ks.at(i).findHit(m, p)
-          if Some(s) := sub
-            return Some(Node.prepend(i, s))
-          i = i - 1
-      _ => 0
-    if self.hit(lp)
-      return Some(Slice[Int]())
-    None
-  # The id of the actor at `path` below this node, or -1 if the path leads nowhere.
-  fun idAt(self, path: Slice[Int], depth: Int) -> Int =
-    if depth >= path.length()
-      return self.id
-    match self.kind
-      Group(ks) =>
-        i := path.at(depth)
-        if i >= 0 && i < ks.length()
-          return ks.at(i).idAt(path, depth + 1)
-      _ => 0
-    -1
-  # The path to the first actor with `id`, depth first; None if none.
-  fun findPath(self, id: Int) -> Option[Slice[Int]] =
-    if self.id == id
-      return Some(Slice[Int]())
-    match self.kind
-      Group(ks) =>
-        for i := range ks.length()
-          sub := ks.at(i).findPath(id)
-          if Some(s) := sub
-            return Some(Node.prepend(i, s))
-      _ => 0
-    None
-  # `i` followed by the path `rest`.
-  fun prepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
-    out := [i].toSlice()
-    for j := range rest.length()
-      out.push(rest.at(j))
-    out
-  # --- drawing ---
-  # Draws the node and its children given the parent's matrix and tint.
-  fun drawTree(self, canvas: Canvas, parent: Affine, tint: Color) =
-    if !self.visible
-      return
-    m := parent * self.localMatrix()
-    t := tint.times(self.color)
-    match self.kind
-      Group(children) =>
-        for i := range children.length()
-          children.at(i).drawTree(canvas, m, t)
-      Sprite(tex, srcX, srcY, srcW, srcH) => Node.drawSprite(canvas, m, t, self.width, self.height, tex, srcX, srcY, srcW, srcH)
-      Label(text, size) => Node.drawText(canvas, m, t, text, size)
-      Button(text, upTex, downTex, pressed, over) => Node.drawButton(canvas, self, m, t, text, upTex, downTex, pressed, over)
-      Custom(actor) => actor.draw(canvas, self, m, t)
-  fun drawSprite(canvas: Canvas, m: Affine, tint: Color, w: Float, h: Float, tex: Texture, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
-    sx := w * m.scaleX()
-    sy := h * m.scaleY()
-    c := m.apply(Vec2(x: w / 2.0, y: h / 2.0))
-    canvas.drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, tint)
-  fun drawText(canvas: Canvas, m: Affine, tint: Color, s: Str, size: Float) =
-    p := m.apply(Vec2(x: 0.0, y: 0.0))
-    canvas.drawText(s, p.x, p.y, size * m.scaleY(), tint)
-  fun drawButton(canvas: Canvas, n: Node, m: Affine, tint: Color, text: Str, upTex: Texture, downTex: Texture, pressed: Bool, over: Bool) =
-    t := upTex
-    if pressed && over
-      t = downTex
-    Node.drawSprite(canvas, m, tint, n.width, n.height, t, 0.0, 0.0, 0.0, 0.0)
-    size := n.height * 0.5
-    ox := {n.width - size * 0.6 * Float(text.length())} / 2.0
-    oy := {n.height - size} / 2.0
-    Node.drawText(canvas, m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, text, size)
-  # --- updating ---
-  # A Custom node's actor acts on it; every other node is itself.
-  fun acted(self, dt: Float) -> Node =
-    if Some(actor) := self.actor()
-      return actor.act(self, dt)
-    self
-  # The node after `dt` seconds: a Custom actor's own `act`, then its actions on its pose,
-  # then every child. The tree is changed in place and handed back.
-  fun update(self, dt: Float) -> Node =
-    b := self.acted(dt)
-    r := Action.stepAll(Pose(x: b.x, y: b.y, rotation: b.rotation, scaleX: b.scaleX, scaleY: b.scaleY), b.actions, dt)
-    b = Node(..b, x: r.pose.x, y: r.pose.y, rotation: r.pose.rotation, scaleX: r.pose.scaleX, scaleY: r.pose.scaleY)
-    match b.kind
-      Group(ks) =>
-        _ := ks.mapInPlace(|k| k.update(dt))
-      _ => 0
-    b
-  # The tree where the first actor with `id` is replaced by `f` of it.
-  fun modify(self, id: Int, f: fn(Node) -> Node) -> Node =
-    path := self.findPath(id)
-    if Some(p) := path
-      return self.modifyAt(p, 0, f)
-    self
-  fun modifyAt(self, path: Slice[Int], depth: Int, f: fn(Node) -> Node) -> Node =
-    if depth >= path.length()
-      return f(self)
-    match self.kind
-      Group(ks) =>
-        i := path.at(depth)
-        if i >= 0 && i < ks.length()
-          c := ks.takeAt(i)
-          ks.putAt(i, c.modifyAt(path, depth + 1, f))
-      _ => 0
-    self
-  # --- input ---
-  # Handles `e` (in the node's own coordinates; `over` says the pointer is on the
-  # node) and returns the new node, the events it raised and whether it consumed `e`.
-  # A Button reacts to the pointer; a Custom node asks its actor's `onInput`.
-  fun onInput(self, e: InputEvent, over: Bool) -> Handled =
-    n := self
-    ev := Slice[UiEvent]()
-    match n.kind
-      Button(text, upTex, downTex, wasPressed, wasOver) =>
-        pressed := wasPressed
-        now := wasOver
-        match e
-          PointerDown(_, _) =>
-            pressed = true
-            now = over
-            ev.push(UiEvent(id: n.id, kind: Press))
-          PointerMove(_, _) =>
-            now = over
-            if over && !wasOver
-              ev.push(UiEvent(id: n.id, kind: Enter))
-            if !over && wasOver
-              ev.push(UiEvent(id: n.id, kind: Exit))
-          PointerUp(_, _) =>
-            now = over
-            if wasPressed
-              pressed = false
-              ev.push(UiEvent(id: n.id, kind: Release))
-              if over
-                ev.push(UiEvent(id: n.id, kind: Click))
-          _ => 0
-        n = Node(..n, kind: Button(text: text, upTex: upTex, downTex: downTex, pressed: pressed, over: now))
-      Custom(actor) =>
-        return actor.onInput(n, e, over)
-      _ => 0
-    Handled(node: n, events: ev, consumed: false)
-  # Delivers `e` (in the coordinates of the parent) along `path`: the child on the
-  # path first, then this node, unless a child consumed it. A path that runs out
-  # reaches the deepest actor it can.
-  fun route(self, path: Slice[Int], depth: Int, e: InputEvent, over: Bool) -> Handled =
-    events := Slice[UiEvent]()
-    self.routeInto(path, depth, e, over, events)
-  # `route`, appending the raised events to `events` (the returned Handled holds it).
-  fun routeInto(self, path: Slice[Int], depth: Int, e: InputEvent, over: Bool, events: Slice[UiEvent]) -> Handled =
-    local := e
-    if Some(q) := self.localMatrix().invert()
-      local = e.through(q)
-    consumed := false
-    if depth < path.length()
-      match self.kind
-        Group(ks) =>
-          i := path.at(depth)
-          if i >= 0 && i < ks.length()
-            c := ks.takeAt(i)
-            h := c.routeInto(path, depth + 1, local, over, events)
-            consumed = h.consumed
-            ks.putAt(i, h.intoNode())
-        _ => 0
-    if consumed
-      return Handled(node: self, events: events, consumed: true)
-    h := self.onInput(local, over)
-    for j := range h.events.length()
-      events.push(h.events.at(j))
-    used := h.consumed
-    Handled(node: h.intoNode(), events: events, consumed: used)
-enum Kind =
-  | Group(children: Slice[Node])
-  | Sprite(tex: Texture, srcX: Float, srcY: Float, srcW: Float, srcH: Float)
-  | Label(text: Str, size: Float)
-  | Button(text: Str, upTex: Texture, downTex: Texture, pressed: Bool, over: Bool)
-  | Custom(actor: Actor)
-# Game behaviour for a `Custom` node. The defaults do nothing.
-struct Actor() =
-  # The node after `dt` seconds of this actor's behaviour; the default is itself.
-  fun act(self, n: Node, dt: Float) -> Node = n
-  # Paints the node at its stage transform `m` with the combined `tint`.
-  fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    return
-  # Handles `e` (in the node's own coordinates; `over` says the pointer is on the
-  # node). Return `consumed: true` to keep it from the node's ancestors. The
-  # default ignores it.
-  fun onInput(self, n: Node, e: InputEvent, over: Bool) -> Handled =
-    Handled(node: n, events: Slice[UiEvent](), consumed: false)
-# The node after handling an input, the events it raised, and whether it consumed
-# the input (its ancestors then do not see it).
-struct Handled(node: Node, events: Slice[UiEvent], consumed: Bool) =
-  # The node, moved out; read `events` and `consumed` first, they stay behind.
-  fun intoNode(self) -> Node =
-    match self
-      Handled(n, _, _) => n
-fun psKinds(h: Handled) -> Slice[UiKind] =
-  out := Slice[UiKind]()
-  for i := range h.events.length()
-    out.push(h.events.at(i).kind)
-  out
-fun psIsPressed(n: Node) -> Bool =
-  match n.kind
-    Button(_, _, _, pressed, _) => pressed
-    _ => false
-fun psClicks(h: Handled) -> Int =
-  n := 0
-  for i := range h.events.length()
-    if h.events.at(i).kind == Click
-      n = n + 1
-  n
-fun psDown() -> InputEvent = PointerDown(x: 1.0, y: 1.0)
-fun psUp() -> InputEvent = PointerUp(x: 1.0, y: 1.0)
-fun psMove() -> InputEvent = PointerMove(x: 1.0, y: 1.0)
-# A game actor: counts its draws and moves its node right by 1 on each act.
-struct Beacon(Actor, mut draws: Int) =
-  override fun act(self, n: Node, dt: Float) -> Node =
-    Node(..n, x: n.x + 1.0)
-  override fun draw(self, canvas: Canvas, n: Node, m: Affine, tint: Color) =
-    self.draws = self.draws + 1
-fun ttFixture() -> Node =
-  inner := [Node.sprite(4, Texture(id: 0), 0.0, 0.0, 5.0, 5.0)].toSlice()
-  kids := [Node.sprite(2, Texture(id: 0), 0.0, 0.0, 10.0, 10.0), Node.group(3, 20.0, 0.0, 10.0, 10.0, inner)].toSlice()
-  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttNoPath(r: Option[Slice[Int]]) -> Bool =
-  r.isNone()
-fun ttPathEq(r: Option[Slice[Int]], want: Slice[Int]) -> Bool =
-  if Some(p) := r
-    if p.length() != want.length()
-      return false
-    for i := range p.length()
-      if p.at(i) != want.at(i)
-        return false
-    return true
-  false
-fun ttInts(a: Int, b: Int) -> Slice[Int] =
-  out := [a, b].toSlice()
-  out
-fun ttAt(x: Float, y: Float) -> Vec2 =
-  Vec2(x: x, y: y)
-fun ttMovingTree() -> Node =
-  s := Node.sprite(2, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)
-  s2 := Node(..s, actions: [Action.moveBy(10.0, 0.0, 1.0)].toSlice())
-  kids := [s2].toSlice()
-  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttFirstKidX(a: Node) -> Float =
-  match a.kind
-    Group(k) =>
-      return k.at(0).x
-    _ => 0
-  0.0 - 1.0
-fun ttFirstKidActions(a: Node) -> Int =
-  match a.kind
-    Group(k) =>
-      return k.at(0).actions.length()
-    _ => 0
-  0 - 1
-fun ttSetTouch(t: Node, id: Int, tc: Touchable) -> Node =
-  t.modify(id, |a| ttSetTouchOf(a, tc))
-fun ttSetTouchOf(a: Node, tc: Touchable) -> Node =
-  Node(..a, touchable: tc)
-fun ttSetScaleX(a: Node) -> Node =
-  Node(..a, scaleX: 0.0)
-fun ttSetX9(a: Node) -> Node =
-  Node(..a, x: 9.0)
-fun ttKidX(a: Node, i: Int) -> Float =
-  match a.kind
-    Group(k) =>
-      return k.at(i).x
-    _ => 0
-  0.0 - 1.0
-fun ttButtonRoot() -> Node =
-  kids := [Node.button(5, "Go", Texture(id: 0), Texture(id: 1), 10.0, 10.0, 100.0, 40.0)].toSlice()
-  root := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  me: Node := root
-  me
-fun ttZero() -> Slice[Int] =
-  out := [0].toSlice()
-  out
-# Five actions on one sprite: the 1st, 3rd and 5th finish in the first 0.1s step,
-# the 2nd (MoveBy) and 4th (RotateBy) keep running.
-fun ttCompactTree() -> Node =
-  s := Node.sprite(2, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)
-  s2 := Node(..s, actions: [Action.moveBy(1.0, 0.0, 0.1), Action.moveBy(0.0, 10.0, 10.0), Action.rotateBy(1.0, 0.1), Action.rotateBy(2.0, 10.0), Action.delay(0.1)].toSlice())
-  kids := [s2].toSlice()
-  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  me
-fun ttKid(a: Node) -> Node =
-  match a.kind
-    Group(k) =>
-      return k.at(0)
-    _ => 0
-  none: Node := Node.sprite(0, Texture(id: 0), 0.0, 0.0, 0.0, 0.0)
-  none
-# 1 MoveBy, 2 RotateBy, 3 Delay, 0 anything else.
-fun ttActKind(a: Action) -> Int =
-  match a.kind
-    MoveBy(_, _, _) => 1
-    RotateBy(_, _) => 2
-    Delay(_) => 3
-    _ => 0
-# Adds 1.0 to its node's x on every act.
-struct TtStepper(Actor, ticks: Int) =
-  override fun act(self, n: Node, dt: Float) -> Node =
-    Node(..n, x: n.x + 1.0)
-test "local_matrix_translates"
-  s := Node.sprite(1, Texture(id: 0), 10.0, 0.0, 2.0, 2.0)
-  p := s.localMatrix().apply(Vec2(x: 0.0, y: 0.0))
-  assert {p.x - 10.0}.abs() < 1e-6
-  assert {p.y}.abs() < 1e-6
-test "button_click_needs_press_and_over"
-  b := Node.button(7, "go", Texture(id: 1), Texture(id: 2), 0.0, 0.0, 10.0, 10.0)
-  h1 := b.onInput(psDown(), true)
-  ks := psKinds(h1)
-  n1 := h1.events.length()
-  id1 := h1.events.at(0).id
-  h2 := h1.intoNode().onInput(psUp(), true)
-  ks.push(h2.events.at(0).kind)
-  ks.push(h2.events.at(1).kind)
-  assert n1 == 1
-  assert h2.events.length() == 2
-  assert ks.at(0) == Press
-  assert ks.at(1) == Release
-  assert ks.at(2) == Click
-  assert id1 == 7
-  assert h2.events.at(1).id == 7
-test "button_release_elsewhere_no_click"
-  b := Node.button(7, "go", Texture(id: 1), Texture(id: 2), 0.0, 0.0, 10.0, 10.0)
-  h1 := b.onInput(psDown(), true)
-  h2 := h1.intoNode().onInput(psUp(), false)
-  assert h2.events.length() == 1
-  assert h2.events.at(0).kind == Release
-  assert !psIsPressed(h2.intoNode())
-test "button_drag_off_and_back_one_click"
-  b := Node.button(7, "go", Texture(id: 1), Texture(id: 2), 0.0, 0.0, 10.0, 10.0)
-  a1 := b.onInput(psDown(), true).intoNode()
-  h2 := a1.onInput(psMove(), false)
-  c2 := psClicks(h2)
-  h3 := h2.intoNode().onInput(psMove(), true)
-  c3 := psClicks(h3)
-  h4 := h3.intoNode().onInput(psUp(), true)
-  assert c2 + c3 + psClicks(h4) == 1
-test "on_pointer_hands_back_changed_actor"
-  b := Node.button(7, "go", Texture(id: 1), Texture(id: 2), 0.0, 0.0, 10.0, 10.0)
-  h := b.onInput(psDown(), true)
-  assert psIsPressed(h.intoNode())
-test "custom_actor_act_and_draw_dispatch"
-  beacon := Beacon(draws: 0)
-  n := Node.custom(7, 2.0, 0.0, 8.0, 8.0, beacon)
-  canvas := Canvas(io: io)
-  n.drawTree(canvas, Affine.Identity, Color.White)
-  assert beacon.draws == 1
-  moved := n.acted(0.016)
-  assert moved.x == 3.0
-test "draw_tree_nested_groups_reaches_custom"
-  beacon := Beacon(draws: 0)
-  inner := Node.group(2, 0.0, 0.0, 10.0, 10.0, [Node.custom(3, 1.0, 1.0, 4.0, 4.0, beacon)].toSlice())
-  root := Node.group(1, 0.0, 0.0, 10.0, 10.0, [inner].toSlice())
-  canvas := Canvas(io: io)
-  root.drawTree(canvas, Affine.Identity, Color.White)
-  assert beacon.draws == 1
-test "hit_box_and_children_of"
-  s := Node.sprite(1, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)
-  assert s.hit(Vec2(x: 5.0, y: 5.0))
-  assert !s.hit(Vec2(x: 11.0, y: 5.0))
-  assert s.children().isNone()
-  assert Node.group(2, 0.0, 0.0, 1.0, 1.0, [s].toSlice()).children().isSome()
-test "button_move_raises_enter_then_exit"
-  b := Node.button(7, "go", Texture(id: 1), Texture(id: 2), 0.0, 0.0, 10.0, 10.0)
-  h1 := b.onInput(psMove(), true)
-  assert h1.events.length() == 1
-  assert h1.events.at(0).kind == Enter
-  h2 := h1.intoNode().onInput(psMove(), false)
-  assert h2.events.length() == 1
-  assert h2.events.at(0).kind == Exit
-  assert !psIsPressed(h2.intoNode())
-test "on_pointer_non_button_raises_nothing"
-  s := Node.sprite(1, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)
-  h := s.onInput(psDown(), true)
-  assert h.events.length() == 0
-  assert h.intoNode().id == 1
-test "draw_tree_skips_invisible_custom"
-  beacon := Beacon(draws: 0)
-  n := Node.custom(7, 0.0, 0.0, 8.0, 8.0, beacon)
-  n2 := Node(..n, visible: false)
-  canvas := Canvas(io: io)
-  n2.drawTree(canvas, Affine.Identity, Color.White)
-  assert beacon.draws == 0
-test "find_hit_nested"
-  r := ttFixture().findHit(Affine.Identity, ttAt(21.0, 1.0))
-  assert ttPathEq(r, ttInts(1, 0))
-test "find_hit_miss"
-  assert ttNoPath(ttFixture().findHit(Affine.Identity, ttAt(200.0, 200.0)))
-test "id_at_paths"
-  t := ttFixture()
-  assert t.idAt(ttInts(1, 0), 0) == 4
-  five := [5].toSlice()
-  assert t.idAt(five, 0) == -1
-  assert t.idAt(Slice[Int](), 0) == 1
-test "find_path_ids"
-  t := ttFixture()
-  assert ttPathEq(t.findPath(4), ttInts(1, 0))
-  assert ttNoPath(t.findPath(99))
-test "update_runs_actions_and_children"
-  n := ttMovingTree().update(0.5)
-  assert {ttFirstKidX(n) - 5.0}.abs() < 1e-6
-  assert ttFirstKidActions(n) == 1
-test "update_changes_tree_in_place"
-  t := ttMovingTree()
-  n := t.update(0.5)
-  assert ttFirstKidX(n) == 5.0
-  assert ttFirstKidActions(n) == 1
-test "disabled_group_hides_subtree"
-  t := ttSetTouch(ttFixture(), 3, Disabled)
-  r := t.findHit(Affine.Identity, ttAt(21.0, 1.0))
-  assert ttPathEq(r, Slice[Int]())
-test "children_only_group_not_hit_itself"
-  t := ttSetTouch(ttFixture(), 3, ChildrenOnly)
-  r := t.findHit(Affine.Identity, ttAt(28.0, 8.0))
-  assert ttPathEq(r, Slice[Int]())
-test "scale_zero_not_hit"
-  t := ttFixture().modify(2, |a| ttSetScaleX(a))
-  r := t.findHit(Affine.Identity, ttAt(1.0, 1.0))
-  assert ttPathEq(r, Slice[Int]())
-test "topmost_child_wins"
-  kids := [Node.sprite(2, Texture(id: 0), 0.0, 0.0, 10.0, 10.0), Node.sprite(3, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)].toSlice()
-  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  r := me.findHit(Affine.Identity, ttAt(1.0, 1.0))
-  want := [1].toSlice()
-  assert ttPathEq(r, want)
-test "modify_changes_first_match_only"
-  kids := [Node.sprite(7, Texture(id: 0), 0.0, 0.0, 10.0, 10.0), Node.sprite(7, Texture(id: 0), 0.0, 0.0, 10.0, 10.0)].toSlice()
-  root := Node.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Node := root
-  n := me.modify(7, |a| ttSetX9(a))
-  assert ttKidX(n, 0) == 9.0
-  assert ttKidX(n, 1) == 0.0
-test "route_child_first_then_group"
-  g := ttButtonRoot()
-  h1 := g.route(ttZero(), 0, PointerDown(x: 20.0, y: 20.0), true)
-  n1 := h1.events.length()
-  k1 := h1.events.at(0).kind
-  h2 := h1.intoNode().route(ttZero(), 0, PointerUp(x: 20.0, y: 20.0), true)
-  assert n1 == 1
-  assert k1 == Press
-  assert h2.events.length() == 2
-  assert h2.events.at(0).kind == Release
-  assert h2.events.at(1).kind == Click
-  assert h2.events.at(1).id == 5
-test "stale_path_reaches_group_only"
-  nine := [9].toSlice()
-  h := ttButtonRoot().route(nine, 0, PointerDown(x: 20.0, y: 20.0), true)
-  assert h.events.length() == 0
-test "compaction_keeps_order"
-  n := ttCompactTree().update(0.1)
-  acts := ttKid(n).actions
-  assert acts.length() == 2
-  assert ttActKind(acts.at(0)) == 1
-  assert ttActKind(acts.at(1)) == 2
-  assert {ttKid(n).x - 1.0}.abs() < 1e-6
-  assert {ttKid(n).y - 0.1}.abs() < 1e-6
-  assert {ttKid(n).rotation - 1.02}.abs() < 1e-6
-  # The next step advances the right survivors: MoveBy 0.1 -> 0.6, RotateBy 0.1 -> 0.6.
-  m := n.update(0.5)
-  acts2 := ttKid(m).actions
-  assert acts2.length() == 2
-  assert ttActKind(acts2.at(0)) == 1
-  assert ttActKind(acts2.at(1)) == 2
-  assert actElapsed(acts2.at(0)) == 0.6
-  assert {ttKid(m).y - 0.6}.abs() < 1e-6
-  assert {ttKid(m).rotation - 1.12}.abs() < 1e-6
-  assert {ttKid(m).x - 1.0}.abs() < 1e-6
-test "update_runs_custom_actor_act"
-  c := Node.custom(9, 1.0, 0.0, 4.0, 4.0, TtStepper(ticks: 0))
-  n := Node.group(1, 0.0, 0.0, 10.0, 10.0, [c].toSlice()).update(0.016)
-  assert ttFirstKidX(n) == 2.0

std/game/pure/SceneInput.plum DELETED Viewed

@@ -1,313 +0,0 @@
-module std
-import std/Int
-import std/Float
-import std/Str
-import std/Slice
-import std/game/Vec2
-import std/game/Color
-import std/game/Affine
-import std/game/Game
-import std/game/pure/Actions
-import std/game/pure/PureScene
-import std/game/Input
-import std/List
-import std/Option
-# The root of a pure scene tree, its camera, pointer capture and keyboard focus. A
-# Stage is an unique value: `input` and `frame` take it, change it in place and hand
-# it back inside a StageHandled (`intoStage` moves it out). A press captures the
-# actor it landed on: moves and the release go to that actor until the release,
-# even when the pointer leaves it (scene2d's touch focus). The pressed actor also
-# takes the keyboard focus: keys go to it first (then its ancestors), and keys no
-# node consumes come back in `StageHandled.keys` for the game. The id stored with a
-# path guards against the tree changing under it.
-struct Capture(path: Slice[Int], id: Int) =
-  # Whether the captured path is `p` or leads into it (the pointer is over the actor).
-  fun within(self, p: Slice[Int]) -> Bool =
-    a := self.path
-    if a.length() > p.length()
-      return false
-    for i := range a.length()
-      if a.at(i) != p.at(i)
-        return false
-    true
-# The stage after some inputs, the UI events raised and the keys no node consumed.
-struct StageHandled(stage: Stage, events: Slice[UiEvent], keys: Slice[InputEvent]) =
-  # The stage, moved out; read `events` and `keys` first, they stay behind.
-  fun intoStage(self) -> Stage =
-    match self
-      StageHandled(s, _, _) => s
-struct Stage(root: Node, camera: Affine, captured: Option[Capture], focus: Option[Int]) =
-  # A stage over `root` with no camera transform, nothing captured and no focus.
-  fun create(root: Node) -> Stage =
-    Stage(root: root, camera: Affine.Identity, captured: None, focus: None)
-  # Handles one input: routes it, returns the new stage and the events raised.
-  fun input(self, e: InputEvent) -> StageHandled =
-    if !e.isPointer()
-      return self.key(e)
-    none := Slice[UiEvent]()
-    inv := self.camera.invert()
-    if inv.isNone()
-      return StageHandled(stage: self, events: none, keys: Slice[InputEvent]())
-    q := inv.unwrap()
-    world := e.through(q)
-    at := world.position().unwrapOr(Vec2(x: 0.0, y: 0.0))
-    hit := self.root.findHit(Affine.Identity, at)
-    # A capture is valid only while its path still leads to its actor.
-    cap: Option[Capture] := None
-    if Some(c) := self.captured
-      if self.root.idAt(c.path, 0) == c.id
-        cap = Some(c)
-    match world
-      PointerDown(_, _) =>
-        if Some(p) := hit
-          id := self.root.idAt(p, 0)
-          return Stage(..self, focus: Some(id)).deliver(p, world, true, Some(Capture(path: p, id: id)))
-        return StageHandled(stage: Stage(..self, captured: None, focus: None), events: none, keys: Slice[InputEvent]())
-      _ => 0
-    if Some(c) := cap
-      over := false
-      if Some(p) := hit
-        over = c.within(p)
-      match world
-        PointerUp(_, _) =>
-          return self.deliver(c.path, world, over, None)
-        _ => 0
-      return self.deliver(c.path, world, over, Some(c))
-    # Hover without a press: route to whatever is under the pointer.
-    match world
-      PointerMove(_, _) =>
-        if Some(p) := hit
-          return self.deliver(p, world, true, None)
-      _ => 0
-    StageHandled(stage: self.withCapture(None), events: none, keys: Slice[InputEvent]())
-  # A key goes to the focused actor (then its ancestors); unconsumed, it is returned.
-  fun key(self, e: InputEvent) -> StageHandled =
-    left := [e].toSlice()
-    if Some(f) := self.focus
-      if Some(p) := self.root.findPath(f)
-        events := Slice[UiEvent]()
-        match self
-          Stage(root, camera, captured, focus) =>
-            h := root.routeInto(p, 0, e, true, events)
-            if h.consumed
-              left = Slice[InputEvent]()
-            return StageHandled(stage: Stage(root: h.intoNode(), camera: camera, captured: captured, focus: focus), events: events, keys: left)
-    StageHandled(stage: self, events: Slice[UiEvent](), keys: left)
-  fun withCapture(self, c: Option[Capture]) -> Stage =
-    Stage(..self, captured: c)
-  fun deliver(self, path: Slice[Int], e: InputEvent, over: Bool, c: Option[Capture]) -> StageHandled =
-    events := Slice[UiEvent]()
-    match self
-      Stage(root, camera, _, focus) =>
-        h := root.routeInto(path, 0, e, over, events)
-        StageHandled(stage: Stage(root: h.intoNode(), camera: camera, captured: c, focus: focus), events: events, keys: Slice[InputEvent]())
-  # Handles the inputs in order, then advances the tree by `dt`.
-  fun frame(self, dt: Float, inputs: Slice[InputEvent]) -> StageHandled =
-    cur := self
-    out := Slice[UiEvent]()
-    keys := Slice[InputEvent]()
-    for i := range inputs.length()
-      h := cur.input(inputs.at(i))
-      for j := range h.events.length()
-        out.push(h.events.at(j))
-      for j := range h.keys.length()
-        keys.push(h.keys.at(j))
-      cur = h.intoStage()
-    match cur
-      Stage(root, camera, captured, focus) => StageHandled(stage: Stage(root: root.update(dt), camera: camera, captured: captured, focus: focus), events: out, keys: keys)
-  # Paints the tree through the camera.
-  fun draw(self, canvas: Canvas) =
-    self.root.drawTree(canvas, self.camera, Color.White)
-fun inBtnTree() -> Node =
-  b: Node := Node.button(5, "Go", Texture(id: 0), Texture(id: 1), 10.0, 10.0, 100.0, 40.0)
-  kids := [b].toSlice()
-  g: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  g
-fun inBtnPressed(s: Stage) -> Bool =
-  if Some(k) := s.root.children()
-    return psIsPressed(k.at(0))
-  false
-fun inBtnOver(s: Stage) -> Bool =
-  if Some(k) := s.root.children()
-    return inOverOf(k.at(0))
-  false
-fun inOverOf(a: Node) -> Bool =
-  match a.kind
-    Button(_, _, _, _, over) => over
-    _ => false
-fun inDown(x: Float, y: Float) -> InputEvent =
-  PointerDown(x: x, y: y)
-fun inUp(x: Float, y: Float) -> InputEvent =
-  PointerUp(x: x, y: y)
-fun inMove(x: Float, y: Float) -> InputEvent =
-  PointerMove(x: x, y: y)
-fun inClicks(events: Slice[UiEvent]) -> Int =
-  n := 0
-  for i := range events.length()
-    if events.at(i).kind == Click
-      n = n + 1
-  n
-fun inXformTree() -> Node =
-  b: Node := Node.button(5, "Go", Texture(id: 0), Texture(id: 1), 10.0, 10.0, 100.0, 40.0)
-  kids := [b].toSlice()
-  g := Node.group(1, 100.0, 0.0, 800.0, 600.0, kids)
-  g2 := Node(..g, rotation: 1.5707963267948966, scaleX: 2.0, scaleY: 2.0)
-  me: Node := g2
-  me
-# A custom actor that moves its node right on its key and reports presses.
-struct KeyMover(Actor, key: Int) =
-  override fun onInput(self, n: Node, e: InputEvent, over: Bool) -> Handled =
-    match e
-      KeyDown(k) =>
-        if k == self.key
-          return Handled(node: Node(..n, x: n.x + 1.0), events: Slice[UiEvent](), consumed: true)
-      PointerDown(_, _) =>
-        return Handled(node: n, events: [UiEvent(id: n.id, kind: Press)].toSlice(), consumed: true)
-      _ => 0
-    Handled(node: n, events: Slice[UiEvent](), consumed: false)
-fun inMoverTree() -> Node =
-  m: Node := Node.custom(8, 10.0, 10.0, 50.0, 50.0, KeyMover(key: Key.KeyA))
-  m2 := Node(..m, touchable: Enabled)
-  g: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, [m2].toSlice())
-  g
-fun inFirstX(s: Stage) -> Float =
-  if Some(k) := s.root.children()
-    return k.at(0).x
-  0.0 - 1.0
-test "press_sets_capture"
-  h := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  assert h.events.length() == 1
-  assert h.events.at(0).kind == Press
-  assert h.events.at(0).id == 5
-  if Some(c) := h.stage.captured
-    assert c.id == 5
-  else
-    assert false
-test "release_elsewhere_no_click"
-  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  h2 := h1.intoStage().input(inUp(500.0, 500.0))
-  assert h2.events.length() == 1
-  assert h2.events.at(0).kind == Release
-  assert h2.events.at(0).id == 5
-  assert h2.stage.captured.isNone()
-  assert !inBtnPressed(h2.stage)
-test "drag_off_and_back_one_click"
-  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  c1 := inClicks(h1.events)
-  h2 := h1.intoStage().input(inMove(500.0, 500.0))
-  c2 := inClicks(h2.events)
-  h3 := h2.intoStage().input(inMove(20.0, 20.0))
-  c3 := inClicks(h3.events)
-  h4 := h3.intoStage().input(inUp(20.0, 20.0))
-  assert c1 + c2 + c3 + inClicks(h4.events) == 1
-test "stale_capture_dropped"
-  h1 := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  empty: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Node]())
-  swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured, focus: None)
-  h2 := swapped.input(inUp(20.0, 20.0))
-  assert h2.events.length() == 0
-  assert h2.stage.captured.isNone()
-test "hover_without_press_routes_move"
-  h := Stage.create(inBtnTree()).input(inMove(20.0, 20.0))
-  assert inBtnOver(h.stage)
-  assert h.stage.captured.isNone()
-test "camera_maps_screen_to_world"
-  cam := Affine(a: 2.0, b: 0.0, c: 0.0, d: 2.0, e: 0.0, f: 0.0)
-  s := Stage(root: inBtnTree(), camera: cam, captured: None, focus: None)
-  h := s.input(inDown(40.0, 40.0))
-  assert h.events.length() == 1
-  assert h.events.at(0).kind == Press
-  assert h.events.at(0).id == 5
-test "frame_handles_inputs_then_updates"
-  spr := Node.sprite(6, Texture(id: 0), 300.0, 300.0, 10.0, 10.0)
-  acts := [Action.moveBy(10.0, 0.0, 1.0)].toSlice()
-  spr2 := Node(..spr, actions: acts)
-  b: Node := Node.button(5, "Go", Texture(id: 0), Texture(id: 1), 10.0, 10.0, 100.0, 40.0)
-  sp: Node := spr2
-  kids := [b, sp].toSlice()
-  root: Node := Node.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  ins := [inDown(20.0, 20.0), inUp(20.0, 20.0)].toSlice()
-  h := Stage.create(root).frame(0.5, ins)
-  assert h.events.length() == 3
-  assert h.events.at(0).kind == Press
-  assert h.events.at(1).kind == Release
-  assert h.events.at(2).kind == Click
-  if Some(k) := h.stage.root.children()
-    assert {k.at(1).x - 305.0}.abs() < 0.000001
-  else
-    assert false
-test "hit_and_route_agree_for_rotated_scaled_group"
-  # local (20,20) in the button's parent maps to world (100 - 2*20, 2*20) = (60,40)
-  t := inXformTree()
-  hit := t.findHit(Affine.Identity, Vec2(x: 60.0, y: 40.0))
-  assert hit.isSome()
-  h := Stage(root: t, camera: Affine.Identity, captured: None, focus: None).input(inDown(60.0, 40.0))
-  assert h.events.length() == 1
-  assert h.events.at(0).id == 5
-  miss := Stage(root: inXformTree(), camera: Affine.Identity, captured: None, focus: None).input(inDown(20.0, 20.0))
-  assert miss.events.length() == 0
-test "input_changes_stage_in_place"
-  h := Stage.create(inBtnTree()).input(inDown(20.0, 20.0))
-  assert h.stage.captured.isSome()
-  assert inBtnPressed(h.stage)
-test "custom_actor_gets_pointer_through_on_input"
-  h := Stage.create(inMoverTree()).input(inDown(20.0, 20.0))
-  assert h.events.length() == 1
-  assert h.events.at(0).id == 8
-  assert h.stage.focus.unwrapOr(-1) == 8
-test "focused_actor_consumes_its_key"
-  h1 := Stage.create(inMoverTree()).input(inDown(20.0, 20.0))
-  h2 := h1.intoStage().input(KeyDown(key: Key.KeyA))
-  assert h2.keys.length() == 0
-  assert inFirstX(h2.stage) == 11.0
-test "unconsumed_and_unfocused_keys_go_to_the_game"
-  h1 := Stage.create(inMoverTree()).input(KeyDown(key: Key.KeyA))
-  assert h1.keys.length() == 1
-  assert inFirstX(h1.stage) == 10.0
-  h2 := Stage.create(inMoverTree()).input(inDown(20.0, 20.0))
-  h3 := h2.intoStage().input(KeyDown(key: Key.KeyB))
-  assert h3.keys.length() == 1
-test "frame_collects_unconsumed_keys"
-  ins := [inDown(20.0, 20.0), KeyDown(key: Key.KeyA), KeyDown(key: Key.Space)].toSlice()
-  h := Stage.create(inMoverTree()).frame(0.0, ins)
-  assert h.keys.length() == 1
-  assert inFirstX(h.stage) == 11.0