Lucas WintherandClaude Fable 5.2
edd57f0148
Audit pass: - Frame rule counts frames since the last move, so every step lasts exactly movesEvery(score) frames, also right after a speed-up - clampTime + MAX_GAP_MS: a hidden tab no longer replays the whole gap - Pong Restart keeps held keys - Fact corrections (mulberry32 output coverage, Haskell IO, uniform) - New fixture cases from a mutation analysis Extensions (all three tracks, shared fixtures, course text): - Turn queue (Exercise 10.6), persisted high score (10.7), replay viewer (10.8), play() end-to-end helper (9.5) - Optional State (4.7) and optional Module 7b, stack-safe IO - Module 12, property-based testing with generators, shrinking, invariants and a model-based oracle - Module 13, Conway's Life with a Click event - JS type checking via jsconfig, JSDoc and types.d.ts - Maintainer tools: scripts/mutate.mjs, scripts/typecheck-js.sh, Playwright end-to-end suite (e2e/, scripts/e2e.sh) Docs: docs/contract.md is the canonical contract; specs and build log under docs/superpowers. Verified: JS 728, Scala 689, F# 691 unit tests; stubs and progression M01-M13 and M07b; 176 end-to-end tests on Chromium and WebKit. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
52 lines
2.1 KiB
Scala
52 lines
2.1 KiB
Scala
package snake
|
|
|
|
/** The outside world, as the runtime sees it. */
|
|
trait Platform:
|
|
def fillRect(x: Int, y: Int, w: Int, h: Int, color: String): Unit
|
|
def fillText(x: Int, y: Int, text: String, color: String, size: Int, align: String): Unit
|
|
def randomSeed(): Long
|
|
def loadBest(): Int // m10
|
|
def saveBest(score: Int): Unit // m10
|
|
def startClock(onTime: Long => Unit): Unit
|
|
def onKeyDown(cb: String => Unit): Unit
|
|
def onKeyUp(cb: String => Unit): Unit
|
|
def onClick(cb: (Int, Int) => Unit): Unit // m13
|
|
|
|
/**
|
|
* m09 runtime: the single impure place in the course (with the web/ glue); everything else only builds values.
|
|
* Here we interpret IO descriptions against a Platform and hold the one mutable variable, the current stream.
|
|
*/
|
|
object Runtime:
|
|
|
|
// Perform one op on the platform and return its answer.
|
|
private def perform(op: Op, p: Platform): OpResult = op match
|
|
case Op.RandomSeed => OpResult.Seed(p.randomSeed())
|
|
case Op.LoadBest => OpResult.Best(p.loadBest())
|
|
case Op.SaveBest(score) =>
|
|
p.saveBest(score)
|
|
OpResult.Done
|
|
case Op.Draw(Shape.Rect(x, y, w, h, color)) =>
|
|
p.fillRect(x, y, w, h, color)
|
|
OpResult.Done
|
|
case Op.Draw(Shape.Text(x, y, text, color, size, align)) =>
|
|
p.fillText(x, y, text, color, size, align)
|
|
OpResult.Done
|
|
|
|
// Tail recursive, so it compiles to a loop: a scene is hundreds of ops and the stack must not grow with them.
|
|
@annotation.tailrec
|
|
def runIO[A](io: IO[A], p: Platform): A = io match
|
|
case IO.Pure(a) => a
|
|
case IO.Effect(op, k) => runIO(k(perform(op, p)), p)
|
|
|
|
def runApp(main: IO[Stream[IO[Unit]]], p: Platform): Unit =
|
|
var stream = runIO(main, p)
|
|
def feed(event: Event): Unit =
|
|
val (ios, next) = stream.step(event)
|
|
stream = next
|
|
ios.foreach(runIO(_, p))
|
|
p.onKeyDown(key => feed(Event.KeyDown(key)))
|
|
p.onKeyUp(key => feed(Event.KeyUp(key)))
|
|
// m13: a fourth kind of input. Programs that do not listen for clicks simply ignore them.
|
|
p.onClick((x, y) => feed(Event.Click(x, y)))
|
|
p.startClock(t => feed(Event.Time(t)))
|