e465385 | plum | pyrossh

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

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

e465385 — Peter John 2026-11-03T12:10:24+05:30

examples: Orb Run World functions become World methods

Files changed (2) hide show

plum-examples/game.plum +182 -176
plum-examples/game_scene.plum +202 -196

plum-examples/game.plum CHANGED Viewed

@@ -3,9 +3,9 @@
 # the mines. Three lives; Enter or R restarts after the game is over. The music
 # loops from `init`; orbs, mines and the end of a run each play a sound.
 #
-# All rules are plain functions over `World` that never call the host, so the
+# All rules are methods of `World` (plus a few free helpers) that never call the host, so
-# `test` blocks below run under `plum test`; only `init`, `update` and `draw`
+# the `test` blocks below run under `plum test`; only `init`, `update` and `draw`
-# talk to the host.
+# (and `startMusic`, `sprite`) talk to the host.
 module game
 import std/Str
 import std/Int
@@ -50,7 +50,163 @@ record World(
   pickupSound: Int,
   hitSound: Int,
   overSound: Int,
-  musicSound: Int)
+  musicSound: Int) =
+  fun create(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,
+      pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
+    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
+  # A world with the orbs and mines moved out of the way.
+  fun empty() -> World =
+    w := World.create(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
+  # Starts a fresh game, keeping the best score and the random stream.
+  fun restart(self) =
+    self.best = self.best.max(self.score)
+    self.score = 0
+    self.lives = Rules.StartLives
+    self.hurt = 0.0
+    self.over = false
+    self.ship.x = Rules.ArenaW / 2.0
+    self.ship.y = Rules.ArenaH / 2.0
+    self.ship.vx = 0.0
+    self.ship.vy = 0.0
+    for i := range self.orbs.length()
+      moved := spawn(self.rng, self.ship, 120.0, 40.0)
+      self.orbs.at(i).x = moved.x
+      self.orbs.at(i).y = moved.y
+      self.orbs.at(i).vx = moved.vx
+      self.orbs.at(i).vy = moved.vy
+    while self.mines.length() > mineCount(0)
+      _ := self.mines.pop()!
+    for i := range self.mines.length()
+      moved := spawn(self.rng, self.ship, 220.0, 90.0)
+      self.mines.at(i).x = moved.x
+      self.mines.at(i).y = moved.y
+      self.mines.at(i).vx = moved.vx
+      self.mines.at(i).vy = moved.vy
+  # One simulation step. Does nothing once the game is over.
+  fun step(self, ax: Float, ay: Float, dt: Float) =
+    self.clock = self.clock + dt
+    if self.over
+      return
+    self.hurt = {self.hurt - dt}.max(0.0)
+    steer(self.ship, ax, ay, dt)
+    for i := range self.orbs.length()
+      orb := self.orbs.at(i)
+      drift(orb, Rules.OrbRadius, dt)
+      if overlaps(self.ship, Rules.ShipRadius, orb, Rules.OrbRadius)
+        self.score = self.score + Rules.OrbPoints
+        moved := spawn(self.rng, self.ship, 120.0, 40.0)
+        orb.x = moved.x
+        orb.y = moved.y
+        orb.vx = moved.vx
+        orb.vy = moved.vy
+    while self.mines.length() < mineCount(self.score)
+      self.mines.push(spawn(self.rng, self.ship, 220.0, 90.0))
+    for i := range self.mines.length()
+      mine := self.mines.at(i)
+      drift(mine, Rules.MineRadius, dt)
+      mine.angle = mine.angle + 2.0 * dt
+      if self.hurt <= 0.0 && overlaps(self.ship, Rules.ShipRadius, mine, Rules.MineRadius)
+        self.lives = self.lives - 1
+        self.hurt = Rules.HurtTime
+        if self.lives <= 0
+          self.over = true
+          self.best = self.best.max(self.score)
+  # Restarts the music loop from the top.
+  fun startMusic(self) =
+    soundStop(self.musicSound)
+    soundLoop(self.musicSound, musicVolume())
+  # Draws frame `frame` of sheet row `row`, centred on (x, y), at `Rules.Zoom` times its size.
+  fun sprite(self, row: Int, frame: Int, x: Float, y: Float, angle: Float, tint: Color) =
+    size := Rules.Cell * Rules.Zoom
+    drawTextureEx(
+      self.sheet, Float(frame) * Rules.Cell, Float(row) * Rules.Cell, Rules.Cell, Rules.Cell,
+      x - size / 2.0, y - size / 2.0, size, size, angle, false, tint)
+  fun drawStars(self) =
+    for i := range 40
+      sx := Float({i * 7919} % 800)
+      sy := Float({i * 104729} % 600)
+      twinkle := 0.25 + 0.2 * Math.sin(self.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))
+  fun update(self, dt: Float) =
+    if self.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+      self.restart()
+      self.startMusic()
+    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 := self.score
+    lives := self.lives
+    self.step(axis(left, right), axis(up, down), dt)
+    if self.score > score
+      soundPlay(self.pickupSound, 0.8)
+    if self.lives < lives
+      if self.over
+        soundStop(self.musicSound)
+        soundPlay(self.overSound, 1.0)
+      else
+        soundPlay(self.hitSound, 1.0)
+  fun draw(self) =
+    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))
+    self.drawStars()
+    for i := range self.orbs.length()
+      orb := self.orbs.at(i)
+      blendMode(Blend.Add)
+      drawCircle(orb.x, orb.y, 26.0, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5))
+      drawCircle(orb.x, orb.y, 17.0, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
+      blendMode(Blend.Normal)
+      self.sprite(1, frameOf(self.clock + Float(i) * 0.1, 4, 8.0), orb.x, orb.y, 0.0, Color.White)
+    for i := range self.mines.length()
+      mine := self.mines.at(i)
+      self.sprite(2, frameOf(self.clock, 4, 4.0), mine.x, mine.y, mine.angle, Color.White)
+    blink := self.hurt > 0.0 && frameOf(self.clock, 2, 10.0) == 0
+    if !self.over && !blink
+      flame := frameOf(self.clock, 4, 14.0)
+      drawCircle(self.ship.x, self.ship.y, 17.0, Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12))
+      self.sprite(0, flame, self.ship.x, self.ship.y, self.ship.angle, Color.White)
+    drawText("Score {self.score}", 16.0, 12.0, 28.0, Color.White)
+    drawText("Best {self.best.max(self.score)}", 16.0, 44.0, 20.0, Color.Yellow)
+    for i := range self.lives
+      drawTextureEx(
+        self.sheet, 0.0, 0.0, Rules.Cell, Rules.Cell,
+        Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0, 0.0, false, Color.White)
+    if self.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()
 fun distance(a: Body, b: Body) -> Float =
   Math.hypot(a.x - b.x, a.y - b.y)
