126b62f | plum | pyrossh

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

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

126b62f — Peter John 2026-11-04T11:10:06+05:30

examples: mutable games move to games/imperative (T16), io-style entry points (T13)

Files changed (4) hide show

plum-examples/{game.plum → games/imperative/game.plum} +53 -52
plum-examples/{game_scene.plum → games/imperative/game_scene.plum} +46 -45
plum-examples/{scene.plum → games/imperative/scene.plum} +35 -34
plum-std/game/{Scene.plum → imperative/Scene.plum} +0 -0

plum-examples/{game.plum → games/imperative/game.plum} RENAMED Viewed

@@ -1,4 +1,4 @@
-# Orb Run: a small arcade game for the game host (`plum game plum-examples/game.plum`).
+# Orb Run: a small arcade game for the game host (`plum game plum-examples/games/imperative/game.plum`).
 # Steer the ship with the arrow keys or WASD, collect the drifting orbs and avoid
 # the mines. Three lives; Enter or R restarts after the game is over. The music
 # loops from `init`; orbs, mines and the end of a run each play a sound.
@@ -16,6 +16,7 @@ import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
+import std/Io
 primitive Rules =
   ArenaW = 800.0
@@ -135,78 +136,78 @@ record World(
           self.best = self.best.max(self.score)
   # Restarts the music loop from the top.
-  fun startMusic(self) =
+  fun startMusic(self, io: Io) =
-    soundStop(self.musicSound)
+    io.soundStop(self.musicSound)
-    soundLoop(self.musicSound, musicVolume())
+    io.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) =
+  fun sprite(self, io: Io, row: Int, frame: Int, x: Float, y: Float, angle: Float, tint: Color) =
     size := Rules.Cell * Rules.Zoom
-    drawTextureEx(
+    io.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) =
+  fun drawStars(self, io: Io) =
     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))
+      io.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) =
+  fun update(self, io: Io, dt: Float) =
-    if self.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+    if self.over && {io.isKeyPressed(Key.Enter) || io.isKeyPressed(Key.KeyR)}
       self.restart()
-      self.startMusic()
+      self.startMusic(io)
-    left := isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+    left := io.isKeyDown(Key.Left) || io.isKeyDown(Key.KeyA)
-    right := isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+    right := io.isKeyDown(Key.Right) || io.isKeyDown(Key.KeyD)
-    up := isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+    up := io.isKeyDown(Key.Up) || io.isKeyDown(Key.KeyW)
-    down := isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+    down := io.isKeyDown(Key.Down) || io.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)
+      io.soundPlay(self.pickupSound, 0.8)
     if self.lives < lives
       if self.over
-        soundStop(self.musicSound)
+        io.soundStop(self.musicSound)
-        soundPlay(self.overSound, 1.0)
+        io.soundPlay(self.overSound, 1.0)
       else
-        soundPlay(self.hitSound, 1.0)
+        io.soundPlay(self.hitSound, 1.0)
-  fun draw(self) =
+  fun draw(self, io: Io) =
-    sw := screenWidth()
+    sw := io.screenWidth()
-    sh := screenHeight()
+    sh := io.screenHeight()
     zoom := {sw / Rules.ArenaW}.min(sh / Rules.ArenaH)
-    clear(Color.rgb(0.04, 0.05, 0.1))
+    io.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)
+    io.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))
+    io.drawRect(0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16))
-    self.drawStars()
+    self.drawStars(io)
     for i := range self.orbs.length()
       orb := self.orbs.at(i)
-      blendMode(Blend.Add)
+      io.blendMode(Blend.Add)
-      drawCircle(orb.x, orb.y, 26.0, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5))
+      io.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))
+      io.drawCircle(orb.x, orb.y, 17.0, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5))
-      blendMode(Blend.Normal)
+      io.blendMode(Blend.Normal)
-      self.sprite(1, frameOf(self.clock + Float(i) * 0.1, 4, 8.0), orb.x, orb.y, 0.0, Color.White)
+      self.sprite(io, 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)
+      self.sprite(io, 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))
+      io.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)
+      self.sprite(io, 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)
+    io.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)
+    io.drawText("Best {self.best.max(self.score)}", 16.0, 44.0, 20.0, Color.Yellow)
     for i := range self.lives
-      drawTextureEx(
+      io.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))
+      io.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)
+      io.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)
+      io.drawText("Press Enter to play again", 270.0, 316.0, 24.0, Color.White)
-    resetCamera()
+    io.resetCamera()
 fun distance(a: Body, b: Body) -> Float =
   Math.hypot(a.x - b.x, a.y - b.y)
@@ -280,13 +281,13 @@ fun drift(b: Body, r: Float, dt: Float) =
 fun musicVolume() -> Float =
   0.3
