9cfafea | plum | pyrossh

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

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

9cfafea — Peter John 2026-11-02T20:47:29+05:30

game_scene: keep animating at game over

Files changed (1) hide show

plum-examples/game_scene.plum +48 -9

plum-examples/game_scene.plum CHANGED Viewed

@@ -90,7 +90,7 @@ fun mineCount(score: Int) -> Int =
 # (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) =
+record Ship(Actor, vx: Float, vy: Float, ax: Float, ay: Float, hurt: Float, clock: Float, tex: Int, live: Bool) =
   fun create(sheet: Int, x: Float, y: Float) -> Ship =
     size := Rules.Cell * Rules.Zoom
@@ -99,12 +99,14 @@ record Ship(Actor, vx: Float, vy: Float, ax: Float, ay: Float, hurt: Float, cloc
       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)
+      vx: 0.0, vy: 0.0, ax: 0.0, ay: 0.0, hurt: 0.0, clock: 0.0, tex: sheet, live: true)
   # 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
+    if !self.live
+      return
     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
@@ -137,7 +139,7 @@ record Ship(Actor, vx: Float, vy: Float, ax: Float, ay: Float, hurt: Float, cloc
     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) =
+record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int, live: Bool) =
   fun create(sheet: Int, phase: Float, at: Motion) -> Orb =
     size := Rules.Cell * Rules.Zoom
@@ -146,7 +148,7 @@ record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
       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)
+      vx: at.vx, vy: at.vy, phase: phase, clock: 0.0, tex: sheet, live: true)
   fun motion(self) -> Motion =
     Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
@@ -159,6 +161,8 @@ record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
   fun act(self, dt: Float) =
     self.clock = self.clock + dt
+    if !self.live
+      return
     m := self.motion()
     drift(m, Rules.OrbRadius, dt)
     self.place(m)
@@ -174,7 +178,7 @@ record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
     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) =
+record Mine(Actor, vx: Float, vy: Float, clock: Float, tex: Int, live: Bool) =
   fun create(sheet: Int, at: Motion) -> Mine =
     size := Rules.Cell * Rules.Zoom
@@ -183,7 +187,7 @@ record Mine(Actor, vx: Float, vy: Float, clock: Float, tex: Int) =
       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)
+      vx: at.vx, vy: at.vy, clock: 0.0, tex: sheet, live: true)
   fun motion(self) -> Motion =
     Motion(x: self.x, y: self.y, vx: self.vx, vy: self.vy)
@@ -196,6 +200,8 @@ record Mine(Actor, vx: Float, vy: Float, clock: Float, tex: Int) =
   fun act(self, dt: Float) =
     self.clock = self.clock + dt
+    if !self.live
+      return
     m := self.motion()
     drift(m, Rules.MineRadius, dt)
     self.place(m)
@@ -336,18 +342,27 @@ fun sync(w: World) =
     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
 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.
+# 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
-  if w.over
+  setLive(w, !w.over)
-    return
   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)
@@ -544,6 +559,30 @@ test "the game ends at zero lives and then ignores steps"
   step(w, 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.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)
+  assert w.over
+  x := mine.x
+  rot := mine.rotation
+  clock := mine.clock
+  orbClock := w.orbList.at(0).clock
+  star := Star.create(0)
+  w.stage.root.children.at(1).add(star)
+  for i := range 10
+    step(w, 1.0, 0.0, 0.1)
+  assert mine.x == x
+  assert mine.rotation == rot
+  assert w.ship.x == Rules.ArenaW / 2.0
+  assert !w.ship.visible
+  assert mine.clock > clock + 0.9
+  assert w.orbList.at(0).clock > orbClock + 0.9
+  assert star.clock > 0.9
+  assert w.score == 0
 test "restart resets the run and keeps the best score"
   w := emptyWorld()
   w.score = 90