moshcode 0.41.0 → 0.42.0

package/src/games-invaders.mjs

@@ -0,0 +1,258 @@
+// Space Invaders. Forty of them, coming down a row at a time, and the fewer are
+// left the faster the rest move — which is the joke the original hardware told by
+// accident and every version since has kept on purpose.
+//
+// Nothing here moves on a fraction of a cell. The fleet steps a whole column at
+// a time on a counter, shots move a whole row per tick, and every hit is one
+// grid cell against another. A game whose whole tension is "will it get to the
+// bottom before I do" should never lose a shot to a rounding error.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 44;
+export const HEIGHT = 16;
+
+export const ROWS = 5;
+export const COLS = 8;
+const PITCH_X = 4;     // an alien is two cells wide, with two between them
+// One row per rank. At two the fleet stood nine rows tall on a board with eleven
+// above the bunkers, so it "landed" after two drops and no wave was survivable.
+const PITCH_Y = 1;
+
+export const CANNON_ROW = HEIGHT - 2;
+const FLOOR_ROW = HEIGHT - 1;
+export const BUNKER_ROW = HEIGHT - 4;
+const LIVES = 3;
+const BOMB_EVERY = 2;  // bombs fall on every other tick, so they can be dodged
+const SHOT_SPEED = 2;  // rows per tick — a slow shot makes the whole game a queue
+
+/** Top rows are worth more, and look meaner. */
+export const KINDS = [
+  { art: "▛▜", points: 30, paint: rgb(190, 130, 255) },
+  { art: "▛▜", points: 20, paint: rgb(90, 200, 250) },
+  { art: "▙▟", points: 20, paint: acid },
+  { art: "▙▟", points: 10, paint: amber },
+  { art: "▞▚", points: 10, paint: ash },
+];
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/** Where an alien sits, given the fleet's corner. */
+export const alienAt = (fleet, row, col) => ({
+  x: fleet.x + col * PITCH_X,
+  y: fleet.y + row * PITCH_Y,
+});
+
+export const aliveCount = (fleet) => fleet.alive.reduce((n, row) => n + row.filter(Boolean).length, 0);
+
+/**
+ * How many ticks between steps. Forty aliens crawl; the last one sprints. This
+ * is the entire difficulty curve of the game and it costs one line.
+ */
+export const cadence = (fleet) => Math.max(2, Math.round(aliveCount(fleet) / 2.4));
+
+const newFleet = (wave) => ({
+  x: 3,
+  y: 1 + Math.min(3, wave - 1), // each wave starts closer to the floor
+  dir: 1,
+  alive: Array.from({ length: ROWS }, () => Array.from({ length: COLS }, () => true)),
+  clock: 0,
+});
+
+/** Four bunkers, each cell able to take two hits before it is gone. */
+export function buildBunkers() {
+  const bunkers = new Map();
+  for (let b = 0; b < 4; b++) {
+    const left = 5 + b * 10;
+    for (let i = 0; i < 5; i++) bunkers.set(left + i, 2);
+  }
+  return bunkers;
+}
+
+/** Chip a bunker cell, and say whether there was one there to chip. */
+export function chip(bunkers, x, y) {
+  if (y !== BUNKER_ROW) return false;
+  const hp = bunkers.get(x);
+  if (!hp) return false;
+  if (hp <= 1) bunkers.delete(x); else bunkers.set(x, hp - 1);
+  return true;
+}
+
+/** The lowest live alien in each column — the only ones that can drop a bomb. */
+export function frontLine(fleet) {
+  const front = [];
+  for (let col = 0; col < COLS; col++) {
+    for (let row = ROWS - 1; row >= 0; row--) {
+      if (fleet.alive[row][col]) { front.push({ row, col }); break; }
+    }
+  }
+  return front;
+}
+
+/** Whether a shot at (x, y) hits an alien, and which one. */
+export function alienHit(fleet, x, y) {
+  for (let row = 0; row < ROWS; row++) {
+    for (let col = 0; col < COLS; col++) {
+      if (!fleet.alive[row][col]) continue;
+      const at = alienAt(fleet, row, col);
+      if (y === at.y && x >= at.x && x <= at.x + 1) return { row, col };
+    }
+  }
+  return null;
+}
+
+function marchFleet(state) {
+  const fleet = state.fleet;
+  const cols = [];
+  for (let col = 0; col < COLS; col++) if (fleet.alive.some((row) => row[col])) cols.push(col);
+  if (!cols.length) return state;
+  const leftMost = fleet.x + cols[0] * PITCH_X;
+  const rightMost = fleet.x + cols[cols.length - 1] * PITCH_X + 1;
+
+  if ((fleet.dir > 0 && rightMost >= WIDTH - 1) || (fleet.dir < 0 && leftMost <= 0)) {
+    fleet.dir *= -1;
+    fleet.y += 1;
+  } else {
+    fleet.x += fleet.dir;
+  }
+
+  // The fleet landing is the loss condition, and it beats having lives left.
+  for (let row = 0; row < ROWS; row++) {
+    for (let col = 0; col < COLS; col++) {
+      if (fleet.alive[row][col] && alienAt(fleet, row, col).y >= BUNKER_ROW) {
+        state.over = `the fleet landed · ${state.score} points`;
+        return state;
+      }
+    }
+  }
+  return state;
+}
+
+/** One tick. Exported so a test can clear a wave with no clock. */
+export function step(state) {
+  const { rng } = state;
+
+  // The shot climbs a row at a time even though it covers two, so it can never
+  // skip over the row an alien is standing on.
+  for (let i = 0; i < SHOT_SPEED && state.shot; i++) {
+    state.shot.y -= 1;
+    if (state.shot.y < 0) { state.shot = null; break; }
+    if (chip(state.bunkers, state.shot.x, state.shot.y)) { state.shot = null; break; }
+    const hit = alienHit(state.fleet, state.shot.x, state.shot.y);
+    if (!hit) continue;
+    state.fleet.alive[hit.row][hit.col] = false;
+    state.score += KINDS[hit.row].points;
+    state.shot = null;
+    if (!aliveCount(state.fleet)) {
+      state.wave++;
+      state.fleet = newFleet(state.wave);
+      state.bombs = [];
+      return state;
+    }
+  }
+
+  state.tick++;
+  if (state.tick % BOMB_EVERY === 0) {
+    for (const bomb of state.bombs) bomb.y += 1;
+    state.bombs = state.bombs.filter((bomb) => {
+      if (chip(state.bunkers, bomb.x, bomb.y)) return false;
+      if (bomb.y >= FLOOR_ROW) return false;
+      if (bomb.y === CANNON_ROW && Math.abs(bomb.x - state.cannon) <= 1) {
+        state.lives--;
+        if (state.lives <= 0) { state.lives = 0; state.over = `out of cannons · ${state.score} points`; }
+        return false;
+      }
+      return true;
+    });
+  }
+  if (state.over) return state;
+
+  // Somebody on the front line lets one go, more often the fewer are left.
+  const front = frontLine(state.fleet);
+  if (front.length && state.bombs.length < 3 && rng() < 0.02 + (COLS - front.length) * 0.004) {
+    const from = front[Math.floor(rng() * front.length) % front.length];
+    const at = alienAt(state.fleet, from.row, from.col);
+    state.bombs.push({ x: at.x, y: at.y + 1 });
+  }
+
+  state.fleet.clock++;
+  if (state.fleet.clock >= cadence(state.fleet)) {
+    state.fleet.clock = 0;
+    marchFleet(state);
+  }
+  return state;
+}
+
+export const INVADERS = {
+  key: "invaders",
+  aliases: ["spaceinvaders", "space", "aliens"],
+  title: "SPACE INVADERS",
+  blurb: "forty of them, and the last one moves fastest",
+  keys: "← → move · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      fleet: newFleet(1),
+      bunkers: buildBunkers(),
+      cannon: Math.floor(WIDTH / 2),
+      shot: null,
+      bombs: [],
+      score: 0,
+      lives: LIVES,
+      wave: 1,
+      tick: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "left") state.cannon = clamp(state.cannon - 1, 1, WIDTH - 2);
+    else if (key === "right") state.cannon = clamp(state.cannon + 1, 1, WIDTH - 2);
+    else if (key === "space" || key === "up" || key === "enter") {
+      // One shot in the air at a time. Everything about the pacing of this game
+      // comes from that single rule.
+      if (!state.shot) state.shot = { x: state.cannon, y: CANNON_ROW - 1 };
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? state.over
+      : `${state.score} · wave ${state.wave} · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (let row = 0; row < ROWS; row++) {
+      for (let col = 0; col < COLS; col++) {
+        if (!state.fleet.alive[row][col]) continue;
+        const at = alienAt(state.fleet, row, col);
+        const kind = KINDS[row];
+        [...kind.art].forEach((c, i) => put(at.x + i, at.y, kind.paint(c)));
+      }
+    }
+
+    for (const [x, hp] of state.bunkers) put(x, BUNKER_ROW, hp > 1 ? acid("█") : dim("▓"));
+    for (const bomb of state.bombs) put(bomb.x, bomb.y, danger("╽"));
+    if (state.shot) put(state.shot.x, state.shot.y, bone("│"));
+
+    if (state.over) {
+      put(state.cannon, CANNON_ROW, danger("✷"));
+    } else {
+      [...("▟█▙")].forEach((c, i) => put(state.cannon - 1 + i, CANNON_ROW, acid(c)));
+    }
+
+    return grid.map((row, y) => row.map((cell) => (
+      cell ?? (y === FLOOR_ROW ? ash("═") : " ")
+    )).join(""));
+  },
+};

package/src/games-kong.mjs

@@ -0,0 +1,191 @@
+// Kong. Girders, ladders, barrels, and a climb you have done before.
+//
+// The girders here are flat. The originals slope, and a slope is the one thing
+// this board cannot honestly draw — a terminal row is a terminal row, and faking
+// it with half-blocks would make a game that looks like the arcade and plays
+// like a bug report. What the slope actually *does* is kept: each girder has a
+// direction, they alternate, and the ladder down sits at the far end of each
+// one. So barrels cross a whole girder and drop, and a player climbing the same
+// ladders walks every girder the opposite way — which is why you meet them head
+// on instead of following them around.
+import { acid, amber, ash, bone, danger, rgb } from "./ui.mjs";
+
+export const WIDTH = 34;
+export const HEIGHT = 17;
+
+/**
+ * Top to bottom: the row, the way barrels roll along it, the column of the
+ * ladder barrels come down, and a second ladder that only you use.
+ *
+ * The second one is not decoration. With a single ladder per girder, the only
+ * way up is the chute the barrels fall down, and climbing it is a coin toss you
+ * cannot jump out of — the board becomes unplayable rather than hard.
+ */
+export const GIRDERS = [
+  { y: 3, dir: -1, ladder: 3, climb: WIDTH - 12 },
+  { y: 6, dir: 1, ladder: WIDTH - 4, climb: 8 },
+  { y: 9, dir: -1, ladder: 3, climb: WIDTH - 12 },
+  { y: 12, dir: 1, ladder: WIDTH - 4, climb: 8 },
+  { y: 15, dir: -1, ladder: null, climb: null },
+];
+
+export const TOP = GIRDERS[0].y;
+export const FLOOR = GIRDERS[GIRDERS.length - 1].y;
+
+/** Where Kong stands and throws from, and the way out beside him. */
+export const KONG_X = WIDTH - 3;
+const GOAL_X = WIDTH - 6;
+
+const LIVES = 3;
+const JUMP_TICKS = 6;
+const kong = rgb(190, 130, 255);
+
+export const girderAt = (y) => GIRDERS.find((g) => g.y === y) ?? null;
+
+/** The ladders, derived from the girders so the two can never disagree. */
+export const LADDERS = GIRDERS.slice(0, -1).flatMap((g, i) => (
+  [g.ladder, g.climb].map((x) => ({ x, top: g.y, bottom: GIRDERS[i + 1].y, barrels: x === g.ladder }))
+));
+
+export const ladderAt = (x, y) => LADDERS.find((l) => l.x === x && y >= l.top && y <= l.bottom) ?? null;
+
+/** A barrel starts at Kong's end of the top girder and works its way down. */
+export const newBarrel = () => ({ x: KONG_X, y: TOP, falling: null, jumped: false });
+
+/**
+ * One barrel step: along its girder in that girder's direction, and down the
+ * ladder at the end of it. Rolling off the bottom girder is how a barrel leaves.
+ */
+export function rollBarrel(state, barrel) {
+  if (barrel.falling !== null) {
+    barrel.y += 1;
+    if (barrel.y >= barrel.falling) barrel.falling = null;
+    return barrel;
+  }
+  const girder = girderAt(barrel.y);
+  if (!girder) { barrel.done = true; return barrel; }
+  if (girder.ladder !== null && barrel.x === girder.ladder) {
+    // Mostly it takes the ladder; sometimes it carries on and rolls off the end,
+    // which is the only thing that makes two barrels behave differently.
+    if (state.rng() < 0.8) {
+      barrel.falling = GIRDERS[GIRDERS.indexOf(girder) + 1].y;
+      return barrel;
+    }
+  }
+  barrel.x += girder.dir;
+  if (barrel.x < 0 || barrel.x >= WIDTH) barrel.done = true;
+  return barrel;
+}
+
+function lose(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  state.player = { x: 1, y: FLOOR, jump: 0 };
+  state.barrels = [];
+  return state;
+}
+
+/** Barrels roll this often, and a level makes them quicker. */
+export const rollEvery = (state) => Math.max(2, 5 - Math.floor(state.level / 2));
+export const throwEvery = (state) => Math.max(14, 40 - state.level * 5);
+
+/** One tick. Exported so a test can climb the whole board with no clock. */
+export function step(state) {
+  state.clock++;
+  if (state.player.jump > 0) state.player.jump--;
+
+  if (state.clock % rollEvery(state) === 0) {
+    for (const barrel of state.barrels) rollBarrel(state, barrel);
+    state.barrels = state.barrels.filter((b) => !b.done);
+  }
+  if (state.clock % throwEvery(state) === 0) state.barrels.push(newBarrel());
+
+  for (const barrel of state.barrels) {
+    if (barrel.x !== state.player.x || barrel.y !== state.player.y) continue;
+    // A barrel you are in the air over is a barrel you have jumped.
+    if (!state.player.jump) return lose(state, "flattened by a barrel");
+    if (!barrel.jumped) { barrel.jumped = true; state.score += 100; }
+  }
+
+  if (state.player.y === TOP && state.player.x >= GOAL_X) {
+    state.level++;
+    state.score += 1000;
+    state.player = { x: 1, y: FLOOR, jump: 0 };
+    state.barrels = [];
+  }
+  return state;
+}
+
+export const KONG = {
+  key: "kong",
+  aliases: ["dk", "barrels", "climb"],
+  title: "KONG",
+  blurb: "five girders, four ladders, and a barrel with your name on it",
+  keys: "← → walk · ↑ ↓ ladders · space jump · q quit",
+  tickMs: 60,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      player: { x: 1, y: FLOOR, jump: 0 },
+      barrels: [],
+      score: 0,
+      lives: LIVES,
+      level: 1,
+      clock: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    const p = state.player;
+    if (pressed === "space" || pressed === "enter") {
+      if (!p.jump) p.jump = JUMP_TICKS;
+      return state;
+    }
+    if (pressed === "left" && p.x > 0) p.x -= 1;
+    else if (pressed === "right" && p.x < WIDTH - 1) p.x += 1;
+    else if (pressed === "up" || pressed === "down") {
+      // Ladders are the only way between girders, and you have to be standing on
+      // one to use it.
+      const ladder = ladderAt(p.x, p.y);
+      if (!ladder) return state;
+      const next = pressed === "up" ? p.y - 1 : p.y + 1;
+      if (next >= ladder.top && next <= ladder.bottom) p.y = next;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? state.over
+      : `${state.score} · level ${state.level} · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const girder of GIRDERS) for (let x = 0; x < WIDTH; x++) put(x, girder.y, ash("═"));
+    for (const ladder of LADDERS) {
+      for (let y = ladder.top; y <= ladder.bottom; y++) put(ladder.x, y, bone("╫"));
+    }
+    put(KONG_X, TOP - 1, kong("♜"));
+    put(GOAL_X, TOP - 1, amber("♥"));
+
+    for (const barrel of state.barrels) put(barrel.x, barrel.y, danger("◍"));
+    const p = state.player;
+    put(p.x, p.jump ? p.y - 1 : p.y, state.over ? danger("✷") : acid(p.jump ? "⌃" : "◉"));
+
+    return grid.map((row) => row.map((cell) => cell ?? " ").join(""));
+  },
+};