-export fun init() -> World =
+export fun init(io: Io) -> World =
-  w := World.create(2024, textureLoad("sprites.png"))
+  w := World.create(2024, io.textureLoad("sprites.png"))
-  w.pickupSound = soundLoad("pickup.wav")
+  w.pickupSound = io.soundLoad("pickup.wav")
-  w.hitSound = soundLoad("hit.wav")
+  w.hitSound = io.soundLoad("hit.wav")
-  w.overSound = soundLoad("gameover.wav")
+  w.overSound = io.soundLoad("gameover.wav")
-  w.musicSound = soundLoad("music.wav")
+  w.musicSound = io.soundLoad("music.wav")
-  w.startMusic()
+  w.startMusic(io)
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -297,11 +298,11 @@ fun axis(negative: Bool, positive: Bool) -> Float =
   else
     0.0
-export fun update(w: World, dt: Float) =
+export fun update(io: Io, w: World, dt: Float) =
-  w.update(dt)
+  w.update(io, dt)
-export fun draw(w: World) =
+export fun draw(io: Io, w: World) =
-  w.draw()
+  w.draw(io)
 # --- tests ---

plum-examples/{game_scene.plum → games/imperative/game_scene.plum} RENAMED Viewed

@@ -1,6 +1,6 @@
-# Orb Run on the scene graph (`plum game plum-examples/game_scene.plum`): the same game as
+# Orb Run on the scene graph (`plum game plum-examples/games/imperative/game_scene.plum`): the same game as
 # game.plum (same arena, rules, sprites, sounds, keys and scoring), rebuilt in retained
-# mode on std/game/Scene. Steer the ship with the arrow keys or WASD, collect the
+# mode on std/game/imperative/Scene. Steer the ship with the arrow keys or WASD, collect the
 # drifting orbs and avoid the mines. Three lives; Enter or R restarts after the game
 # is over.
 #
@@ -30,7 +30,8 @@ import std/Random
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/Scene
+import std/game/imperative/Scene
+import std/Io
 primitive Rules =
   ArenaW = 800.0
@@ -136,11 +137,11 @@ record Ship(Actor(x, y), tex: Int) =
       self.rotation = Math.atan2(self.vx, 0.0 - self.vy)
     self.visible = !{self.hurt > 0.0 && frameOf(self.clock, 2, 10.0) == 0}
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, 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))
+    io.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)
+    drawSpriteFrame(io, 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(x, y), vx: Float, vy: Float, phase: Float, tex: Int) =
@@ -173,15 +174,15 @@ record Orb(Actor(x, y), vx: Float, vy: Float, phase: Float, tex: Int) =
     drift(m, Rules.OrbRadius, dt)
     self.place(m)
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, m: Affine, alpha: Float) =
     c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
     k := m.scaleX()
-    blendMode(Blend.Add)
+    io.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))
+    io.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))
+    io.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)
+    io.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)
+    drawSpriteFrame(io, 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(x, y), vx: Float, vy: Float, tex: Int) =
@@ -215,9 +216,9 @@ record Mine(Actor(x, y), vx: Float, vy: Float, tex: Int) =
     self.place(m)
     self.rotation = self.rotation + 2.0 * dt
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, 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)
+    drawSpriteFrame(io, 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(x, y, width, height), seed: Float) =
@@ -234,9 +235,9 @@ record Star(Actor(x, y, width, height), seed: Float) =
   override fun act(self, dt: Float) =
     self.clock = self.clock + dt
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, 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))
+    drawDisc(io, m, alpha, self.width / 2.0, Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle))
 # The whole game: it embeds the Stage (camera and root) and has its layers, typed handles to the actors the rules
 # touch, and the run's state. `mines` and `orbs` are the layer Groups; `mineList`
@@ -403,34 +404,34 @@ record World(
     self.camY = 0.0 - {sh / zoom - Rules.ArenaH} / 2.0
   # Restarts the music loop from the top.
-  fun startMusic(self) =
+  fun startMusic(self, io: Io) =
-    soundStop(self.musicSound)
+    io.soundStop(self.musicSound)
-    soundLoop(self.musicSound, musicVolume())
+    io.soundLoop(self.musicSound, musicVolume())
-  fun update(self, dt: Float) =
+  fun update(self, io: Io, dt: Float) =
-    if self.over && {isKeyPressed(Key.Enter) || isKeyPressed(Key.KeyR)}
+    if self.over && {io.isKeyPressed(Key.Enter) || io.isKeyPressed(Key.KeyR)}
       self.restart()
-      self.startMusic()
+      self.startMusic(io)
-    left := isKeyDown(Key.Left) || isKeyDown(Key.KeyA)
+    left := io.isKeyDown(Key.Left) || io.isKeyDown(Key.KeyA)
-    right := isKeyDown(Key.Right) || isKeyDown(Key.KeyD)
+    right := io.isKeyDown(Key.Right) || io.isKeyDown(Key.KeyD)
-    up := isKeyDown(Key.Up) || isKeyDown(Key.KeyW)
+    up := io.isKeyDown(Key.Up) || io.isKeyDown(Key.KeyW)
-    down := isKeyDown(Key.Down) || isKeyDown(Key.KeyS)
+    down := io.isKeyDown(Key.Down) || io.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)
+      io.soundPlay(self.pickupSound, 0.8)
     if self.lives < lives
       if self.over
