3ac7d50 | plum | pyrossh

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

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

3ac7d50 — Peter John 2026-11-02T14:42:36+05:30

Add Orb Run example game with generated sprite sheet; generic Games docs

Files changed (6) hide show

README.md +14 -12
docs/game.png +0 -0
docs/plans/2026-10-26-game-engine.md +2 -0
plum-examples/assets/make_sprites.py +85 -0
plum-examples/assets/sprites.png +0 -0
plum-examples/game.plum +373 -0

README.md CHANGED Viewed

@@ -1027,7 +1027,11 @@ Every module that imports `std/Str` also exports four helpers for hosts that can
 ## Games
-`plum game file.plum` compiles a game and runs it in a native window (macroquad, with the module under wasmtime). `plum game --web file.plum [-o dist] [--preload path]...` writes a static web build instead: `index.html`, `mq_js_bundle.js`, `plum_bridge.js`, `plum-game.wasm`, `plum.wasm`, `preload.txt` and an `assets/` copy of the preloaded files (the six `sprites/*.rxx` and `data/defines/mapelem.dat` are always preloaded; `dist` defaults to the source file's directory). Serve it from any static host; the browser needs wasm GC support. The web build needs `rustup target add wasm32-unknown-unknown`.
+`plum game file.plum` compiles a game and runs it in a native window (macroquad, with the module under wasmtime). `plum game --web file.plum [-o dist] [--assets DIR]` writes a static web build instead: `index.html`, `mq_js_bundle.js`, `plum_bridge.js`, `plum-game.wasm`, `plum.wasm`, `preload.txt` and an `assets/` copy of the whole asset directory (every file in it is listed in `preload.txt` and fetched before the first frame; `dist` defaults to `dist` beside the source file). Serve it from any static host; the browser needs wasm GC support. The web build needs `rustup target add wasm32-unknown-unknown`.
+`plum game plum-examples/game.plum` runs the example, a small arcade game: steer a ship with the arrow keys or WASD, collect orbs, dodge mines (Enter restarts). It draws shapes, text and an animated sprite sheet (`plum-examples/assets/sprites.png`, generated by `make_sprites.py` beside it). Its rules are plain functions with `test` blocks, so `plum test plum-examples` covers them without a window.
+![the example game](docs/game.png)
 A game declares three exports. `G` is any record and holds all game state (there are no globals):
@@ -1041,29 +1045,27 @@ The host calls `init` once after the window exists, then `update` and `draw` eve
 **Headless check:** `PLUM_GAME_CAPTURE=out.png plum-game game.wasm` runs `PLUM_GAME_FRAMES` frames (default 30), saves the framebuffer as an upright PNG and exits 0.
-**Assets** are never part of the repository. The asset root is `--assets DIR`, else `$PLUM_GAME_ASSETS`, else `../kam_macroquad/assets` beside the repository. `--web` copies only the preloaded files into `dist/assets`.
+**Asset root:** `plum-game <wasm> [--assets DIR]` reads textures and files relative to `DIR`, default `assets` beside the wasm (`$PLUM_GAME_ASSETS` overrides that default). `plum game file.plum` passes `assets` beside the source file. A path that escapes the root (`..` or absolute) fails like a missing file: `-1`, `""` or `false`.
-**Host API** (`std/Game`; `Int` handles are `-1` on failure; coordinates are world units once a camera is set):
+**Host API** (`std/Game`; texture handles are `-1` on failure; coordinates are world units once a camera is set):
 | function | meaning |
 |---|---|
 | `screenWidth()`, `screenHeight()`, `frameTime()` | window size in pixels, last frame time in seconds |
 | `clear(c)` | fill the screen |
-| `drawRect(x, y, w, h, c)`, `drawLine(x1, y1, x2, y2, thickness, c)`, `drawText(s, x, y, size, c)` | shapes and text (`x, y` is the text's top-left) |
+| `drawRect(x, y, w, h, c)`, `drawCircle(x, y, r, c)`, `drawLine(x1, y1, x2, y2, thickness, c)`, `drawText(s, x, y, size, c)` | shapes and text (`x, y` is the text's top-left, a circle's centre) |
 | `setCamera(x, y, scale)`, `resetCamera()` | world point `(x, y)` maps to the screen's top-left, one world unit is `scale` pixels |
-| `atlasLoad(name)` | load `<assets>/sprites/<name>.rxx` |
-| `spriteCount(a)`, `spriteW(a, i)`, `spriteH`, `spritePivotX`, `spritePivotY`, `spriteColor(a, i)` | sprite info (0 for a missing sprite); `spriteColor` is the average opaque colour |
-| `drawSprite(a, i, x, y, flipX, tint)` | sprite at its natural size, top-left at `(x + pivotX, y + pivotY)` |
-| `drawTile(a, i, x, y, size, quarterTurns, tint)` | sprite stretched to a square, rotated clockwise about its centre |
+| `textureLoad(path)` | load an image (PNG at least) relative to the asset root |
+| `textureWidth(t)`, `textureHeight(t)` | size in pixels (0 for a bad handle) |
+| `textureSetSmooth(t, smooth)` | linear (`true`) or nearest (`false`, the default) filtering |
+| `drawTexture(t, x, y, tint)` | the texture at its natural size, top-left at `(x, y)` |
+| `drawTextureEx(t, sx, sy, sw, sh, x, y, w, h, rotation, flipX, tint)` | source rect `(sx, sy, sw, sh)` in texture pixels drawn into dest rect `(x, y, w, h)`, rotated `rotation` radians clockwise about the dest centre |
+| `fileExists(path)`, `fileLoad(path)` | whole file as a `Str` (`""` if missing), relative to the asset root |
 | `isKeyDown(k)`, `isKeyPressed(k)`, `isMouseDown(b)`, `isMousePressed(b)` | input; `k` is a `Key` constant, `b` a `Mouse` constant |
 | `mousePos()`, `mouseWheel()` | pointer in screen pixels; wheel direction this frame (+ is up) |
-| `mapLoad(path)`, `mapWidth(m)`, `mapHeight(m)` | load a KaM `.map` relative to the asset root |
-| `mapTerrain(m, x, y)`, `mapRotation`, `mapElevation`, `mapObject` | per-tile data; row 0 is the map's first row. The Tileset sprite for a terrain id is `id + 1`; `mapObject` is a `Trees_a` sprite index (0 for none) |
 `Key` constants use GLFW numbering: `Key.Space`, `Key.KeyA` to `Key.KeyZ`, `Key.Num0` to `Key.Num9`, `Key.Escape`, `Key.Enter`, `Key.Tab`, `Key.Backspace`, `Key.Right`, `Key.Left`, `Key.Down`, `Key.Up`, `Key.LeftShift`, `Key.LeftControl`. `Mouse` has `Mouse.Left`, `Mouse.Right` and `Mouse.Middle`. `Color` holds RGBA channels in 0..1 with the constants `White`, `Black`, `Red`, `Green`, `Blue`, `Yellow` and `Transparent`, plus `Color.rgb(r, g, b)` and `withAlpha(a)`.
-`plum-game/kam/Main.plum` is a Knights and Merchants map viewer built on this API: `plum game plum-game/kam/Main.plum`.
 ## Standard library highlights
 - **`Bool`** — `true`/`false`, `if`, `&&`/`||`/`!` and `==` are built in (no import); `toStr` (also used by `"{b}"` interpolation) and `Bool.parse("true")` need `import std/Bool`

docs/game.png ADDED Viewed

Binary file

docs/plans/2026-10-26-game-engine.md CHANGED Viewed

@@ -1,5 +1,7 @@
 # Plum for games: browser-first macroquad host, port of a simplified KaM
+> The engine is generic (textures, files, shapes, input); the KaM port lives in `../kam_plum`, not in this repository.
 **Status:** draft. Planned only and not run; the user has more ideas to fold in first.
 **Depends on:** `2026-10-26-zig-generics-and-numbers.md`, which supplies duck-typed per-type-copy generics, no traits (enums plus duck-typed operator methods), native typed arrays, and `Int`/`Float` kept as i64/f64 with `Int` narrowed to wasm i32 at `extern fun` boundaries (no JS BigInt in the browser bridge). That plan runs first.
 **Goal:** Port `../kam_macroquad`, a 98k-line Rust/macroquad remake of Knights and Merchants that already runs in the browser via wasm, to Plum as a **simplified** game. There is no mission scripting (rhai) and the rules are simpler, but animations and sounds stay identical. It runs in the browser first.

plum-examples/assets/make_sprites.py ADDED Viewed

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Writes sprites.png beside this script: a 64x48 sheet of 16x16 frames.
+Row 0: the ship with four engine-flame frames (pointing up).
+Row 1: an orb spinning (four frames, squeezed and widened).
+Row 2: a mine whose light blinks (four frames).
+Standard library only (zlib + struct).
+"""
+import math
+import os
+import struct
+import zlib
+CELL, COLS, ROWS = 16, 4, 3
+W, H = CELL * COLS, CELL * ROWS
+pix = [[(0, 0, 0, 0)] * W for _ in range(H)]
+def put(col, row, x, y, rgba):
+    if 0 <= x < CELL and 0 <= y < CELL:
+        pix[row * CELL + y][col * CELL + x] = rgba
+def ship(col):
+    hull, edge, glass = (120, 200, 255, 255), (30, 90, 160, 255), (255, 255, 255, 255)
+    for y in range(2, 13):
+        half = (y - 2) * 5 // 10 + 1
+        for x in range(8 - half, 8 + half):
+            put(col, 0, x, y, edge if x in (8 - half, 7 + half) or y == 12 else hull)
+    for y in (5, 6):
+        put(col, 0, 7, y, glass)
+        put(col, 0, 8, y, glass)
+    flame = (255, 190, 60, 255) if col % 2 == 0 else (255, 90, 40, 255)
+    for y in range(13, 13 + 1 + (col % 4)):
+        put(col, 0, 7, y, flame)
+        put(col, 0, 8, y, flame)
+def orb(col):
+    half_w = (7, 5, 2, 5)[col]
+    for y in range(16):
+        for x in range(16):
+            dx, dy = (x - 7.5) / max(half_w, 1), (y - 7.5) / 7
+            d = dx * dx + dy * dy
+            if d <= 1.0:
+                shade = (255, 215, 70, 255) if d < 0.55 else (230, 150, 20, 255)
+                if dx < -0.2 and dy < -0.2 and d < 0.5:
+                    shade = (255, 250, 200, 255)
+                put(col, 1, x, y, shade)
+def mine(col):
+    body, spike = (190, 60, 70, 255), (110, 25, 40, 255)
+    for y in range(16):
+        for x in range(16):
+            d = math.hypot(x - 7.5, y - 7.5)
+            if d <= 5.2:
+                put(col, 2, x, y, body)
+    for k in range(8):
+        a = k * math.pi / 4
+        for r in (6, 7):
+            put(col, 2, int(round(7.5 + math.cos(a) * r)), int(round(7.5 + math.sin(a) * r)), spike)
+    light = (255, 255, 255, 255) if col % 2 == 0 else (90, 20, 30, 255)
+    for x, y in ((7, 7), (8, 7), (7, 8), (8, 8)):
+        put(col, 2, x, y, light)
+for c in range(COLS):
+    ship(c)
+    orb(c)
+    mine(c)
+def chunk(tag, data):
+    body = tag + data
+    return struct.pack(">I", len(data)) + body + struct.pack(">I", zlib.crc32(body) & 0xFFFFFFFF)
+raw = b"".join(b"\x00" + b"".join(bytes(p) for p in row) for row in pix)
+png = b"\x89PNG\r\n\x1a\n"
+png += chunk(b"IHDR", struct.pack(">IIBBBBB", W, H, 8, 6, 0, 0, 0))
+png += chunk(b"IDAT", zlib.compress(raw, 9))
+png += chunk(b"IEND", b"")
+with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "sprites.png"), "wb") as f:
+    f.write(png)

plum-examples/assets/sprites.png ADDED Viewed

Binary file

plum-examples/game.plum ADDED Viewed

@@ -0,0 +1,373 @@
+# Orb Run: a small arcade game for the game host (`plum game plum-examples/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.
+#
+# All rules are plain functions over `World` that never call the host, so the
+# `test` blocks below run under `plum test`; only `init`, `update` and `draw`
+# talk to the host.
+module game
+import std/Str
+import std/Int
+import std/Float
+import std/List
+import std/Math
+import std/Random
+import std/Vec2
+import std/Color
+import std/Game
+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.
+record Body(x: Float, y: Float, vx: Float, vy: Float, angle: Float)
+record World(
+  ship: Body,
+  orbs: List[Body],
+  mines: List[Body],
+  rng: Random,
+  score: Int,
+  best: Int,
+  lives: Int,
+  hurt: Float,
+  clock: Float,
+  over: Bool,
+  sheet: Int)
+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`.
+fun spawn(rng: Random, avoid: Body, gap: Float, speed: Float) -> Body =
+  margin := 30.0
+  b := Body(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0, angle: 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 distance(b, avoid) >= 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
+# How many mines are out: more as the score grows.
+fun mineCount(score: Int) -> Int =
+  {3 + score / 50}.min(8)
+fun newWorld(seed: Int, sheet: Int) -> World =
+  rng := Random(seed: seed)
+  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: List[Body](), mines: List[Body](), rng: rng, score: 0, best: 0,
+    lives: Rules.StartLives, hurt: 0.0, clock: 0.0, over: false, sheet: sheet)
+  for i := range Rules.OrbCount
+    w.orbs.push(spawn(rng, ship, 120.0, 40.0))
+  for i := range mineCount(0)
+    w.mines.push(spawn(rng, ship, 220.0, 90.0))
+  w
+# 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.hurt = 0.0
+  w.over = false
+  w.ship.x = Rules.ArenaW / 2.0
+  w.ship.y = Rules.ArenaH / 2.0
+  w.ship.vx = 0.0
+  w.ship.vy = 0.0
+  for i := range w.orbs.length()
+    moved := spawn(w.rng, w.ship, 120.0, 40.0)
+    w.orbs.at(i).x = moved.x
+    w.orbs.at(i).y = moved.y
+    w.orbs.at(i).vx = moved.vx
+    w.orbs.at(i).vy = moved.vy
+  while w.mines.length() > mineCount(0)
+    _ := w.mines.pop()!
+  for i := range w.mines.length()
+    moved := spawn(w.rng, w.ship, 220.0, 90.0)
+    w.mines.at(i).x = moved.x
+    w.mines.at(i).y = moved.y
+    w.mines.at(i).vx = moved.vx
+    w.mines.at(i).vy = moved.vy
+# 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)
+# One simulation step. 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.hurt = {w.hurt - dt}.max(0.0)
+  steer(w.ship, ax, ay, dt)
+  for i := range w.orbs.length()
+    orb := w.orbs.at(i)
+    drift(orb, Rules.OrbRadius, dt)
+    if overlaps(w.ship, Rules.ShipRadius, orb, Rules.OrbRadius)
+      w.score = w.score + Rules.OrbPoints
+      moved := spawn(w.rng, w.ship, 120.0, 40.0)
+      orb.x = moved.x
+      orb.y = moved.y
+      orb.vx = moved.vx
+      orb.vy = moved.vy
+  while w.mines.length() < mineCount(w.score)
+    w.mines.push(spawn(w.rng, w.ship, 220.0, 90.0))
+  for i := range w.mines.length()
+    mine := w.mines.at(i)
+    drift(mine, Rules.MineRadius, dt)
+    mine.angle = mine.angle + 2.0 * dt
+    if w.hurt <= 0.0 && overlaps(w.ship, Rules.ShipRadius, mine, Rules.MineRadius)
+      w.lives = w.lives - 1
+      w.hurt = Rules.HurtTime
+      if w.lives <= 0
+        w.over = true
+        w.best = w.best.max(w.score)
+# --- host glue: input, drawing ---
+export fun init() -> World =
+  newWorld(2024, textureLoad("sprites.png"))
+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)
+  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)
+  step(w, axis(left, right), axis(up, down), dt)
+# Draws frame `frame` of sheet row `row`, centred on (x, y), at `Rules.Zoom` times its size.
+fun sprite(w: World, row: Int, frame: Int, x: Float, y: Float, angle: Float, tint: Color) =
+  size := Rules.Cell * Rules.Zoom
+  drawTextureEx(
+    w.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(w: World) =
+  for i := range 40
+    sx := Float({i * 7919} % 800)
+    sy := Float({i * 104729} % 600)
+    twinkle := 0.25 + 0.2 * Math.sin(w.clock * 2.0 + Float(i))
+    drawCircle(sx, sy, 1.0 + Float(i % 3) * 0.5, Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
+export fun draw(w: World) =
+  sw := screenWidth()
+  sh := screenHeight()
+  zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
+  clear(Color.rgb(0.04, 0.05, 0.1))
+  setCamera(0.0 - {sw / zoom - Rules.ArenaW} / 2.0, 0.0 - {sh / zoom - Rules.ArenaH} / 2.0, zoom)
+  drawRect(0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16))
+  drawStars(w)
+  for i := range w.orbs.length()
+    orb := w.orbs.at(i)
+    drawCircle(orb.x, orb.y, 22.0, Color(r: 1.0, g: 0.8, b: 0.2, a: 0.18))
+    sprite(w, 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)
+    sprite(w, 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)
+    drawCircle(w.ship.x, w.ship.y, 17.0, Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12))
+    sprite(w, 0, flame, w.ship.x, w.ship.y, w.ship.angle, Color.White)
+  drawText("Score {w.score}", 16.0, 12.0, 28.0, Color.White)
+  drawText("Best {w.best.max(w.score)}", 16.0, 44.0, 20.0, Color.Yellow)
+  for i := range w.lives
+    drawTextureEx(
+      w.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
+    drawRect(0.0, 240.0, Rules.ArenaW, 120.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6))
+    drawText("Game over", 300.0, 258.0, 48.0, Color.Red)
+    drawText("Press Enter to play again", 270.0, 316.0, 24.0, Color.White)
+  resetCamera()
+# --- tests ---
+fun still(x: Float, y: Float) -> Body =
+  Body(x: x, y: y, vx: 0.0, vy: 0.0, angle: 0.0)
+# A world with the orbs and mines moved out of the way.
+fun emptyWorld() -> World =
+  w := newWorld(7, -1)
+  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
+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 := emptyWorld()
+  orb := w.orbs.at(0)
+  orb.x = w.ship.x
+  orb.y = w.ship.y
+  step(w, 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 := emptyWorld()
+  mine := w.mines.at(0)
+  mine.x = w.ship.x
+  mine.y = w.ship.y
+  step(w, 0.0, 0.0, 0.016)
+  assert w.lives == Rules.StartLives - 1
+  assert w.hurt > 0.0
+  step(w, 0.0, 0.0, 0.016)
+  assert w.lives == Rules.StartLives - 1
+  mine.x = 5000.0
+  for i := range 100
+    step(w, 0.0, 0.0, 0.016)
+  assert w.hurt == 0.0
+test "the game ends at zero lives and then ignores steps"
+  w := emptyWorld()
+  w.lives = 1
+  w.score = 40
+  mine := w.mines.at(0)
+  mine.x = w.ship.x
+  mine.y = w.ship.y
+  step(w, 0.0, 0.0, 0.016)
+  assert w.over
+  assert w.lives == 0
+  assert w.best == 40
+  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
+  restart(w)
+  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 := emptyWorld()
+  w.score = 100
+  step(w, 0.0, 0.0, 0.016)
+  assert w.mines.length() == 5
+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.mines.at(0).x == b.mines.at(0).x
+  assert newWorld(12, -1).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