3c9dcee | plum | pyrossh

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

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

3c9dcee — Peter John 2026-11-02T20:04:16+05:30

T9: Scene on trait Actor

Files changed (6) hide show

README.md +19 -7
plum-examples/scene.plum +154 -42
plum-game/web-test/BENCHMARK.md +15 -0
plum-game/web-test/fixtures/stress_scene.plum +75 -28
plum-game/web-test/fixtures/stress_world.plum +3 -3
plum-std/game/Scene.plum +360 -288

README.md CHANGED Viewed

@@ -1080,22 +1080,34 @@ Games run in the browser on Plum's own WebGPU renderer (`plum-game/web/plum_brid
 `plum-examples/game.plum` is a small arcade game: steer a ship with the arrow keys or WASD, collect orbs, dodge mines (Enter restarts). It draws shapes, text, additive orb glow (`blendMode(Blend.Add)`) and an animated sprite sheet (`plum-examples/assets/sprites.png`, generated by `plum-examples/tools/make_sprites.py`) and plays music and sound effects (`plum-examples/assets/*.wav`, generated by `plum-examples/tools/make_sounds.py`); both generators live outside the asset dir so they are not shipped. For a bigger game built on this engine see the Knights and Merchants port in the sibling repo `../kam_plum` (`./run.sh` there). Its rules are plain functions with `test` blocks, so `plum test plum-examples` covers them without a browser.