package/src/games-outrun.mjs

@@ -0,0 +1,208 @@
+// OutRun. A road drawn in perspective, a clock that is always losing, and a
+// checkpoint that gives you a bit of it back.
+//
+// This is the one game in the cabinet that fakes a third dimension, and it does
+// it the way the eighties did: the road is not an object, it is a rule for
+// drawing each row. Rows near the top are far away, so the tarmac is narrow
+// there and the bend is wide; rows near the bottom are under your bumper, so the
+// tarmac is wide and dead centre. Nothing is ever transformed — `roadHalf` and
+// `centreAt` are the whole renderer, and the same two functions decide what you
+// have hit.
+import { acid, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 48;
+export const HEIGHT = 16;
+
+const NEAR_HALF = 20;   // half the road's width under your bumper
+const FAR_HALF = 3;     // and up at the horizon
+const BEND = 15;        // how far a full-lock corner throws the far end sideways
+
+const MAX_SPEED = 1.9;
+const ACCEL = 0.06;
+const BRAKE = 0.12;
+const DRAG = 0.012;
+const OFF_ROAD = 0.55;  // the fastest you will ever go with two wheels on the grass
+const DRIFT = 0.5;      // how hard a corner pushes you towards the outside
+const START_TIME = 900; // ticks
+const CHECKPOINT = 320; // and how far apart the checkpoints are
+const CHECK_BONUS = 220; // flat out, a checkpoint takes about 170 ticks to reach
+
+const grass = rgb(60, 140, 70);
+const road = rgb(90, 90, 95);
+
+/** How far from the middle the tarmac reaches on a given row. */
+export const roadHalf = (row) => {
+  const p = (row + 1) / HEIGHT;
+  return FAR_HALF + (NEAR_HALF - FAR_HALF) * p ** 1.7;
+};
+
+/**
+ * Where the middle of the road is on a given row.
+ *
+ * The bend is squared against distance so it opens up towards the horizon and
+ * closes to nothing under the car — which is exactly what a corner looks like
+ * from the driver's seat, and why the bottom row never moves.
+ */
+export const centreAt = (row, curve) => {
+  const p = (row + 1) / HEIGHT;
+  return WIDTH / 2 + curve * BEND * (1 - p) ** 2;
+};
+
+export const PLAYER_ROW = HEIGHT - 1;
+export const CAR_W = 3;
+
+/** A stretch of road: how long it runs, and how hard it bends. */
+export function nextSegment(rng) {
+  return { left: 40 + Math.floor(rng() * 60), curve: (rng() * 2 - 1) * (rng() < 0.35 ? 1 : 0.45) };
+}
+
+/** Whether the car is on the tarmac at all. */
+export const onRoad = (x, curve) => Math.abs(x - centreAt(PLAYER_ROW, curve)) <= roadHalf(PLAYER_ROW) - 1;
+
+/** Where a car at depth `z` (1 at the horizon, 0 at your bumper) is drawn. */
+export const rowAt = (z) => Math.round(PLAYER_ROW - z * (PLAYER_ROW - 1));
+
+function spin(state) {
+  state.speed = 0;
+  state.spins++;
+  state.stunned = 30;
+  return state;
+}
+
+/** One tick of road. Exported so a test can drive the whole stage with no clock. */
+export function step(state) {
+  state.clock--;
+  if (state.clock <= 0) {
+    state.clock = 0;
+    state.over = `time up · ${Math.round(state.dist)} miles`;
+    return state;
+  }
+  if (state.stunned > 0) state.stunned--;
+
+  // The road ahead, one segment at a time, eased towards rather than snapped to.
+  state.segment.left -= state.speed;
+  if (state.segment.left <= 0) state.segment = nextSegment(state.rng);
+  state.curve += (state.segment.curve - state.curve) * 0.04;
+
+  state.speed = Math.max(0, state.speed - DRAG);
+  const off = !onRoad(state.car, state.curve);
+  if (off) state.speed = Math.min(state.speed, OFF_ROAD);
+  if (state.stunned) state.speed = Math.min(state.speed, 0.2);
+
+  state.dist += state.speed;
+  // A corner throws you at the outside of it. Steering is how you stay in.
+  state.car += state.curve * state.speed * DRIFT;
+  state.car = Math.max(0, Math.min(WIDTH - 1, state.car));
+
+  for (const car of state.traffic) car.z -= (state.speed - car.speed) * 0.012;
+  state.traffic = state.traffic.filter((c) => c.z > -0.05 && c.z < 1.2);
+  if (state.traffic.length < 3 && state.rng() < 0.03) {
+    state.traffic.push({ z: 1.1, lane: state.rng() * 1.4 - 0.7, speed: 0.35 + state.rng() * 0.5 });
+  }
+
+  if (!state.stunned) {
+    const hit = state.traffic.find((c) => {
+      if (c.z > 0.08) return false;
+      const at = centreAt(PLAYER_ROW, state.curve) + c.lane * roadHalf(PLAYER_ROW);
+      return Math.abs(at - state.car) < CAR_W;
+    });
+    if (hit) {
+      state.traffic = state.traffic.filter((c) => c !== hit);
+      spin(state);
+    }
+  }
+
+  if (state.dist >= state.nextCheck) {
+    state.nextCheck += CHECKPOINT;
+    state.clock += CHECK_BONUS;
+    state.checks++;
+    state.score += 1000;
+  }
+  state.score += Math.floor(state.dist) - state.scored;
+  state.scored = Math.floor(state.dist);
+  return state;
+}
+
+export const OUTRUN = {
+  key: "outrun",
+  aliases: ["run", "coast", "racer"],
+  title: "OUTRUN",
+  blurb: "a road that bends, traffic that doesn't, and a clock that always wins",
+  keys: "← → steer · ↑ throttle · ↓ brake · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      car: WIDTH / 2,
+      speed: 0,
+      curve: 0,
+      segment: nextSegment(rng),
+      traffic: [],
+      dist: 0,
+      scored: 0,
+      nextCheck: CHECKPOINT,
+      checks: 0,
+      clock: START_TIME,
+      stunned: 0,
+      spins: 0,
+      score: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    if (pressed === "left") state.car -= 0.9;
+    else if (pressed === "right") state.car += 0.9;
+    else if (pressed === "up") state.speed = Math.min(MAX_SPEED, state.speed + ACCEL * 4);
+    else if (pressed === "down") state.speed = Math.max(0, state.speed - BRAKE * 2);
+    state.car = Math.max(0, Math.min(WIDTH - 1, state.car));
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const kph = Math.round(state.speed * 120);
+    return `${kph} kph · ${Math.round(state.clock / 20)}s · check ${state.checks} · ${Math.round(state.dist)} mi`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const car of state.traffic) {
+      const row = rowAt(car.z);
+      if (row < 1 || row > PLAYER_ROW) continue;
+      const at = centreAt(row, state.curve) + car.lane * roadHalf(row);
+      // Cars shrink with distance, the same way the road does.
+      const w = Math.max(1, Math.round(CAR_W * ((row + 1) / HEIGHT)));
+      for (let i = 0; i < w; i++) put(Math.round(at) - Math.floor(w / 2) + i, row, danger("▀"));
+    }
+
+    const nose = state.stunned ? danger("✷") : acid("▟▙");
+    put(Math.round(state.car) - 1, PLAYER_ROW, state.stunned ? nose : acid("▟"));
+    put(Math.round(state.car), PLAYER_ROW, state.stunned ? nose : acid("█"));
+    put(Math.round(state.car) + 1, PLAYER_ROW, state.stunned ? nose : acid("▙"));
+
+    return grid.map((row, y) => {
+      const centre = centreAt(y, state.curve);
+      const half = roadHalf(y);
+      return row.map((cell, x) => {
+        if (cell) return cell;
+        const from = centre - half;
+        const to = centre + half;
+        if (x < from || x > to) return grass("░");
+        // Kerbs, and a centre line that moves with you so the road runs.
+        if (x < from + 1 || x > to - 1) return ((y + Math.floor(state.dist)) % 4 < 2 ? bone : danger)("│");
+        const middle = Math.round(centre);
+        if (x === middle && (y + Math.floor(state.dist * 1.5)) % 4 < 2) return dim("┆");
+        return road(" ");
+      }).join("");
+    });
+  },
+};