ab19e82 | plum | pyrossh

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

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

ab19e82 — Peter John 2026-11-02T20:45:48+05:30

examples: Orb Run on the scene graph (game_scene.plum); README immediate vs scene

Files changed (4) hide show

README.md +2 -0
plum-examples/game_scene.plum +600 -0
plum-game/web-test/README.md +1 -1
plum-game/web-test/tests/web_check.rs +5 -0

README.md CHANGED Viewed

@@ -1128,6 +1128,8 @@ The page calls `init` once after the assets are loaded, then `update` and `draw`
 **Headless tests:** the `plum-game` crate (a standalone crate, wasmtime only) runs a compiled game with no browser against a `Recorder` backend that logs every host call as a string and answers input from scripted values, so `cargo test --manifest-path plum-game/Cargo.toml` checks games' draw-call sequences (`plum-game/tests/host_test.rs`). `plum-game <wasm> [--assets DIR] [--frames N]` does the same from the command line and prints the host calls of the last frame.
+**Immediate mode or Scene?** [`plum-examples/game.plum`](plum-examples/game.plum) is immediate mode: one state record, a pure `update`, and `draw` issues the calls each frame; it suits flat arcade games with a few kinds of thing. [`plum-examples/scene.plum`](plum-examples/scene.plum) and [`plum-examples/game_scene.plum`](plum-examples/game_scene.plum) are retained mode on `trait Actor`: a tree with transforms, z-order, culling, hit-testing and per-kind `act`/`draw`, which suits UI, layered worlds and unit crowds. `game_scene.plum` is the same Orb Run as `game.plum` rebuilt on the scene graph, so you can compare the two styles on identical rules.
 **Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png` builds the static web version, serves it and drives headless Chromium (software WebGPU; `--browser webkit` drives Playwright's WebKit, the Safari engine, instead) through [playwright-rs](https://crates.io/crates/playwright-rs): it fails if the canvas stays blank or stops changing, or the page logs an error, and reports whether audio started. It also takes `--assets DIR`, `--require-audio`, `--measure SECS` (with `--json`, `draws` is the GPU draw calls per frame), `--headed`, `--dpr N` (a device pixel ratio of N), `--lose-device` (destroys the GPU device after a few frames and requires rendering to resume) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y)), `--expect-unsupported-webgpu` (hides `navigator.gpu` and requires the page's "WebGPU is not supported" message while plum.wasm still loads) and `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw, as Safari does). `plum-game/web-test/fixtures/` has `interleave.plum`, `text_sizes.plum` and `rendertarget.plum` for these. One-time setup: `cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers`. See [`plum-game/web-test/README.md`](plum-game/web-test/README.md); `docs/game.png` above was made with `--screenshot`. [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) records the renderer benchmark that led to this design.
 **Asset root:** textures and files are read relative to the asset root. A path that escapes the root (`..` or absolute) fails like a missing file: `-1`, `""` or `false`. The headless runner's root is `--assets` or `assets` beside the wasm; it reads image headers for `textureWidth`/`textureHeight` and records sounds without decoding them.

plum-examples/game_scene.plum ADDED Viewed