-**`std/game/Scene`** is a scene-graph library written in Plum (see [`plum-examples/scene.plum`](plum-examples/scene.plum)): a tree of `Node`s (group, sprite, rect, circle, text) under a `Stage`, with parent-relative position, rotation, scale and colour, per-node `act` behaviours, a camera and hit testing; its demo renders a minimap into a texture with `textureCreate` and `renderTarget`. Use it for UI and other hierarchical scenes, where moving a parent should move everything in it. For a large world, keep the game objects in flat records and lists instead (for example `enum Entity = Unit | House` with an `update` and a `draw` that the enum dispatches to its variants) and draw them directly through `std/game/Game`; a tree of thousands of nodes costs a closure call and a matrix composition per node every frame.
+**`std/game/Scene`** is a scene-graph library written in Plum (see [`plum-examples/scene.plum`](plum-examples/scene.plum)): a tree of actors under a `Stage`, with parent-relative position, rotation, scale and colour, per-actor `act`, `draw` and `hit` behaviour, a camera and hit testing; its demo renders a minimap into a texture with `textureCreate` and `renderTarget`. Use it for UI and other hierarchical scenes, where moving a parent should move everything in it. It is libGDX Scene2D-style subclassing on a [trait](#traits): `Actor` is a trait holding the position, size, origin, scale, rotation, colour, visibility, children and culling fields, and `Group`, `Sprite`, `Rect`, `Circle` and `Text` are records embedding it. A game adds its own kinds the same way and overrides what it needs:
-`std/game/Scene` follows libGDX Scene2D for draw order and culling. A node's z-index is its position in its parent's child list (draw order is list order, hit testing goes in reverse):
+```plum
+record Walker(Actor, speed: Float) =
+  fun act(self, dt: Float) =
+    self.x = self.x + self.speed * dt
+  fun draw(self, m: Affine, alpha: Float) =
+    drawRectBox(m, alpha, self.width, self.height, self.color)
+stage.root.add(Walker(x: 0.0, y: 0.0, width: 8.0, height: 8.0, originX: 0.0, originY: 0.0, scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.Red, visible: true, children: List[Actor](), parent: null, scratch: List[Actor](), cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0, speed: 30.0))
+```
+The default `act` acts the children (an override that keeps children calls `self.actChildren(dt)`), the default `draw` paints nothing and the default `hit(p)` tests the width by height box. Compare actors with `same(a, b)`, not `==` (a trait value is a new wrapper each time a record is converted). Every trait field is read and written through a dispatch over the program's actor kinds, so a hot loop that reads fields from outside the trait (a y-sort key over 20,000 actors) costs several times a closure-based node ([`BENCHMARK.md`](plum-game/web-test/BENCHMARK.md)); code inside the trait's default methods reads them directly. For a large world, keep the game objects in flat records and lists instead (for example `enum Entity = Unit | House`) and draw them directly through `std/game/Game`.
+`std/game/Scene` follows libGDX Scene2D for draw order and culling. An actor's z-index is its position in its parent's child list (draw order is list order, hit testing goes in reverse):
 ```plum
-n.zIndex()                              # index among its siblings, -1 without a parent
+a.zIndex()                              # index among its siblings, -1 without a parent
-n.setZIndex(0)                          # move within the parent (clamped to 0..length-1)
+a.setZIndex(0)                          # move within the parent (clamped to 0..length-1)
-n.toFront()                             # last child: drawn on top, hit first
+a.toFront()                             # last child: drawn on top, hit first
-n.toBack()                              # first child: drawn first
+a.toBack()                              # first child: drawn first
 world.sortChildren(|a, b| a.y < b.y)    # stable, in place, no allocation once warm
 world.setCullingArea(cam.x, cam.y, viewW, viewH)   # in world's own coordinates
 world.clearCullingArea()
 ```
-`sortChildren(before)` is a natural merge sort with a scratch list kept on the node: a list that is already sorted costs n - 1 comparisons and a nearly sorted one (a y-sorted layer re-sorted every frame) about 2n, with O(n log n) as the worst case; equal keys keep their order, so ties do not flicker. `setCullingArea` makes a group skip each direct child whose box (position and size, scaled about its origin; rotation ignored) lies outside the rectangle, in both `draw` and `hit`, with the child's whole subtree; children with no size (plain groups) are never culled. In [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) a 20,000-sprite y-sorted layer costs 1.15 ms per frame with culling and 4.20 ms without.
+`sortChildren(before)` is a natural merge sort with a scratch list kept on the actor: a list that is already sorted costs n - 1 comparisons and a nearly sorted one (a y-sorted layer re-sorted every frame) about 2n, with O(n log n) as the worst case; equal keys keep their order, so ties do not flicker. `setCullingArea` makes a group skip each direct child whose box (position and size, scaled about its origin; rotation ignored) lies outside the rectangle, in both `draw` and `hit`, with the child's whole subtree; children with no size (plain groups) are never culled. In [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) a 20,000-sprite y-sorted layer costs 1.15 ms per frame with culling and 4.20 ms without on the earlier closure-based `Node` (2.09 ms with culling on `trait Actor`, which pays a dispatch per field read in the sort).
 A layered world (a layer recipe for a large map) is a few groups under the stage root, drawn in order: `terrain` (static, culled), `world` (y-sorted every frame, culled), `effects` (culled) and `ui` (not culled, in screen space with a second `Stage` or camera). Each frame: `world.sortChildren(|a, b| a.y < b.y)`, then `setCullingArea` on `terrain`, `world` and `effects` from the camera view.

plum-examples/scene.plum CHANGED Viewed

@@ -36,47 +36,88 @@ primitive Layout =
   WalkMin = 500.0
   WalkMax = 1300.0
+# Actor kinds of this game: `record X(Actor, ...)` embeds the scene's `Actor` trait, so
+# an X 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.
+record Orbit(Actor, speed: Float) =
+  fun create(speed: Float) -> Orbit =
+    Orbit(
+      x: 0.0, y: 0.0, width: 0.0, height: 0.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      speed: speed)
+  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.
+record Spinner(Actor, speed: Float, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
+  fun create(sheet: Int, sx: Float, sy: Float, size: Float, speed: Float) -> Spinner =
+    Spinner(
+      x: 0.0, y: 0.0, width: size, height: size, originX: size / 2.0, originY: size / 2.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      speed: speed, tex: sheet, srcX: sx, srcY: sy, srcW: Layout.Cell, srcH: Layout.Cell)
+  fun act(self, dt: Float) =
+    self.rotation = self.rotation + self.speed * dt
+    self.actChildren(dt)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawSpriteFrame(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.
+record Walker(Actor, pace: Float, phase: Float, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
+  fun create(sheet: Int, sx: Float, pace: Float, phase: Float) -> Walker =
+    Walker(
+      x: 0.0, y: 0.0, width: 24.0, height: 24.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      pace: pace, phase: phase, tex: sheet, srcX: sx, srcY: Layout.Cell, srcW: Layout.Cell, srcH: Layout.Cell)
+  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)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawSpriteFrame(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).
 record Sky(
   stage: Stage,
-  bodies: List[Node],
+  bodies: List[Actor],
-  halos: List[Node],
+  halos: List[Actor],
   names: List[Str],
-  sun: Node,
+  sun: Spinner,
-  label: Node,
+  label: Text,
-  crowd: Node,
+  crowd: Group,
-  front: Node?,
+  front: Actor?,
   selected: Int,
   clock: Float,
   paused: Bool,
   map: Int)
-# Gives the node a behaviour that turns it `speed` radians per second.
-fun spun(n: Node, speed: Float) -> Node =
-  turn := |m, dt|
-    m.rotation = m.rotation + speed * dt
-  n.setAct(turn)
-# A walker's behaviour: it moves along x at `speed` and bobs on a wave of its x.
-fun walking(n: Node, pace: Float, phase: Float) -> Node =
-  step: fn(Node, Float) := |m, dt|
-    nx := m.x + dt * pace
-    if nx > Layout.WalkMax
-      nx = 0.0 - Layout.WalkMin
-    if nx < 0.0 - Layout.WalkMin
-      nx = Layout.WalkMax
-    _ := m.at(nx, 510.0 + 50.0 * Math.sin(nx / 90.0 + phase))
-  n.setAct(step)
 # 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: Int, name: Str, row: Int, frame: Int, size: Float, spin: Float) -> Node =
+fun addBody(sky: Sky, sheet: Int, name: Str, row: Int, frame: Int, size: Float, spin: Float) -> Actor =
-  slot := Node.group()
+  slot := Group.create()
-  halo := Node.circle(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 := 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 := Node.sprite(sheet, Float(frame) * Layout.Cell, Float(row) * Layout.Cell, Layout.Cell, Layout.Cell, size, size).at(0.0 - size / 2.0, 0.0 - size / 2.0).centerOrigin()
+  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)
-  body = spun(body, spin)
   slot.add(halo)
   slot.add(body)
   sky.halos.push(halo)
@@ -86,28 +127,32 @@ fun addBody(sky: Sky, sheet: Int, name: Str, row: Int, frame: Int, size: Float,
 fun newSky(sheet: Int) -> Sky =
   stage := Stage.create()
-  backdrop := Node.rect(Layout.Width, Layout.Height, Color.rgb(0.04, 0.05, 0.1))
+  backdrop := Rect.create(Layout.Width, Layout.Height, Color.rgb(0.04, 0.05, 0.1))
   stage.root.add(backdrop)
   for i := range 40
-    star := Node.circle(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))
+    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 := spun(Node.sprite(sheet, 0.0, Layout.Cell, Layout.Cell, Layout.Cell, 96.0, 96.0).at(Layout.CenterX - 48.0, Layout.CenterY - 48.0).centerOrigin(), 0.3)
+  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 := Node.text("Click a planet", 24.0, Color.White).at(16.0, 12.0)
+  label := Text.create("Click a planet", 24.0, Color.White)
+  label.x = 16.0
+  label.y = 12.0
   sky := Sky(
-    stage: stage, bodies: List[Node](), halos: List[Node](), names: List[Str](),
+    stage: stage, bodies: List[Actor](), halos: List[Actor](), names: List[Str](),
-    sun: sun, label: label, crowd: Node.group(), front: null, selected: -1, clock: 0.0, paused: false, map: -1)
+    sun: sun, label: label, crowd: Group.create(), front: null, selected: -1, clock: 0.0, paused: false, map: -1)
   # 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(Node.circle(r, Color(r: 1.0, g: 1.0, b: 1.0, a: 0.04)).at(Layout.CenterX - r, Layout.CenterY - r))
+    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 := List("Ember", "Cinder", "Ashen", "Glacier")
   moons := List(0, 1, 2, 1)
   for i := range Layout.Planets
-    orbit := spun(Node.group().at(Layout.CenterX, Layout.CenterY), 0.9 / Float(1 + i))
+    orbit := Orbit.create(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 := spun(Node.group(), 2.0 + Float(m))
+      moonOrbit := Orbit.create(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)
@@ -117,8 +162,8 @@ fun newSky(sheet: Int) -> Sky =
     speed := 20.0 + Float(i % 7) * 9.0
     if i % 2 == 0
       speed = 0.0 - speed
-    walker := Node.sprite(sheet, Float(i % 3) * Layout.Cell, Layout.Cell, Layout.Cell, Layout.Cell, 24.0, 24.0).at(Layout.WalkMax - 1800.0 + Float(i * 61 % 1800), 510.0)
+    walker := Walker.create(sheet, Float(i % 3) * Layout.Cell, speed, Float(i)).at(Layout.WalkMax - 1800.0 + Float(i * 61 % 1800), 510.0)
-    sky.crowd.add(walking(walker, speed, Float(i)))
+    sky.crowd.add(walker)
   stage.root.add(sky.crowd)
   stage.root.add(label)
   sky
@@ -132,9 +177,9 @@ fun fit(sky: Sky, sw: Float, sh: Float) =
   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: Node) -> Int =
+fun indexOf(sky: Sky, n: Actor) -> Int =
   for i := range sky.bodies.length()
-    if sky.bodies.at(i) == n || sky.halos.at(i) == n
+    if same(sky.bodies.at(i), n) || same(sky.halos.at(i), n)
       return i
   -1
@@ -155,7 +200,7 @@ fun clickAt(sky: Sky, x: Float, y: Float) =
   if n := sky.stage.hit(x, y)
     i = indexOf(sky, n)
     if p := n.parent
-      if p == sky.crowd
+      if p.children == sky.crowd.children
         n.toFront()
         sky.front = n
   if i == sky.selected
@@ -226,6 +271,38 @@ export fun draw(sky: Sky) =
 # --- 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.
+record ProbeSpinner(Actor) =
+  fun create() -> ProbeSpinner =
+    ProbeSpinner(
+      x: 0.0, y: 0.0, width: 0.0, height: 0.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
+  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.
+record ProbeWalker(Actor, speed: Float, drawn: Int) =
+  fun create(speed: Float) -> ProbeWalker =
+    ProbeWalker(
+      x: 0.0, y: 0.0, width: 10.0, height: 10.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      speed: speed, drawn: 0)
+  fun act(self, dt: Float) =
+    self.x = self.x + self.speed * dt
+  fun draw(self, m: Affine, alpha: Float) =
+    self.drawn = self.drawn + 1
 fun near(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 0.01
@@ -323,3 +400,38 @@ test "clicking a walker brings it to the front, even after the next sort"
   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.create()
+  stage.root.add(g)
+  k := ProbeSpinner.create()
+  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.create(4.0)
+  stage.root.add(w)
+  stage.root.add(Group.create())
+  stage.act(0.5)
+  stage.act(0.5)
+  assert near(w.x, 4.0)
+  assert w.drawn == 0
+  stage.root.drawTree(Affine.Identity, 1.0)
+  stage.root.drawTree(Affine.Identity, 1.0)
+  assert w.drawn == 2
+  w.visible = false
+  stage.root.drawTree(Affine.Identity, 1.0)
+  assert w.drawn == 2
+  w.visible = true
+  # a trait value reaches the same record
+  a: Actor := w
+  a.act(1.0)
+  assert near(w.x, 8.0)
+  assert same({stage.hit(8.5, 5.0) ?: crash "miss"}, w)

plum-game/web-test/BENCHMARK.md CHANGED Viewed

@@ -112,3 +112,18 @@ Fixture `stress_world.plum`: one world layer with 20,000 sprites in a 4000x2300
 | stress_scene, 5.8k nodes (reference) | 1.71 | 1.9 | 584 | 0.060 | 1.251 | 0.261 |
 With culling the frame costs about what the 2,000 visible sprites cost, not what the 20,000 nodes cost: 1.15 ms against 4.20 ms without it (3.7x), and below the 5k-node `stress_scene` (1.71 ms), which draws every node. Culling removes draw (2.92 -> 0.52 ms) and render (0.69 -> 0.09 ms, 20,000 against about 2,000 sprites reaching the batcher); what stays is `update` at about 0.42 ms, which is the y-sort's O(n) scan over all 20,000 children (n - 1 comparisons through the closure, about 20 ns each, plus the merge of the few displaced sprites) and the 500 walkers. So the remaining cost grows with total nodes through the sort and the `act` walk, but at a fraction of a draw, and the draw side now scales with what is on screen.
+## Scene on `trait Actor` vs closure `Node`
+`std/game/Scene` moved from one `Node` record with `act: fn(Node, Float)` closures to `trait Actor` with records embedding it (`Group`, `Sprite`, ... and the game's own, such as `Walker`). Same machine and method as above (headed, gpu per-call, `--uncapped --measure 10 --frames-wait 6`, two runs per cell). The fixtures were ported 1:1 (same node counts and motion); in `stress_scene` each node kind became a record with its own `act` and `draw`.
+| fixture | version | avg ms (2 runs) | p95 | update | draw | render |
+|---|---|---|---|---|---|---|
+| stress_scene, 5.8k nodes | closure `Node` | 1.60, 1.62 | 1.7-1.8 | 0.055 | 1.19-1.20 | 0.24 |
+| stress_scene, 5.8k nodes | `trait Actor` | 1.69, 1.69 | 1.8 | 0.039 | 1.27 | 0.26 |
+| stress_world, 20k nodes, culling on | closure `Node` | 1.09, 1.09 | 1.2 | 0.421 | 0.495 | 0.082 |
+| stress_world, 20k nodes, culling on | `trait Actor` | 2.09, 2.12 | 2.3-2.4 | 1.29-1.31 | 0.59 | 0.09 |
+- `stress_scene`: +5% (1.60 -> 1.69 ms), at the edge of noise. The per-node closure call became a trait dispatch, which is cheaper (`update` 0.055 -> 0.039 ms); `draw` grew by 0.08 ms because the draw walk reads child fields through the trait.
+- `stress_world`: +92% (1.09 -> 2.09 ms), above the 10% threshold. All of it is `update`, which here is the y-sort: `sortChildren(|a, b| a.y < b.y)` makes 2 x 19,999 `a.y` reads per frame and every read of a trait field is a dispatch (`__get_y`) over the program's actor kinds, about 30-40 ns each against about 10 ns for a direct field read. Without the sort `update` is 0.01 ms. The cost scales with the number of actor kinds in the program: dropping two unused test-only kinds took `update` from 1.65 to 1.29 ms, which is why the Scene tests that need their own `act`/`draw` records live in `plum-examples/scene.plum` and not in `std/game/Scene.plum`. Draw is +0.1 ms (culling and transforms run as trait default methods, so they read fields directly, one dispatch per child).
+- Reading the trait's fields from outside it (a game's sort key, hit tests on `.x`/`.y`) is the price of the trait. Default methods run on the concrete record and read its fields directly, which is why `local()`, `outside()`, `drawTree()` and `hitTree()` are trait methods rather than free functions.

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

@@ -1,7 +1,7 @@
 # The stress scene of stress.plum built as a Scene2D-like scene graph (std/game/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` behaviour, so each frame runs ~5800 closures and a composed-transform draw.
+# `act`, so each frame runs ~5800 trait-dispatched acts and a composed-transform draw.
 module stress_scene
 import std/Str
 import std/Int
@@ -26,31 +26,78 @@ record Demo(sheet: Int, 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)
+# The actor kinds of this scene: records embedding the Actor trait, each with its own `act`.
+record SpinGroup(Actor) =
+  fun create() -> SpinGroup =
+    SpinGroup(
+      x: 0.0, y: 0.0, width: 0.0, height: 0.0, originX: 75.0, originY: 85.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
-fun spinGroup(n: Node, dt: Float) =
+  fun act(self, dt: Float) =
-  n.rotation = n.rotation + 0.004
+    self.rotation = self.rotation + 0.004
+    self.actChildren(dt)
 # Turns the sprite; its frame follows the angle, advancing every 6 frames.
+record Dancer(Actor, tex: Int, srcX: Float) =
+  fun create(tex: Int, srcX: Float) -> Dancer =
+    Dancer(
+      x: 0.0, y: 0.0, width: 16.0, height: 16.0, originX: 8.0, originY: 8.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      tex: tex, srcX: srcX)
-fun animateSprite(n: Node, dt: Float) =
+  fun act(self, dt: Float) =
-  n.rotation = n.rotation + 0.02
+    self.rotation = self.rotation + 0.02
-  n.srcX = Float(Int(n.rotation * 50.0) / 6 % 4 * 16)
+    self.srcX = Float(Int(self.rotation * 50.0) / 6 % 4 * 16)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawSpriteFrame(m, alpha, self.width, self.height, self.color, self.tex, self.srcX, 0.0, 16.0, 16.0)
+record DriftRect(Actor) =
+  fun create(c: Color) -> DriftRect =
+    DriftRect(
+      x: 0.0, y: 0.0, width: 12.0, height: 8.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
-fun driftRect(n: Node, dt: Float) =
+  fun act(self, dt: Float) =
-  n.x = n.x + 2.0
+    self.x = self.x + 2.0
-  if n.x > Float(Counts.WorldW)
+    if self.x > Float(Counts.WorldW)
-    n.x = n.x - Float(Counts.WorldW)
+      self.x = self.x - Float(Counts.WorldW)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawRectBox(m, alpha, self.width, self.height, self.color)
+record DriftCircle(Actor) =
+  fun create(c: Color) -> DriftCircle =
+    DriftCircle(
+      x: 0.0, y: 0.0, width: 12.0, height: 12.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
-fun driftCircle(n: Node, dt: Float) =
+  fun act(self, dt: Float) =
-  n.x = n.x + 3.0
+    self.x = self.x + 3.0
-  n.y = n.y + 1.0
+    self.y = self.y + 1.0
-  if n.x > Float(Counts.WorldW)
+    if self.x > Float(Counts.WorldW)
-    n.x = n.x - Float(Counts.WorldW)
+      self.x = self.x - Float(Counts.WorldW)
-  if n.y > Float(Counts.WorldH)
+    if self.y > Float(Counts.WorldH)
-    n.y = n.y - Float(Counts.WorldH)
+      self.y = self.y - Float(Counts.WorldH)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawDisc(m, alpha, self.width / 2.0, self.color)
-# `tex` is the number shown.
+# `n` is the number shown.
+record CountText(Actor, n: Int, text: Str) =
+  fun create(n: Int) -> CountText =
+    CountText(
+      x: 0.0, y: 0.0, width: 60.0, height: 14.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      n: n, text: "n {n}")
-fun countText(n: Node, dt: Float) =
+  fun act(self, dt: Float) =
-  n.tex = n.tex + 1
+    self.n = self.n + 1
-  n.text = "n {n.tex}"
+    self.text = "n {self.n}"
+  fun draw(self, m: Affine, alpha: Float) =
+    drawLabel(m, alpha, self.text, 14.0, self.color)
 export fun init() -> Demo =
   sheet := textureLoad("sprites.png")
@@ -58,21 +105,21 @@ export fun init() -> Demo =
   stage.camScale = 0.8
   per := Counts.Sprites / Counts.Groups
   for gi := range Counts.Groups
-    g := Node.group().at(Float(gi % 10 * 160), Float(gi / 10 * 180)).setOrigin(75.0, 85.0).setAct(spinGroup)
+    g := SpinGroup.create().at(Float(gi % 10 * 160), Float(gi / 10 * 180))
     for j := range per
       i := gi * per + j
+      s := Dancer.create(sheet, Float(i % 4 * 16))
-      s := Node.sprite(sheet, Float(i % 4 * 16), 0.0, 16.0, 16.0, 16.0, 16.0).at(Float({j * j * 13 + j * 37} % 150), Float({j * j * 29 + j * 53} % 170)).centerOrigin().setAct(animateSprite)
+      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(Node.rect(12.0, 8.0, hue(i)).at(Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH)).setAct(driftRect))
+    stage.root.add(DriftRect.create(hue(i)).at(Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH)))
   for i := range Counts.Circles
-    stage.root.add(Node.circle(6.0, hue(i + 3)).at(Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH)).setAct(driftCircle))
+    stage.root.add(DriftCircle.create(hue(i + 3)).at(Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH)))
   for i := range Counts.Texts
-    t := Node.text("n {i}", 14.0, Color.White).at(Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)).setAct(countText)
+    stage.root.add(CountText.create(i).at(Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
-    t.tex = i
-    stage.root.add(t)
   Demo(sheet: sheet, stage: stage)
 export fun update(g: Demo, dt: Float) =

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

@@ -23,17 +23,17 @@ primitive World =
   ViewH = 720.0
   Culling = 1
-record Demo(sheet: Int, stage: Stage, layer: Node, frame: Int)
+record Demo(sheet: Int, stage: Stage, layer: Group, frame: Int)
 fun spriteAt(i: Int) -> Vec2 =
   Vec2(x: Float({i * 7919 + 13} % World.Width), y: Float({i * i * 31 / 7 + i * 1013} % World.Height))
 fun build(sheet: Int) -> Demo =
   stage := Stage.create()
-  layer := Node.group()
+  layer := Group.create()
   for i := range World.Sprites
     p := spriteAt(i)
-    layer.add(Node.sprite(sheet, Float(i % 4 * 16), 0.0, 16.0, 16.0, 16.0, 16.0).at(p.x, p.y))
+    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)

plum-std/game/Scene.plum CHANGED Viewed

@@ -8,20 +8,31 @@ import std/game/Vec2
 import std/game/Color
 import std/game/Game
-# A Scene2D-like scene graph: a tree of `Node`s under a `Stage`. A node has a
+# A Scene2D-like scene graph: a tree of actors under a `Stage`. `Actor` is a trait;
+# every kind of actor is a `record` that embeds it (`Group`, `Sprite`, `Rect`,
+# `Circle`, `Text` here, your own `record Walker(Actor, speed: Float)` in a game).
-# position, size, origin (the pivot of its rotation and scale), scale, rotation
+# An actor has a position, size, origin (the pivot of its rotation and scale),
-# (radians, clockwise), colour, visibility and children. Children are placed in
+# scale, rotation (radians, clockwise), colour, visibility and children. Children
-# their parent's coordinates, so moving, turning or scaling a group moves
+# are placed in their parent's coordinates, so moving, turning or scaling a group
-# everything in it. Colour alpha multiplies down the tree and an invisible node
+# moves everything in it. Colour alpha multiplies down the tree and an invisible
-# hides its whole subtree.
+# actor hides its whole subtree.
+#
+# A record 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 := Node.group()
+#   ring := Group.create()
 #   stage.root.add(ring)
-#   ring.add(Node.rect(40.0, 20.0, Color.Red).at(10.0, 5.0))
+#   ring.add(Rect.create(40.0, 20.0, Color.Red).at(10.0, 5.0))
-#   stage.act(dt)   # runs every node's `act` behaviour, depth first
+#   stage.act(dt)   # runs every actor's `act`, depth first
 #   stage.draw()    # draws through `std/game/Game`
 #
+# Actors are compared with `same(a, b)` (a trait value is a fresh wrapper each time
+# it is converted, so `==` would not tell). A record built for the tree sets every
+# trait field; copy `Group.create()` for the list.
+#
 # The transform maths (`Affine`, `localMatrix`, `worldMatrix`, `flatten`,
 # `hitNode`) never calls the host, so it runs under `plum test`.
 #
@@ -31,14 +42,6 @@ import std/game/Game
 # scale, since the host has no rotated shapes. Non-uniform scale under rotation
 # (skew) is not supported for drawing; hit testing handles it exactly.
-# What a node draws.
-primitive NodeKind =
-  Group = 0
-  Sprite = 1
-  Rect = 2
-  Circle = 3
-  Text = 4
 # A 2D affine transform: x' = a*x + c*y + e, y' = b*x + d*y + f.
 struct Affine(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) =
@@ -80,91 +83,77 @@ struct Affine(a: Float, b: Float, c: Float, d: Float, e: Float, f: Float) =
   fun rotation(self) -> Float =
     Math.atan2(self.b, self.a)
-record Node(
+trait Actor(
   x: Float, y: Float, width: Float, height: Float,
   originX: Float, originY: Float,
   scaleX: Float, scaleY: Float,
   rotation: Float,
   color: Color,
   visible: Bool,
-  children: List[Node],
+  children: List[Actor],
-  parent: Node?,
+  parent: Actor?,
-  kind: Int,
-  tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float,
-  text: Str, size: Float,
+  scratch: List[Actor],
-  acting: Bool,
-  act: fn(Node, Float),
-  cull: Bool, cullX: Float, cullY: Float, cullW: Float, cullH: Float,
+  cull: Bool, cullX: Float, cullY: Float, cullW: Float, cullH: Float) =
-  scratch: List[Node]) =
-  fun make(kind: Int, w: Float, h: Float, c: Color) -> Node =
-    Node(
-      x: 0.0, y: 0.0, width: w, height: h, originX: 0.0, originY: 0.0,
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
-      children: List[Node](), parent: null, kind: kind,
-      tex: -1, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0, text: "", size: 0.0,
-      acting: false, act: noAct,
-      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0, scratch: List[Node]())
+  # This actor's behaviour. The default acts the children; an override that keeps
-  # A node that only holds children.
+  # children calls `self.actChildren(dt)` too.
-  fun group() -> Node =
+  fun act(self, dt: Float) =
+    self.actChildren(dt)
-    Node.make(NodeKind.Group, 0.0, 0.0, Color.White)
+  fun actChildren(self, dt: Float) =
+    i := 0
+    while i < self.children.length()
+      self.children.at(i).act(dt)
+      i = i + 1
-  # A texture region (sx, sy, sw, sh in texture pixels) drawn w by h.
+  # Paints this actor only, given its stage transform `m` and accumulated alpha.
-  fun sprite(tex: Int, sx: Float, sy: Float, sw: Float, sh: Float, w: Float, h: Float) -> Node =
-    n := Node.make(NodeKind.Sprite, w, h, Color.White)
+  # The default paints nothing (a group).
-    n.tex = tex
-    n.srcX = sx
-    n.srcY = sy
-    n.srcW = sw
-    n.srcH = sh
-    n
-  fun rect(w: Float, h: Float, c: Color) -> Node =
+  fun draw(self, m: Affine, alpha: Float) =
-    Node.make(NodeKind.Rect, w, h, c)
+    return
-  # A circle of radius r whose bounding box has its top-left at the node's position.
+  # 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 circle(r: Float, c: Color) -> Node =
+  fun hit(self, p: Vec2) -> Bool =
-    Node.make(NodeKind.Circle, r * 2.0, r * 2.0, c)
-  # Text with its top-left at the node's position; the size is an estimate of the extent.
+    self.width > 0.0 && self.height > 0.0 && p.x >= 0.0 && p.x <= self.width && p.y >= 0.0 && p.y <= self.height
-  fun text(s: Str, size: Float, c: Color) -> Node =
-    n := Node.make(NodeKind.Text, size * 0.6 * Float(s.length()), size, c)
-    n.text = s
-    n.size = size
-    n
-  fun at(self, x: Float, y: Float) -> Node =
+  fun at(self, x: Float, y: Float) -> Actor =
     self.x = x
     self.y = y
     self
-  fun setOrigin(self, ox: Float, oy: Float) -> Node =
+  fun setOrigin(self, ox: Float, oy: Float) -> Actor =
     self.originX = ox
     self.originY = oy
     self
-  fun centerOrigin(self) -> Node =
+  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 setAct(self, f: fn(Node, Float)) -> Node =
+  fun childIndex(self, c: Actor) -> Int =
+    for i := range self.children.length()
+      if self.children.at(i).children == c.children
-    self.act = f
+        return i
-    self.acting = true
-    self
+    -1
   # Appends a child (taking it from its previous parent) so it draws after its siblings.
-  fun add(self, child: Node) =
+  fun add(self, child: Actor) =
     if p := child.parent
-      p.children.remove(child)
+      p.detach(child)
     child.parent = 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: Node) =
+  fun remove(self, child: Actor) =
     if p := child.parent
-      if p == self
-        self.children.remove(child)
+      if p.children == self.children
+        self.detach(child)
         child.parent = null
   fun clear(self) =
@@ -172,15 +161,13 @@ record Node(
       self.children.at(i).parent = null
     self.children.clear()
-  # The node's index among its siblings (its draw order), -1 without a parent.
+  # The actor's index among its siblings (its draw order), -1 without a parent.
   fun zIndex(self) -> Int =
     if p := self.parent
-      for i := range p.children.length()
-        if p.children.at(i) == self
+      return p.childIndex(self)
-          return i
     -1
-  # Moves the node to index `i` of its parent's children (clamped to the valid
+  # 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 p := self.parent
@@ -192,13 +179,14 @@ record Node(
         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, self)
+      d.set(base + dst, me)
   # Draws last (on top) and is hit first.
   fun toFront(self) =
@@ -216,9 +204,9 @@ record Node(
   # 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 node's own `scratch` list, which keeps its capacity between calls, so
+  # 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(Node, Node) -> Bool) =
+  fun sortChildren(self, before: fn(Actor, Actor) -> Bool) =
     n := self.children.length()
     d := self.children.data
     base := self.children.start
@@ -238,8 +226,8 @@ record Node(
           i = b
       runs = {runs + 1} / 2
-  # Culls this node's direct children against the rectangle (x, y, w, h), in this
+  # Culls this actor's direct children against the rectangle (x, y, w, h), in this
-  # node's own coordinates: a child whose box (position and size, scaled about its
+  # 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) =
@@ -252,19 +240,188 @@ record Node(
   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, parent: Affine, alpha: Float) =
+    if !self.visible
+      return
+    m := parent * self.local()
+    a := alpha * self.color.a
+    self.draw(m, a)
+    n := self.children.length()
+    for i := range n
+      kid := self.children.at(i)
+      if !self.culls(kid)
+        kid.drawTree(m, a)
+  fun collect(self, parent: Affine, alpha: Float, out: List[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) -> Actor? =
+    if !self.visible
+      return null
+    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 found := child.hitTree(q)
+          return found
+    if self.hit(q)
+      me: Actor := self
+      return me
+    null
-  # A point in this node's coordinates, in the stage's.
+  # A point in this actor's coordinates, in the stage's.
   fun localToStage(self, p: Vec2) -> Vec2 =
+    me: Actor := self
-    worldMatrix(self).apply(p)
+    worldMatrix(me).apply(p)
-  # A point in the stage's coordinates, in this node's.
+  # A point in the stage's coordinates, in this actor's.
   fun stageToLocal(self, p: Vec2) -> Vec2 =
+    me: Actor := self
-    worldMatrix(self).inverse().apply(p)
+    worldMatrix(me).inverse().apply(p)
+# Whether two actor values are the same actor (they share the children list).
+fun same(a: Actor, b: Actor) -> Bool =
+  a.children == b.children
+# An actor that only holds children.
+record Group(Actor) =
+  fun create() -> Group =
+    Group(
+      x: 0.0, y: 0.0, width: 0.0, height: 0.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
+# A texture region (srcX, srcY, srcW, srcH in texture pixels) drawn width by height.
+record Sprite(Actor, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
+  fun create(tex: Int, sx: Float, sy: Float, sw: Float, sh: Float, w: Float, h: Float) -> Sprite =
+    Sprite(
+      x: 0.0, y: 0.0, width: w, height: h, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      tex: tex, srcX: sx, srcY: sy, srcW: sw, srcH: sh)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawSpriteFrame(m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
+record Rect(Actor) =
+  fun create(w: Float, h: Float, c: Color) -> Rect =
+    Rect(
+      x: 0.0, y: 0.0, width: w, height: h, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawRectBox(m, alpha, self.width, self.height, self.color)
+record Circle(Actor) =
+  # 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(
+      x: 0.0, y: 0.0, width: r * 2.0, height: r * 2.0, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawDisc(m, alpha, self.width / 2.0, self.color)
+record Text(Actor, 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(
+      x: 0.0, y: 0.0, width: size * 0.6 * Float(s.length()), height: size, originX: 0.0, originY: 0.0,
+      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
+      children: List[Actor](), parent: null, scratch: List[Actor](),
+      cull: false, cullX: 0.0, cullY: 0.0, cullW: 0.0, cullH: 0.0,
+      text: s, size: size)
+  fun draw(self, m: Affine, alpha: Float) =
+    drawLabel(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(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))
+  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(m: Affine, alpha: Float, r: Float, color: Color) =
+  c := m.apply(Vec2(x: r, y: r))
+  drawCircle(c.x, c.y, r * m.scaleX(), color.withAlpha(alpha))
+# Draws text with its top-left at the transform `m`.
+fun drawLabel(m: Affine, alpha: Float, s: Str, size: Float, color: Color) =
+  p := m.apply(Vec2(x: 0.0, y: 0.0))
+  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(m: Affine, alpha: Float, w: Float, h: Float, color: Color, tex: Int, 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))
+  drawTextureEx(tex, srcX, srcY, srcW, srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, color.withAlpha(alpha))
-fun noAct(n: Node, dt: Float) =
-  n.x = n.x
 # The end of the ascending run of `d` starting at `i` (exclusive), within n.
-fun sortRunEnd(d: Array[Node], base: Int, i: Int, n: Int, before: fn(Node, Node) -> Bool) -> Int =
+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
@@ -273,7 +430,7 @@ fun sortRunEnd(d: Array[Node], base: Int, i: Int, n: Int, before: fn(Node, Node)
 # 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: List[Node], d: Array[Node], base: Int, lo: Int, a: Int, b: Int, before: fn(Node, Node) -> Bool) =
+fun sortMerge(scratch: List[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
@@ -318,136 +475,57 @@ fun sortMerge(scratch: List[Node], d: Array[Node], base: Int, lo: Int, a: Int, b
     i = i + 1
     o = o + 1
-# Whether `parent` culls `c`: the child's box in the parent's coordinates lies
-# outside the parent's culling area.
-fun culled(parent: Node, c: Node) -> Bool =
-  if !parent.cull || c.width == 0.0 && c.height == 0.0
-    return false
-  w := c.width * c.scaleX
-  h := c.height * c.scaleY
-  x := c.x + c.originX - c.originX * c.scaleX
-  y := c.y + c.originY - c.originY * c.scaleY
-  if w < 0.0
-    x = x + w
-    w = 0.0 - w
-  if h < 0.0
-    y = y + h
-    h = 0.0 - h
-  x > parent.cullX + parent.cullW || x + w < parent.cullX || y > parent.cullY + parent.cullH || y + h < parent.cullY
-# The node's transform into its parent's coordinates: translate to the position,
+# The actor's transform into its parent's coordinates.
-# rotate and scale about the origin.
-fun localMatrix(n: Node) -> Affine =
+fun localMatrix(n: Actor) -> Affine =
-  cs := Math.cos(n.rotation)
-  sn := Math.sin(n.rotation)
-  a := cs * n.scaleX
-  b := sn * n.scaleX
-  c := 0.0 - sn * n.scaleY
-  d := cs * n.scaleY
-  Affine(
+  n.local()
-    a: a, b: b, c: c, d: d,
-    e: n.x + n.originX - {a * n.originX + c * n.originY},
-    f: n.y + n.originY - {b * n.originX + d * n.originY})
-# The node's transform into stage coordinates.
+# The actor's transform into stage coordinates.
-fun worldMatrix(n: Node) -> Affine =
+fun worldMatrix(n: Actor) -> Affine =
   if p := n.parent
-    worldMatrix(p) * localMatrix(n)
+    worldMatrix(p) * n.local()
   else
-    localMatrix(n)
+    n.local()
-# One entry of the draw list: a visible node, its stage transform and its alpha.
+# One entry of the draw list: a visible actor, its stage transform and its alpha.
-record Drawn(node: Node, m: Affine, alpha: Float)
+record Drawn(node: Actor, m: Affine, alpha: Float)
-fun collect(n: Node, parent: Affine, alpha: Float, out: List[Drawn]) =
-  if !n.visible
-    return
-  m := parent * localMatrix(n)
-  a := alpha * n.color.a
-  out.push(Drawn(node: n, m: m, alpha: a))
-  for i := range n.children.length()
-    kid := n.children.at(i)
-    if !culled(n, kid)
-      collect(kid, m, a, out)
 # What `draw` would draw, in order: a parent before its children, siblings in
 # list order, invisible and culled subtrees left out.
-fun flatten(root: Node) -> List[Drawn] =
+fun flatten(root: Actor) -> List[Drawn] =
   out := List[Drawn]()
-  collect(root, Affine.Identity, 1.0, out)
+  root.collect(Affine.Identity, 1.0, out)
   out
-fun drawNode(n: Node, parent: Affine, alpha: Float) =
+fun drawNode(n: Actor, parent: Affine, alpha: Float) =
-  if !n.visible
-    return
-  m := parent * localMatrix(n)
-  a := alpha * n.color.a
-  if n.kind == NodeKind.Sprite
-    sx := n.width * m.scaleX()
-    sy := n.height * m.scaleY()
-    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
-    drawTextureEx(n.tex, n.srcX, n.srcY, n.srcW, n.srcH, c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, m.rotation(), false, n.color.withAlpha(a))
-  else if n.kind == NodeKind.Rect
-    sx := n.width * m.scaleX()
-    sy := n.height * m.scaleY()
-    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
-    drawRect(c.x - sx / 2.0, c.y - sy / 2.0, sx, sy, n.color.withAlpha(a))
-  else if n.kind == NodeKind.Circle
-    r := n.width / 2.0
-    c := m.apply(Vec2(x: r, y: r))
-    drawCircle(c.x, c.y, r * m.scaleX(), n.color.withAlpha(a))
-  else if n.kind == NodeKind.Text
-    p := m.apply(Vec2(x: 0.0, y: 0.0))
-    drawText(n.text, p.x, p.y, n.size * m.scaleY(), n.color.withAlpha(a))
-  for i := range n.children.length()
-    kid := n.children.at(i)
-    if !culled(n, kid)
-      drawNode(kid, m, a)
+  n.drawTree(parent, alpha)
-fun actNode(n: Node, dt: Float) =
+fun actNode(n: Actor, dt: Float) =
-  if n.acting
+  n.act(dt)
-    f := n.act
-    f(n, dt)
-  i := 0
-  while i < n.children.length()
-    actNode(n.children.at(i), dt)
-    i = i + 1
-# The topmost visible node under `p`, a point in the node's parent's coordinates:
+# The topmost visible actor under `p`, a point in the actor's parent's coordinates.
-# children before the node itself, later siblings before earlier ones. A node is
-# hit inside its width by height box; a group with no size is never hit itself.
-fun hitNode(n: Node, p: Vec2) -> Node? =
+fun hitNode(n: Actor, p: Vec2) -> Actor? =
-  if !n.visible
-    return null
+  n.hitTree(p)
-  q := localMatrix(n).inverse().apply(p)
-  for i := range n.children.length()
-    child := n.children.at(n.children.length() - 1 - i)
-    if !culled(n, child)
-      if found := hitNode(child, q)
-        return found
-  if n.width > 0.0 && n.height > 0.0 && q.x >= 0.0 && q.x <= n.width && q.y >= 0.0 && q.y <= n.height
-    return n
-  null
-# A root node plus a camera (the world point at the screen's top-left and the
+# A root actor plus a camera (the world point at the screen's top-left and the
 # pixels per world unit, as in `setCamera`).
-record Stage(root: Node, camX: Float, camY: Float, camScale: Float) =
+record Stage(root: Actor, camX: Float, camY: Float, camScale: Float) =
   fun create() -> Stage =
-    Stage(root: Node.group(), camX: 0.0, camY: 0.0, camScale: 1.0)
+    Stage(root: Group.create(), camX: 0.0, camY: 0.0, camScale: 1.0)
-  # Runs every node's behaviour, parents before children, in insertion order.
+  # Runs every actor's `act`, parents before children, in insertion order.
   fun act(self, dt: Float) =
-    actNode(self.root, dt)
+    self.root.act(dt)
   fun draw(self) =
     setCamera(self.camX, self.camY, self.camScale)
-    drawNode(self.root, Affine.Identity, 1.0)
+    self.root.drawTree(Affine.Identity, 1.0)
     resetCamera()
-  # The topmost visible node at a stage point.
+  # The topmost visible actor at a stage point.
-  fun hit(self, x: Float, y: Float) -> Node? =
+  fun hit(self, x: Float, y: Float) -> Actor? =
-    hitNode(self.root, Vec2(x: x, y: y))
+    self.root.hitTree(Vec2(x: x, y: y))
   # A screen pixel in stage coordinates under this camera.
   fun screenToStage(self, sx: Float, sy: Float) -> Vec2 =
@@ -461,23 +539,20 @@ fun sceneNear(a: Float, b: Float) -> Bool =
 fun sceneNearV(p: Vec2, x: Float, y: Float) -> Bool =
   sceneNear(p.x, x) && sceneNear(p.y, y)
-fun sceneKids(n: Int) -> Node =
+fun sceneKids(n: Int) -> Group =
-  g := Node.group()
+  g := Group.create()
   for i := range n
-    g.add(Node.rect(1.0, 1.0, Color.Red).at(Float(i), 0.0))
+    g.add(Rect.create(1.0, 1.0, Color.Red).at(Float(i), 0.0))
   g
-fun sceneOrder(g: Node) -> Str =
+fun sceneOrder(g: Actor) -> Str =
   s := ""
   for i := range g.children.length()
     s = "{s}{Int(g.children.at(i).x)},"
   s
-fun sceneSpin(n: Node, dt: Float) =
-  n.rotation = n.rotation + dt
-test "a node translates; rotation and scale pivot about the origin"
+test "an actor translates; rotation and scale pivot about the origin"
-  n := Node.rect(10.0, 10.0, Color.Red).at(100.0, 50.0)
+  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
@@ -489,11 +564,11 @@ test "a node translates; rotation and scale pivot about the origin"
   assert sceneNearV(localMatrix(n).apply(Vec2(x: 10.0, y: 10.0)), 115.0, 60.0)
 test "matrices compose, and inverse undoes them"
-  g := Node.group().at(100.0, 0.0)
+  g := Group.create().at(100.0, 0.0)
   g.rotation = Float.HalfPi
   g.scaleX = 2.0
   g.scaleY = 2.0
-  k := Node.rect(10.0, 10.0, Color.Red).at(10.0, 0.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)
@@ -506,112 +581,109 @@ test "matrices compose, and inverse undoes them"
   assert sceneNearV(k.stageToLocal(Vec2(x: 80.0, y: 40.0)), 10.0, 10.0)
 test "add reparents, remove and clear detach"
-  a := Node.group()
+  a := Group.create()
-  b := Node.group()
+  b := Group.create()
-  k := Node.group()
+  k := Group.create()
   a.add(k)
   assert a.children.length() == 1
   b.add(k)
   assert a.children.length() == 0
   assert b.children.length() == 1
-  assert {k.parent ?: crash "no parent"} == b
+  assert same({k.parent ?: crash "no parent"}, b)
   b.remove(k)
   assert b.children.length() == 0
   assert k.parent == null
   b.add(k)
-  extra := Node.group()
+  extra := Group.create()
   b.add(extra)
   b.clear()
   assert b.children.length() == 0
   assert k.parent == null
 test "draw order is parent first, then children in insertion order"
-  root := Node.group()
+  root := Group.create()
-  a := Node.group()
+  a := Group.create()
   root.add(a)
-  b := Node.group()
+  b := Group.create()
   root.add(b)
-  a1 := Node.rect(1.0, 1.0, Color.Red)
+  a1 := Rect.create(1.0, 1.0, Color.Red)
   a.add(a1)
-  a2 := Node.rect(1.0, 1.0, Color.Red)
+  a2 := Rect.create(1.0, 1.0, Color.Red)
   a.add(a2)
-  b1 := Node.rect(1.0, 1.0, Color.Red)
+  b1 := Rect.create(1.0, 1.0, Color.Red)
   b.add(b1)
   list := flatten(root)
   assert list.length() == 6
-  assert list.at(0).node == root
+  assert same(list.at(0).node, root)
-  assert list.at(1).node == a
+  assert same(list.at(1).node, a)
-  assert list.at(2).node == a1
+  assert same(list.at(2).node, a1)
-  assert list.at(3).node == a2
+  assert same(list.at(3).node, a2)
-  assert list.at(4).node == b
+  assert same(list.at(4).node, b)
-  assert list.at(5).node == b1
+  assert same(list.at(5).node, b1)
 test "invisible subtrees are skipped and alpha multiplies down"
-  root := Node.group()
+  root := Group.create()
   root.color = Color.White.withAlpha(0.5)
-  g := Node.group()
+  g := Group.create()
   root.add(g)
   g.color = Color.White.withAlpha(0.5)
-  k := Node.rect(1.0, 1.0, Color.Red)
+  k := Rect.create(1.0, 1.0, Color.Red)
   g.add(k)
-  hidden := Node.group()
+  hidden := Group.create()
   root.add(hidden)
   hidden.visible = false
-  hidden.add(Node.rect(1.0, 1.0, Color.Red))
+  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 node through rotated and scaled groups"
+test "hit finds the topmost actor through rotated and scaled groups"
-  root := Node.group()
+  root := Group.create()
-  g := Node.group().at(100.0, 0.0)
+  g := Group.create().at(100.0, 0.0)
   root.add(g)
   g.rotation = Float.HalfPi
   g.scaleX = 2.0
   g.scaleY = 2.0
-  low := Node.rect(30.0, 30.0, Color.Red)
+  low := Rect.create(30.0, 30.0, Color.Red)
   g.add(low)
-  top := Node.rect(10.0, 10.0, Color.Blue).at(10.0, 0.0)
+  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 {stage.hit(90.0, 30.0) ?: crash "miss"} == top
+  assert same({stage.hit(90.0, 30.0) ?: crash "miss"}, top)
-  assert {stage.hit(70.0, 10.0) ?: crash "miss"} == low
+  assert same({stage.hit(70.0, 10.0) ?: crash "miss"}, low)
-  assert {stage.hit(60.0, 30.0) ?: crash "miss"} == low
+  assert same({stage.hit(60.0, 30.0) ?: crash "miss"}, low)
   assert stage.hit(10.0, 10.0) == null
   assert stage.hit(150.0, 30.0) == null
   top.visible = false
-  assert {stage.hit(90.0, 30.0) ?: crash "miss"} == low
+  assert same({stage.hit(90.0, 30.0) ?: crash "miss"}, low)
   g.visible = false
   assert stage.hit(90.0, 30.0) == null
 test "hit prefers later siblings and a child over its parent"
   stage := Stage.create()
-  a := Node.rect(50.0, 50.0, Color.Red)
+  a := Rect.create(50.0, 50.0, Color.Red)
   stage.root.add(a)
-  b := Node.rect(50.0, 50.0, Color.Blue).at(25.0, 0.0)
+  b := Rect.create(50.0, 50.0, Color.Blue).at(25.0, 0.0)
   stage.root.add(b)
-  inner := Node.rect(10.0, 10.0, Color.Green)
+  inner := Rect.create(10.0, 10.0, Color.Green)
   b.add(inner)
-  assert {stage.hit(10.0, 10.0) ?: crash "miss"} == a
+  assert same({stage.hit(10.0, 10.0) ?: crash "miss"}, a)
-  assert {stage.hit(30.0, 5.0) ?: crash "miss"} == inner
+  assert same({stage.hit(30.0, 5.0) ?: crash "miss"}, inner)
-  assert {stage.hit(60.0, 40.0) ?: crash "miss"} == b
+  assert same({stage.hit(60.0, 40.0) ?: crash "miss"}, b)
-  assert {stage.hit(40.0, 10.0) ?: crash "miss"} == b
+  assert same({stage.hit(40.0, 10.0) ?: crash "miss"}, b)
-test "act runs behaviours depth first, including invisible nodes"
+test "the default act runs the children's act, invisible ones included"
   stage := Stage.create()
-  g := Node.group().setAct(sceneSpin)
+  g := Group.create()
   stage.root.add(g)
-  k := Node.group().setAct(sceneSpin)
+  g.add(Rect.create(1.0, 1.0, Color.Red))
-  g.add(k)
   g.visible = false
   stage.act(0.5)
-  stage.act(0.25)
-  assert sceneNear(g.rotation, 0.75)
-  assert sceneNear(k.rotation, 0.75)
   assert stage.root.rotation == 0.0
+  assert g.children.length() == 1
 test "the screen maps to the stage through the camera"
   stage := Stage.create()
@@ -622,11 +694,11 @@ test "the screen maps to the stage through the camera"
   assert sceneNearV(p, 120.0, 60.0)
 test "sizes of sprites, circles and text"
-  assert Node.circle(5.0, Color.Red).width == 10.0
+  assert Circle.create(5.0, Color.Red).width == 10.0
-  s := Node.sprite(3, 16.0, 0.0, 16.0, 16.0, 32.0, 32.0)
+  s := Sprite.create(3, 16.0, 0.0, 16.0, 16.0, 32.0, 32.0)
   assert s.tex == 3
-  assert s.kind == NodeKind.Sprite
+  assert s.width == 32.0
-  assert Node.text("ab", 10.0, Color.White).height == 10.0
+  assert Text.create("ab", 10.0, Color.White).height == 10.0
 test "setZIndex, toFront and toBack reorder the siblings"
   g := sceneKids(4)
@@ -646,36 +718,36 @@ test "setZIndex, toFront and toBack reorder the siblings"
   assert sceneOrder(g) == "3,2,0,1,"
   b.setZIndex(-5)
   assert sceneOrder(g) == "1,3,2,0,"
-  assert Node.group().zIndex() == -1
+  assert Group.create().zIndex() == -1
-  Node.group().toFront()
+  Group.create().toFront()
   assert g.children.length() == 4
 test "sortChildren is stable and keeps ties in order"
-  g := Node.group()
+  g := Group.create()
   for i := range 10
-    k := Node.rect(1.0, 1.0, Color.Red).at(Float(i), Float(i * 7 % 3))
+    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 nodes and updates hit order"
+test "sortChildren sorts 5000 random actors and updates hit order"
-  g := Node.group()
+  g := Group.create()
   for i := range 5000
-    g.add(Node.rect(1.0, 1.0, Color.Red).at(Float(i), Float({i * 7919 + 13} % 5003)))
+    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 {g.children.at(10).parent ?: crash "orphan"} == g
+  assert same({g.children.at(10).parent ?: crash "orphan"}, g)
 test "sorting a nearly sorted list takes about n comparisons and reuses the scratch buffer"
-  g := Node.group()
+  g := Group.create()
   for i := range 5000
-    g.add(Node.rect(1.0, 1.0, Color.Red).at(0.0, Float(i)))
+    g.add(Rect.create(1.0, 1.0, Color.Red).at(0.0, Float(i)))
   c := List(0)
-  less: fn(Node, Node) -> Bool := |a, b|
+  less: fn(Actor, Actor) -> Bool := |a, b|
     _ := c.set(0, c.at(0) + 1)
     a.y < b.y
   g.sortChildren(less)
@@ -698,22 +770,22 @@ test "sorting a nearly sorted list takes about n comparisons and reuses the scra
   _ := c.set(0, 0)
   g.children.clear()
   for i := range 5000
-    g.add(Node.rect(1.0, 1.0, Color.Red).at(0.0, Float({i * 7919 + 13} % 5003)))
+    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 := Node.group()
+  g := Group.create()
-  inside := Node.rect(10.0, 10.0, Color.Red).at(20.0, 20.0)
+  inside := Rect.create(10.0, 10.0, Color.Red).at(20.0, 20.0)
-  outside := Node.rect(10.0, 10.0, Color.Red).at(500.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(Node.rect(5.0, 5.0, Color.Red))
+  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 list.at(1).node == inside
+  assert same(list.at(1).node, inside)
   g.setCullingArea(0.0, 100.0, 100.0, 100.0)
   assert flatten(g).length() == 1
   g.clearCullingArea()
@@ -721,24 +793,24 @@ test "culling skips children outside the area in flatten and draw order"
 test "hit does not return culled children, and a scaled child near the edge is kept"
   stage := Stage.create()
-  k := Node.rect(10.0, 10.0, Color.Red).at(105.0, 5.0)
+  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) == null
   k.scaleX = 4.0
   k.originX = 10.0
-  assert {stage.hit(90.0, 7.0) ?: crash "miss"} == k
+  assert same({stage.hit(90.0, 7.0) ?: crash "miss"}, k)
   assert flatten(stage.root).length() == 2
   k.scaleX = 1.0
   k.originX = 0.0
   assert stage.hit(107.0, 7.0) == null
   stage.root.clearCullingArea()
-  assert {stage.hit(107.0, 7.0) ?: crash "miss"} == k
+  assert same({stage.hit(107.0, 7.0) ?: crash "miss"}, k)
 test "a child without a size is never culled"
-  g := Node.group()
+  g := Group.create()
-  slot := Node.group().at(900.0, 900.0)
+  slot := Group.create().at(900.0, 900.0)
   g.add(slot)
-  slot.add(Node.rect(10.0, 10.0, Color.Red).at(-890.0, -890.0))
+  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