@@ -83,45 +239,6 @@ fun spawn(rng: Random, avoid: Body, gap: Float, speed: Float) -> Body =
 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,
-    pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
-  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
@@ -158,53 +275,18 @@ fun drift(b: Body, r: Float, dt: Float) =
     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 ---
 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 := World.create(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.startMusic()
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -216,92 +298,16 @@ fun axis(negative: Bool, positive: Bool) -> Float =
     0.0
 export fun update(w: World, dt: Float) =
-  if w.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
-    restart(w)
+  w.update(dt)
-    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)
-# 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)
+  w.draw()
-  for i := range w.orbs.length()
-    orb := w.orbs.at(i)
-    blendMode(Blend.Add)
-    drawCircle(orb.x, orb.y, 26.0, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5))
-    drawCircle(orb.x, orb.y, 17.0, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
-    blendMode(Blend.Normal)
-    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)
@@ -327,51 +333,51 @@ test "drifters bounce off the walls"
   assert b.x == Rules.ArenaW - 10.0
 test "collecting an orb scores and respawns it elsewhere"
-  w := emptyWorld()
+  w := World.empty()
   orb := w.orbs.at(0)
   orb.x = w.ship.x
   orb.y = w.ship.y
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.score == Rules.OrbPoints
   assert distance(orb, w.ship) >= 120.0
   assert orb.x < 5000.0
 test "a mine costs one life, then the ship is briefly safe"
-  w := emptyWorld()
+  w := World.empty()
   mine := w.mines.at(0)
   mine.x = w.ship.x
   mine.y = w.ship.y
-  step(w, 0.0, 0.0, 0.016)
+  w.step(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)
+  w.step(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)
+    w.step(0.0, 0.0, 0.016)
   assert w.hurt == 0.0
 test "the game ends at zero lives and then ignores steps"
-  w := emptyWorld()
+  w := World.empty()
   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)
+  w.step(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)
+  w.step(1.0, 0.0, 0.5)
   assert w.ship.x == x
 test "restart resets the run and keeps the best score"
-  w := emptyWorld()
+  w := World.empty()
   w.score = 90
   w.lives = 0
   w.over = true
-  restart(w)
+  w.restart()
   assert !w.over
   assert w.score == 0
   assert w.best == 90