@@ -0,0 +1,600 @@
+# Orb Run on the scene graph (`plum game plum-examples/game_scene.plum`): the same game as
+# game.plum (same arena, rules, sprites, sounds, keys and scoring), rebuilt in retained
+# mode on std/game/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 record embedding the scene's `Actor` trait (`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 `stage.root`
+# (backdrop, stars, mines, orbs, ship, HUD), so `stage.act(dt)` and `stage.draw()` do
+# the per-kind work and z-order is the order of the layers. Collisions, scoring,
+# spawning, lives and restart stay in plain functions over `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/List
+import std/Math
+import std/Random
+import std/game/Vec2
+import std/game/Color
+import std/game/Game
+import std/game/Scene
+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.
+record 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`.
+fun spawn(rng: Random, ax: Float, ay: Float, gap: Float, speed: Float) -> Motion =
+  margin := 30.0
+  b := Motion(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0)
+  tries := 0
+  while tries < 20
+    b.x = margin + rng.nextFloat() * {Rules.ArenaW - 2.0 * margin}
+    b.y = margin + rng.nextFloat() * {Rules.ArenaH - 2.0 * margin}
+    if Math.hypot(b.x - ax, b.y - ay) >= gap
+      break
+    tries = tries + 1
+  heading := rng.nextFloat() * Float.Tau
+  pace := speed * {0.4 + 0.6 * rng.nextFloat()}
+  b.vx = Math.cos(heading) * pace
+  b.vy = Math.sin(heading) * pace
+  b
+# 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`.
+record Ship(Actor, vx: Float, vy: Float, ax: Float, ay: Float, hurt: Float, clock: Float, tex: Int) =
+  fun create(sheet: Int, x: Float, y: Float) -> Ship =
+    size := Rules.Cell * Rules.Zoom
+    Ship(
+      x: x, y: y, 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,
+      vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, tex: sheet)
+  # 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`).
+  fun act(self, dt: Float) =
+    self.clock = self.clock + dt
+    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}
+  fun draw(self, m: Affine, alpha: Float) =
+    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
+    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(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.
+record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
+  fun create(sheet: Int, phase: Float, at: Motion) -> Orb =
+    size := Rules.Cell * Rules.Zoom
+    Orb(
+      x: at.x, y: at.y, 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,
+      vx: at.vx, vy: at.vy, phase: phase, clock: 0.0, tex: sheet)
+  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
+  fun act(self, dt: Float) =
+    self.clock = self.clock + dt
+    m := self.motion()
+    drift(m, Rules.OrbRadius, dt)
+    self.place(m)
+  fun draw(self, m: Affine, alpha: Float) =
+    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
+    k := m.scaleX()
+    blendMode(Blend.Add)
+    drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * alpha))
+    drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * alpha))
+    blendMode(Blend.Normal)
+    frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
+    drawSpriteFrame(m, alpha, self.width, self.height, self.color, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
+# A spinning mine drifting about.
+record Mine(Actor, vx: Float, vy: Float, clock: Float, tex: Int) =
+  fun create(sheet: Int, at: Motion) -> Mine =
+    size := Rules.Cell * Rules.Zoom
+    Mine(
+      x: at.x, y: at.y, 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,
+      vx: at.vx, vy: at.vy, clock: 0.0, tex: sheet)
+  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
+  fun act(self, dt: Float) =
+    self.clock = self.clock + dt
+    m := self.motion()
+    drift(m, Rules.MineRadius, dt)
+    self.place(m)
+    self.rotation = self.rotation + 2.0 * dt
+  fun draw(self, m: Affine, alpha: Float) =
+    frame := Float(frameOf(self.clock, 4, 4.0))
+    drawSpriteFrame(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.
+record Star(Actor, seed: Float, 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,
+      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,
+      seed: Float(i), clock: 0.0)
+  fun act(self, dt: Float) =
+    self.clock = self.clock + dt
+  fun draw(self, m: Affine, alpha: Float) =
+    twinkle := 0.25 + 0.2 * Math.sin(self.clock * 2.0 + self.seed)
+    drawDisc(m, alpha, self.width / 2.0, Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
+# The whole game: the stage with 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.
+record World(
+  stage: Stage,
+  ship: Ship,
+  mines: Group,
+  orbs: Group,
+  mineList: List[Mine],
+  orbList: List[Orb],
+  overlay: Group,
+  scoreText: Text,
+  bestText: Text,
+  lifeIcons: List[Sprite],
+  rng: Random,
+  score: Int,
+  best: Int,
+  lives: Int,
+  over: Bool,
+  clock: Float,
+  sheet: Int,
+  pickupSound: Int,
+  hitSound: Int,
+  overSound: Int,
+  musicSound: Int)
+fun newWorld(seed: Int, sheet: Int) -> World =
+  rng := Random(seed: seed)
+  stage := Stage.create()
+  ship := Ship.create(sheet, Rules.ArenaW / 2.0, Rules.ArenaH / 2.0)
+  stars := Group.create()
+  for i := range 40
+    stars.add(Star.create(i))
+  mines := Group.create()
+  orbs := Group.create()
+  hud := Group.create()
+  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 := List[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.create()
+  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)
+  stage.root.add(Rect.create(Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)))
+  stage.root.add(stars)
+  stage.root.add(mines)
+  stage.root.add(orbs)
+  stage.root.add(ship)
+  stage.root.add(hud)
+  w := World(
+    stage: stage, ship: ship, mines: mines, orbs: orbs, mineList: List[Mine](), orbList: List[Orb](),
+    overlay: overlay, scoreText: scoreText, bestText: bestText, lifeIcons: icons,
+    rng: rng, score: 0, best: 0, lives: Rules.StartLives, over: false, clock: 0.0, sheet: sheet,
+    pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
+  for i := range Rules.OrbCount
+    orb := Orb.create(sheet, Float(i) * 0.1, spawn(rng, ship.x, ship.y, 120.0, 40.0))
+    orbs.add(orb)
+    w.orbList.push(orb)
+  for i := range mineCount(0)
+    addMine(w)
+  w
+# Adds one mine, far from the ship, to the mines layer.
+fun addMine(w: World) =
+  mine := Mine.create(w.sheet, spawn(w.rng, w.ship.x, w.ship.y, 220.0, 90.0))
+  w.mines.add(mine)
+  w.mineList.push(mine)
+# Starts a fresh game, keeping the best score 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
+  ship := w.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 w.orbList.length()
+    w.orbList.at(i).place(spawn(w.rng, ship.x, ship.y, 120.0, 40.0))
+  while w.mineList.length() > mineCount(0)
+    gone := w.mineList.pop()!
+    w.mines.remove(gone)
+  for i := range w.mineList.length()
+    w.mineList.at(i).place(spawn(w.rng, ship.x, ship.y, 220.0, 90.0))
+  sync(w)
+# Copies the score, best score, lives and game-over panel into the HUD actors.
+fun sync(w: World) =
+  w.scoreText.text = "Score {w.score}"
+  w.bestText.text = "Best {w.best.max(w.score)}"
+  for i := range w.lifeIcons.length()
+    w.lifeIcons.at(i).visible = i < w.lives
+  w.overlay.visible = w.over
+fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
+  Math.hypot(ax - bx, ay - by) < ra + rb
+# One simulation step: every actor acts through the stage, then the rules look at
+# the result. Does nothing once the game is over.
+fun step(w: World, ax: Float, ay: Float, dt: Float) =
+  w.clock = w.clock + dt
+  if w.over
+    return
+  w.ship.ax = ax
+  w.ship.ay = ay
+  w.stage.act(dt)
+  ship := w.ship
+  for i := range w.orbList.length()
+    orb := w.orbList.at(i)
+    if overlaps(ship.x, ship.y, Rules.ShipRadius, orb.x, orb.y, Rules.OrbRadius)
+      w.score = w.score + Rules.OrbPoints
+      orb.place(spawn(w.rng, ship.x, ship.y, 120.0, 40.0))
+  while w.mineList.length() < mineCount(w.score)
+    addMine(w)
+  for i := range w.mineList.length()
+    mine := w.mineList.at(i)
+    if ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, mine.x, mine.y, Rules.MineRadius)
+      w.lives = w.lives - 1
+      ship.hurt = Rules.HurtTime
+      if w.lives <= 0
+        w.over = true
+        w.best = w.best.max(w.score)
+        ship.visible = false
+  sync(w)
+# Fits the arena into a screen of `sw` by `sh` pixels, centred.
+fun fit(w: World, sw: Float, sh: Float) =
+  zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
+  w.stage.camScale = zoom
+  w.stage.camX = 0.0 - {sw / zoom - Rules.ArenaW} / 2.0
+  w.stage.camY = 0.0 - {sh / zoom - Rules.ArenaH} / 2.0
+# --- host glue: input, sound, drawing ---
+fun musicVolume() -> Float =
+  0.3
+# Restarts the music loop from the top.
+fun startMusic(w: World) =
+  soundStop(w.musicSound)
+  soundLoop(w.musicSound, musicVolume())
+export fun init() -> World =
+  w := newWorld(2024, textureLoad("sprites.png"))
+  w.pickupSound = soundLoad("pickup.wav")
+  w.hitSound = soundLoad("hit.wav")
+  w.overSound = soundLoad("gameover.wav")
+  w.musicSound = soundLoad("music.wav")
+  startMusic(w)
+  w
+fun axis(negative: Bool, positive: Bool) -> Float =
+  if negative && !positive
+    -1.0
+  else if positive && !negative
+    1.0
+  else
+    0.0
+export fun update(w: World, dt: Float) =
+  if w.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+    restart(w)
+    startMusic(w)
+  left := isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+  right := isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+  up := isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+  down := isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+  score := w.score
+  lives := w.lives
+  step(w, axis(left, right), axis(up, down), dt)
+  if w.score > score
+    soundPlay(w.pickupSound, 0.8)
+  if w.lives < lives
+    if w.over
+      soundStop(w.musicSound)
+      soundPlay(w.overSound, 1.0)
+    else
+      soundPlay(w.hitSound, 1.0)
+export fun draw(w: World) =
+  fit(w, screenWidth(), screenHeight())
+  clear(Color.rgb(0.04, 0.05, 0.1))
+  w.stage.draw()
+# --- tests ---
+fun near(a: Float, b: Float) -> Bool =
+  {a - b}.abs() < 0.01
+# A world with the orbs and mines moved out of the way.
+fun emptyWorld() -> World =
+  w := newWorld(7, -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
+test "steering accelerates and drag slows the ship"
+  ship := Ship.create(-1, 400.0, 300.0)
+  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.create(-1, 20.0, 20.0)
+  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(-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(-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 := newWorld(7, -1)
+  assert w.stage.root.children.length() == 6
+  assert w.stage.root.children.at(1).children.length() == 40
+  assert w.mines.children.length() == mineCount(0)
+  assert w.orbs.children.length() == Rules.OrbCount
+  assert same(w.stage.root.children.at(4), w.ship)
+  assert same(w.stage.root.children.at(2), w.mines)
+  assert same(w.stage.root.children.at(3), w.orbs)
+test "collecting an orb scores and respawns it elsewhere, still in the orbs layer"
+  w := emptyWorld()
+  orb := w.orbList.at(0)
+  orb.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
+  step(w, 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 ?: crash "orphaned"}, w.orbs)
+  assert w.scoreText.text == "Score 10"
+test "a mine costs one life and makes the ship flash through its own act"
+  w := emptyWorld()
+  mine := w.mineList.at(0)
+  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
+  step(w, 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
+    step(w, 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 := emptyWorld()
+  mine := w.mineList.at(0)
+  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
+  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
+  mine := w.mineList.at(0)
+  mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
+  step(w, 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
+  step(w, 1.0, 0.0, 0.5)
+  assert w.ship.x == x
+test "restart resets the run and keeps the best score"
+  w := emptyWorld()
+  w.score = 90
+  w.lives = 0
+  w.over = true
+  w.overlay.visible = true
+  restart(w)
+  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 := emptyWorld()
+  w.score = 100
+  step(w, 0.0, 0.0, 0.016)
+  assert w.mineList.length() == 5
+  assert w.mines.children.length() == 5
+  restart(w)
+  assert w.mineList.length() == 3
+  assert w.mines.children.length() == 3
+test "the same seed plays out the same way"
+  a := newWorld(11, -1)
+  b := newWorld(11, -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 a.mineList.at(0).x == b.mineList.at(0).x
+  assert newWorld(12, -1).orbList.at(0).x != a.orbList.at(0).x
+test "fit centres the arena on the screen"
+  w := newWorld(7, -1)
+  fit(w, 1600.0, 600.0)
+  assert near(w.stage.camScale, 1.0)
+  assert near(w.stage.camX, -400.0)
+  assert near(w.stage.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

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

@@ -25,4 +25,4 @@ Options: `--browser chromium|webkit` (default chromium; WebKit is Playwright's S
 Exit code is non-zero with a message on failure.
 `cargo test --manifest-path plum-game/web-test/Cargo.toml` runs the same check on
-`plum-examples/game.plum` and `plum-examples/scene.plum`, plus WebKit runs; each skips with a note if its browser is not installed.
+`plum-examples/game.plum`, `plum-examples/game_scene.plum` and `plum-examples/scene.plum`, plus WebKit runs; each skips with a note if its browser is not installed.

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

@@ -5,6 +5,11 @@ fn orb_run_renders_and_animates() {
     orb_run("plum-examples/game.plum");
 }
+#[test]
+fn orb_run_scene_renders_and_animates() {
+    orb_run("plum-examples/game_scene.plum");
+}
 #[test]
 fn scene_run_renders_and_animates() {
     orb_run("plum-examples/scene.plum");