-        soundStop(self.musicSound)
+        io.soundStop(self.musicSound)
-        soundPlay(self.overSound, 1.0)
+        io.soundPlay(self.overSound, 1.0)
       else
-        soundPlay(self.hitSound, 1.0)
+        io.soundPlay(self.hitSound, 1.0)
-  override fun draw(self) =
+  override fun draw(self, io: Io) =
-    self.fit(screenWidth(), screenHeight())
+    self.fit(io.screenWidth(), io.screenHeight())
-    clear(Color.rgb(0.04, 0.05, 0.1))
+    io.clear(Color.rgb(0.04, 0.05, 0.1))
-    self.Stage.draw()
+    self.Stage.draw(io)
 fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -> Bool =
   Math.hypot(ax - bx, ay - by) < ra + rb
@@ -440,13 +441,13 @@ fun overlaps(ax: Float, ay: Float, ra: Float, bx: Float, by: Float, rb: Float) -
 fun musicVolume() -> Float =
   0.3
-export fun init() -> World =
+export fun init(io: Io) -> World =
-  w := World.create(2024, textureLoad("sprites.png"))
+  w := World.create(2024, io.textureLoad("sprites.png"))
-  w.pickupSound = soundLoad("pickup.wav")
+  w.pickupSound = io.soundLoad("pickup.wav")
-  w.hitSound = soundLoad("hit.wav")
+  w.hitSound = io.soundLoad("hit.wav")
-  w.overSound = soundLoad("gameover.wav")
+  w.overSound = io.soundLoad("gameover.wav")
-  w.musicSound = soundLoad("music.wav")
+  w.musicSound = io.soundLoad("music.wav")
-  w.startMusic()
+  w.startMusic(io)
   w
 fun axis(negative: Bool, positive: Bool) -> Float =
@@ -457,11 +458,11 @@ fun axis(negative: Bool, positive: Bool) -> Float =
   else
     0.0
-export fun update(w: World, dt: Float) =
+export fun update(io: Io, w: World, dt: Float) =
-  w.update(dt)
+  w.update(io, dt)
-export fun draw(w: World) =
+export fun draw(io: Io, w: World) =
-  w.draw()
+  w.draw(io)
 # --- tests ---

plum-examples/{scene.plum → games/imperative/scene.plum} RENAMED Viewed

@@ -1,5 +1,5 @@
-# Clockwork: a scene-graph demo (`plum game plum-examples/scene.plum`). A sun, four
+# Clockwork: a scene-graph demo (`plum game plum-examples/games/imperative/scene.plum`). A sun, four
-# planets and their moons orbit by nesting rotating groups (std/game/Scene): each orbit
+# planets and their moons orbit by nesting rotating groups (std/game/imperative/Scene): each orbit
 # is a group whose rotation carries everything inside it, so a moon only ever
 # says "I sit 40 units from my planet" and the maths composes the rest. Click a
 # body to select it (a halo and its name), click again or the background to clear;
@@ -20,7 +20,8 @@ import std/Math
 import std/game/Vec2
 import std/game/Color
 import std/game/Game
-import std/game/Scene
+import std/game/imperative/Scene
+import std/Io
 primitive Layout =
   Width = 800.0