@@ -383,21 +389,21 @@ test "more mines appear as the score grows"
   assert mineCount(0) == 3
   assert mineCount(100) == 5
   assert mineCount(10000) == 8
-  w := emptyWorld()
+  w := World.empty()
   w.score = 100
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.mines.length() == 5
 test "the same seed plays out the same way"
-  a := newWorld(11, -1)
+  a := World.create(11, -1)
-  b := newWorld(11, -1)
+  b := World.create(11, -1)
   for i := range 120
-    step(a, 1.0, -1.0, 0.016)
+    a.step(1.0, -1.0, 0.016)
-    step(b, 1.0, -1.0, 0.016)
+    b.step(1.0, -1.0, 0.016)
   assert a.ship.x == b.ship.x
   assert a.score == b.score
   assert a.mines.at(0).x == b.mines.at(0).x
-  assert newWorld(12, -1).orbs.at(0).x != a.orbs.at(0).x
+  assert World.create(12, -1).orbs.at(0).x != a.orbs.at(0).x
 test "animation frames cycle"
   assert frameOf(0.0, 4, 8.0) == 0

plum-examples/game_scene.plum CHANGED Viewed

@@ -11,7 +11,7 @@
 # (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`.
+# spawning, lives and restart are methods of `World`.
 #
 # Prefer game.plum's immediate mode for a flat arcade game with a handful of kinds
 # where one state record and one pure `update` are easiest to test. Prefer this