@@ -62,8 +63,8 @@ record Spinner(Actor(width, height, originX, originY), speed: Float, tex: Int, s
     self.rotation = self.rotation + self.speed * dt
     self.actChildren(dt)
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, m: Affine, alpha: Float) =
-    drawSpriteFrame(m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
+    drawSpriteFrame(io, 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) =
@@ -84,8 +85,8 @@ record Walker(Actor, pace: Float, phase: Float, tex: Int, srcX: Float) =
     self.x = nx
     self.y = 510.0 + 50.0 * Math.sin(nx / 90.0 + self.phase)
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, m: Affine, alpha: Float) =
-    drawSpriteFrame(m, alpha, self.width, self.height, self.color, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
+    drawSpriteFrame(io, 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).
@@ -217,49 +218,49 @@ fun tick(sky: Sky, dt: Float) =
 # --- host glue ---
-export fun init() -> Sky =
+export fun init(io: Io) -> Sky =
-  sky := newSky(textureLoad("sprites.png"))
+  sky := newSky(io.textureLoad("sprites.png"))
-  sky.map = textureCreate(Layout.MapW, Layout.MapH)
+  sky.map = io.textureCreate(Layout.MapW, Layout.MapH)
   sky
-export fun update(sky: Sky, dt: Float) =
+export fun update(io: Io, sky: Sky, dt: Float) =
-  if isKeyPressed(Key.Space)
+  if io.isKeyPressed(Key.Space)
     sky.paused = !sky.paused
   tick(sky, dt)
-  fit(sky, screenWidth(), screenHeight())
+  fit(sky, io.screenWidth(), io.screenHeight())
-  if isMousePressed(Mouse.Left)
+  if io.isMousePressed(Mouse.Left)
-    m := mousePos()
+    m := io.mousePos()
     p := sky.stage.screenToStage(m.x, m.y)
     clickAt(sky, p.x, p.y)
 # Redraws the minimap texture (every body as a dot, the selected one highlighted)
 # and shows it in the bottom-right corner of the screen.
-fun drawMinimap(sky: Sky) =
+fun drawMinimap(io: Io, sky: Sky) =
   if sky.map < 0
     return
   k := Layout.MapScale
   w := Float(Layout.MapW)
   h := Float(Layout.MapH)
-  renderTarget(sky.map)
+  io.renderTarget(sky.map)
-  clear(Color(r: 0.05, g: 0.1, b: 0.2, a: 0.85))
+  io.clear(Color(r: 0.05, g: 0.1, b: 0.2, a: 0.85))
-  drawRect(0.0, 0.0, w, 1.0, Color.White)
+  io.drawRect(0.0, 0.0, w, 1.0, Color.White)
-  drawRect(0.0, h - 1.0, w, 1.0, Color.White)
+  io.drawRect(0.0, h - 1.0, w, 1.0, Color.White)
-  drawRect(0.0, 0.0, 1.0, h, Color.White)
+  io.drawRect(0.0, 0.0, 1.0, h, Color.White)
-  drawRect(w - 1.0, 0.0, 1.0, h, Color.White)
+  io.drawRect(w - 1.0, 0.0, 1.0, h, Color.White)
-  drawCircle(Layout.CenterX * k, Layout.CenterY * k, 5.0, Color.Yellow)
+  io.drawCircle(Layout.CenterX * k, Layout.CenterY * k, 5.0, Color.Yellow)
   for i := range sky.bodies.length()
     c := centerOf(sky, i)
     dot := Color(r: 0.6, g: 0.8, b: 1.0, a: 1.0)
     if i == sky.selected
       dot = Color.Yellow
-    drawCircle(c.x * k, c.y * k, 2.0, dot)
+    io.drawCircle(c.x * k, c.y * k, 2.0, dot)
-  renderTarget(-1)
+  io.renderTarget(-1)
-  drawTexture(sky.map, screenWidth() - w - 8.0, screenHeight() - h - 8.0, Color.White)
+  io.drawTexture(sky.map, io.screenWidth() - w - 8.0, io.screenHeight() - h - 8.0, Color.White)
-export fun draw(sky: Sky) =
+export fun draw(io: Io, sky: Sky) =
-  clear(Color.Black)
+  io.clear(Color.Black)
-  sky.stage.draw()
+  sky.stage.draw(io)
-  drawMinimap(sky)
+  drawMinimap(io, sky)
 # --- tests ---
@@ -282,7 +283,7 @@ record ProbeWalker(Actor, speed: Float) =
   override fun act(self, dt: Float) =
     self.x = self.x + self.speed * dt
-  override fun draw(self, m: Affine, alpha: Float) =
+  override fun draw(self, io: Io, m: Affine, alpha: Float) =
     self.drawn = self.drawn + 1
 fun near(a: Float, b: Float) -> Bool =
@@ -405,11 +406,11 @@ test "walker_record: a Walker in a Stage moves via its own act and draws via its
   stage.act(0.5)
   assert near(w.x, 4.0)
   assert w.drawn == 0
-  stage.root.drawTree(Affine.Identity, 1.0)
+  stage.root.drawTree(io, Affine.Identity, 1.0)
-  stage.root.drawTree(Affine.Identity, 1.0)
+  stage.root.drawTree(io, Affine.Identity, 1.0)
   assert w.drawn == 2
   w.visible = false
-  stage.root.drawTree(Affine.Identity, 1.0)
+  stage.root.drawTree(io, Affine.Identity, 1.0)
   assert w.drawn == 2
   w.visible = true
   # a trait value reaches the same record

plum-std/game/{Scene.plum → imperative/Scene.plum} RENAMED Viewed

File without changes