@@ -262,158 +262,192 @@ record World(
   pickupSound: Int,
   hitSound: Int,
   overSound: Int,
-  musicSound: Int)
-fun newWorld(seed: Int, sheet: Int) -> World =
-  rng := Random(seed: seed)
-  stage := Stage.create()
-  ship := Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, tex: sheet)
-  stars := Group()
-  for i := range 40
-    stars.add(Star.create(i))
-  mines := Group()
-  orbs := Group()
-  hud := Group()
-  scoreText := Text.create("Score 0", 28.0, Color.White)
-  scoreText.x = 16.0
-  scoreText.y = 12.0
-  bestText := Text.create("Best 0", 20.0, Color.Yellow)
-  bestText.x = 16.0
-  bestText.y = 44.0
-  hud.add(scoreText)
-  hud.add(bestText)
-  icons := 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()
-  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
-# Lets the actors move (while the game runs) or only animate (once it is over).
-fun setLive(w: World, live: Bool) =
-  w.ship.live = live
-  for i := range w.orbList.length()
-    w.orbList.at(i).live = live
-  for i := range w.mineList.length()
-    w.mineList.at(i).live = live
+  musicSound: Int) =
+  fun create(seed: Int, sheet: Int) -> World =
+    rng := Random(seed: seed)
+    stage := Stage.create()
+    ship := Ship(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, tex: sheet)
+    stars := Group()
+    for i := range 40
+      stars.add(Star.create(i))
+    mines := Group()
+    orbs := Group()
+    hud := Group()
+    scoreText := Text.create("Score 0", 28.0, Color.White)
+    scoreText.x = 16.0
+    scoreText.y = 12.0
+    bestText := Text.create("Best 0", 20.0, Color.Yellow)
+    bestText.x = 16.0
+    bestText.y = 44.0
+    hud.add(scoreText)
+    hud.add(bestText)
+    icons := 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()
+    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)
+      w.addMine()
+    w
+  # A world with the orbs and mines moved out of the way.
+  fun empty() -> World =
+    w := World.create(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
+  # Adds one mine, far from the ship, to the mines layer.
+  fun addMine(self) =
+    mine := Mine.create(self.sheet, spawn(self.rng, self.ship.x, self.ship.y, 220.0, 90.0))
+    self.mines.add(mine)
+    self.mineList.push(mine)
+  # Starts a fresh game, keeping the best score and the random stream.
+  fun restart(self) =
+    self.best = self.best.max(self.score)
+    self.score = 0
+    self.lives = Rules.StartLives
+    self.over = false
+    ship := self.ship
+    ship.hurt = 0.0
+    ship.visible = true
+    ship.x = Rules.ArenaW / 2.0
+    ship.y = Rules.ArenaH / 2.0
+    ship.vx = 0.0
+    ship.vy = 0.0
+    for i := range self.orbList.length()
+      self.orbList.at(i).place(spawn(self.rng, ship.x, ship.y, 120.0, 40.0))
+    while self.mineList.length() > mineCount(0)
+      gone := self.mineList.pop()!
+      self.mines.remove(gone)
+    for i := range self.mineList.length()
+      self.mineList.at(i).place(spawn(self.rng, ship.x, ship.y, 220.0, 90.0))
+    self.sync()
+  # Copies the score, best score, lives and game-over panel into the HUD actors.
+  fun sync(self) =
+    self.scoreText.text = "Score {self.score}"
+    self.bestText.text = "Best {self.best.max(self.score)}"
+    for i := range self.lifeIcons.length()
+      self.lifeIcons.at(i).visible = i < self.lives
+    self.overlay.visible = self.over
+  # Lets the actors move (while the game runs) or only animate (once it is over).
+  fun setLive(self, live: Bool) =
+    self.ship.live = live
+    for i := range self.orbList.length()
+      self.orbList.at(i).live = live
+    for i := range self.mineList.length()
+      self.mineList.at(i).live = live
+  # One simulation step: every actor acts through the stage, then the rules look at
+  # the result. Once the game is over the actors only animate; nothing moves or scores.
+  fun step(self, ax: Float, ay: Float, dt: Float) =
+    self.clock = self.clock + dt
+    self.setLive(!self.over)
+    self.ship.ax = ax
+    self.ship.ay = ay
+    self.stage.act(dt)
+    if self.over
+      return
+    ship := self.ship
+    for i := range self.orbList.length()
+      orb := self.orbList.at(i)
+      if overlaps(ship.x, ship.y, Rules.ShipRadius, orb.x, orb.y, Rules.OrbRadius)
+        self.score = self.score + Rules.OrbPoints
+        orb.place(spawn(self.rng, ship.x, ship.y, 120.0, 40.0))
+    while self.mineList.length() < mineCount(self.score)
+      self.addMine()
+    for i := range self.mineList.length()
+      mine := self.mineList.at(i)
+      if ship.hurt <= 0.0 && overlaps(ship.x, ship.y, Rules.ShipRadius, mine.x, mine.y, Rules.MineRadius)
+        self.lives = self.lives - 1
+        ship.hurt = Rules.HurtTime
+        if self.lives <= 0
+          self.over = true
+          self.best = self.best.max(self.score)
+          ship.visible = false
+    self.sync()
+  # Fits the arena into a screen of `sw` by `sh` pixels, centred.
+  fun fit(self, sw: Float, sh: Float) =
+    zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
+    self.stage.camScale = zoom
+    self.stage.camX = 0.0 - {sw / zoom - Rules.ArenaW} / 2.0
+    self.stage.camY = 0.0 - {sh / zoom - Rules.ArenaH} / 2.0
+  # Restarts the music loop from the top.
+  fun startMusic(self) =
+    soundStop(self.musicSound)
+    soundLoop(self.musicSound, musicVolume())
+  fun update(self, dt: Float) =
+    if self.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+      self.restart()
+      self.startMusic()
+    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 := self.score
+    lives := self.lives
+    self.step(axis(left, right), axis(up, down), dt)
+    if self.score > score
+      soundPlay(self.pickupSound, 0.8)
+    if self.lives < lives
+      if self.over
+        soundStop(self.musicSound)
+        soundPlay(self.overSound, 1.0)
+      else
+        soundPlay(self.hitSound, 1.0)
+  fun draw(self) =
+    self.fit(screenWidth(), screenHeight())
+    clear(Color.rgb(0.04, 0.05, 0.1))
+    self.stage.draw()
 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. Once the game is over the actors only animate; nothing moves or scores.
-fun step(w: World, ax: Float, ay: Float, dt: Float) =
-  w.clock = w.clock + dt
-  setLive(w, !w.over)
-  w.ship.ax = ax
-  w.ship.ay = ay
-  w.stage.act(dt)
-  if w.over
-    return
-  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 := World.create(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.startMusic()
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -425,44 +459,16 @@ fun axis(negative: Bool, positive: Bool) -> Float =
     0.0
 export fun update(w: World, dt: Float) =
-  if w.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
-    restart(w)
+  w.update(dt)
-    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()
+  w.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(x: 400.0, y: 300.0, tex: -1)
   ship.ax = 1.0
@@ -498,7 +504,7 @@ test "a mine spins as it drifts"
   assert near(mine.x, 405.0)
 test "the scene has a backdrop, stars, mines, orbs, ship and HUD layers"
-  w := newWorld(7, -1)
+  w := World.create(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)
@@ -508,10 +514,10 @@ test "the scene has a backdrop, stars, mines, orbs, ship and HUD layers"
   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()
+  w := World.empty()
   orb := w.orbList.at(0)
   orb.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.score == Rules.OrbPoints
   assert Math.hypot(orb.x - w.ship.x, orb.y - w.ship.y) >= 120.0
   assert orb.x < 5000.0
@@ -520,10 +526,10 @@ test "collecting an orb scores and respawns it elsewhere, still in the orbs laye
   assert w.scoreText.text == "Score 10"
 test "a mine costs one life and makes the ship flash through its own act"
-  w := emptyWorld()
+  w := World.empty()
   mine := w.mineList.at(0)
   mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.lives == Rules.StartLives - 1
   assert w.ship.hurt > 0.0
   assert !w.lifeIcons.at(2).visible
@@ -532,7 +538,7 @@ test "a mine costs one life and makes the ship flash through its own act"
   hidden := 0
   shown := 0
   for i := range 100
-    step(w, 0.0, 0.0, 0.016)
+    w.step(0.0, 0.0, 0.016)
     if w.ship.visible
       shown = shown + 1
     else
@@ -544,35 +550,35 @@ test "a mine costs one life and makes the ship flash through its own act"
   assert w.lives == Rules.StartLives - 1
 test "the ship is briefly safe after a hit"
-  w := emptyWorld()
+  w := World.empty()
   mine := w.mineList.at(0)
   mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.lives == Rules.StartLives - 1
 test "the game ends at zero lives and then ignores steps"
-  w := emptyWorld()
+  w := World.empty()
   w.lives = 1
   w.score = 40
   mine := w.mineList.at(0)
   mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 0.0, vy: 0.0))
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.over
   assert w.lives == 0
   assert w.best == 40
   assert w.overlay.visible
   assert !w.ship.visible
   x := w.ship.x
-  step(w, 1.0, 0.0, 0.5)
+  w.step(1.0, 0.0, 0.5)
   assert w.ship.x == x
 test "after game over nothing moves but the animations keep running"
-  w := emptyWorld()
+  w := World.empty()
   w.lives = 1
   mine := w.mineList.at(0)
   mine.place(Motion(x: w.ship.x, y: w.ship.y, vx: 10.0, vy: 0.0))
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.over
   x := mine.x
   rot := mine.rotation
@@ -581,7 +587,7 @@ test "after game over nothing moves but the animations keep running"
   star := Star.create(0)
   w.stage.root.children.at(1).add(star)
   for i := range 10
-    step(w, 1.0, 0.0, 0.1)
+    w.step(1.0, 0.0, 0.1)
   assert mine.x == x
   assert mine.rotation == rot
   assert w.ship.x == Rules.ArenaW / 2.0
@@ -592,12 +598,12 @@ test "after game over nothing moves but the animations keep running"
   assert w.score == 0
 test "restart resets the run and keeps the best score"
-  w := emptyWorld()
+  w := World.empty()
   w.score = 90
   w.lives = 0
   w.over = true
   w.overlay.visible = true
-  restart(w)
+  w.restart()
   assert !w.over
   assert !w.overlay.visible
   assert w.ship.visible
@@ -612,29 +618,29 @@ test "more mines appear as the score grows and restart removes them from the lay
   assert mineCount(0) == 3
   assert mineCount(100) == 5
   assert mineCount(10000) == 8
-  w := emptyWorld()
+  w := World.empty()
   w.score = 100
-  step(w, 0.0, 0.0, 0.016)
+  w.step(0.0, 0.0, 0.016)
   assert w.mineList.length() == 5
   assert w.mines.children.length() == 5
-  restart(w)
+  w.restart()
   assert w.mineList.length() == 3
   assert w.mines.children.length() == 3
 test "the same seed plays out the same way"
-  a := newWorld(11, -1)
+  a := World.create(11, -1)
-  b := newWorld(11, -1)
+  b := World.create(11, -1)
   for i := range 120
-    step(a, 1.0, -1.0, 0.016)
+    a.step(1.0, -1.0, 0.016)
-    step(b, 1.0, -1.0, 0.016)
+    b.step(1.0, -1.0, 0.016)
   assert a.ship.x == b.ship.x
   assert a.score == b.score
   assert a.mineList.at(0).x == b.mineList.at(0).x
-  assert newWorld(12, -1).orbList.at(0).x != a.orbList.at(0).x
+  assert World.create(12, -1).orbList.at(0).x != a.orbList.at(0).x
 test "fit centres the arena on the screen"
-  w := newWorld(7, -1)
+  w := World.create(7, -1)
-  fit(w, 1600.0, 600.0)
+  w.fit(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)