moshcode 0.41.0 → 0.42.0

package/src/games-digdug.mjs

@@ -0,0 +1,267 @@
+// Dig Dug. You are underground, everything down here wants you, and the only
+// wall between you and it is the ground you have not dug yet.
+//
+// The board is the enemy AI. There is no pathfinding: a monster walks the tunnel
+// it is in and turns towards you at a junction, so the shape you dig is the
+// shape of the fight. Dig a straight line and they queue up behind you; dig a
+// loop and they come round both ends of it.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 40;
+export const HEIGHT = 16;
+export const SKY = 1;          // rows above this are open air
+
+const LIVES = 3;
+const HARPOON = 5;             // how far the pump reaches
+const POPS_AT = 3;             // pumps to burst a monster
+const MONSTER_EVERY = 9;       // ticks between monster steps
+const ROCK_EVERY = 3;
+
+const soil = rgb(150, 100, 60);
+const DIRS = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
+
+const key = (x, y) => `${x},${y}`;
+
+/** Solid ground everywhere below the sky, minus the shafts the level starts with. */
+export function buildGround() {
+  const ground = new Set();
+  for (let y = SKY + 1; y < HEIGHT; y++) for (let x = 0; x < WIDTH; x++) ground.add(key(x, y));
+  return ground;
+}
+
+export const isDug = (ground, x, y) => (
+  x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT && !ground.has(key(x, y))
+);
+
+/** Where the monsters and rocks start — spread out, and never on top of you. */
+export function populate(state, level) {
+  state.monsters = [];
+  for (let i = 0; i < 3 + Math.min(3, level - 1); i++) {
+    state.monsters.push({
+      x: 6 + Math.floor(state.rng() * (WIDTH - 12)),
+      y: SKY + 2 + Math.floor(state.rng() * (HEIGHT - SKY - 3)),
+      dir: state.rng() < 0.5 ? "left" : "right",
+      pumped: 0,
+      ghost: 0,
+    });
+  }
+  state.rocks = [];
+  for (let i = 0; i < 4; i++) {
+    state.rocks.push({
+      x: 4 + Math.floor(state.rng() * (WIDTH - 8)),
+      y: SKY + 2 + Math.floor(state.rng() * 5),
+      falling: false,
+    });
+  }
+  // Every monster and rock starts buried, so the board opens up only where you
+  // dig it.
+  for (const thing of [...state.monsters, ...state.rocks]) state.ground.delete(key(thing.x, thing.y));
+  return state;
+}
+
+function lose(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  state.player = { x: Math.floor(WIDTH / 2), y: SKY + 1, dir: "down" };
+  state.harpoon = null;
+  state.ground.delete(key(state.player.x, state.player.y));
+  return state;
+}
+
+/** A rock with nothing under it falls, and takes anything under it with it. */
+export function fallRocks(state) {
+  for (const rock of state.rocks) {
+    const below = { x: rock.x, y: rock.y + 1 };
+    if (!rock.falling && !isDug(state.ground, below.x, below.y)) continue;
+    if (below.y >= HEIGHT) { rock.falling = false; continue; }
+    rock.falling = true;
+    rock.y += 1;
+    state.ground.delete(key(rock.x, rock.y));
+    const squashed = state.monsters.filter((m) => m.x === rock.x && m.y === rock.y);
+    if (squashed.length) {
+      state.monsters = state.monsters.filter((m) => !squashed.includes(m));
+      state.score += squashed.length * 200;
+    }
+    if (state.player.x === rock.x && state.player.y === rock.y) return lose(state, "under a rock");
+  }
+  return state;
+}
+
+/** One monster step: down its own tunnel, turning towards you at a junction. */
+export function walkMonster(state, monster) {
+  if (monster.pumped) return monster;   // a hooked monster is going nowhere
+  const player = state.player;
+
+  // Once in a while one gives up on the tunnels and comes straight through the
+  // ground at you. Without it, a player who digs one deep hole is untouchable.
+  if (monster.ghost > 0) {
+    monster.ghost--;
+    monster.x += Math.sign(player.x - monster.x);
+    if (monster.x === player.x) monster.y += Math.sign(player.y - monster.y);
+    return monster;
+  }
+  if (state.rng() < 0.02) { monster.ghost = 6; return monster; }
+
+  const options = Object.entries(DIRS)
+    .filter(([, [dx, dy]]) => isDug(state.ground, monster.x + dx, monster.y + dy))
+    .sort(([, a], [, b]) => {
+      const da = Math.abs(monster.x + a[0] - player.x) + Math.abs(monster.y + a[1] - player.y);
+      const db = Math.abs(monster.x + b[0] - player.x) + Math.abs(monster.y + b[1] - player.y);
+      return da - db;
+    });
+  if (!options.length) return monster;
+  // It prefers the way it is already going when that is no worse, so it does not
+  // jitter on the spot at a crossroads.
+  const [name, [dx, dy]] = options[0];
+  monster.dir = name;
+  monster.x += dx;
+  monster.y += dy;
+  return monster;
+}
+
+/** One tick. Exported so a test can clear a level with no clock. */
+export function step(state) {
+  state.clock++;
+
+  if (state.clock % ROCK_EVERY === 0) {
+    fallRocks(state);
+    if (state.over) return state;
+  }
+
+  if (state.harpoon) {
+    // The harpoon holds whatever it caught; it is the pump that does the work.
+    const hooked = state.monsters.find((m) => m === state.harpoon.on);
+    if (!hooked) state.harpoon = null;
+  }
+
+  if (state.clock % MONSTER_EVERY === 0) {
+    for (const monster of state.monsters) walkMonster(state, monster);
+    const caught = state.monsters.find((m) => m.x === state.player.x && m.y === state.player.y);
+    if (caught) return lose(state, "caught underground");
+  }
+
+  if (!state.monsters.length) {
+    state.level++;
+    state.ground = buildGround();
+    state.player = { x: Math.floor(WIDTH / 2), y: SKY + 1, dir: "down" };
+    state.ground.delete(key(state.player.x, state.player.y));
+    state.score += 500;
+    populate(state, state.level);
+  }
+  return state;
+}
+
+/** Fire the harpoon down the tunnel you are facing, or pump what is on it. */
+export function pump(state) {
+  if (state.harpoon) {
+    const monster = state.harpoon.on;
+    monster.pumped++;
+    if (monster.pumped >= POPS_AT) {
+      state.monsters = state.monsters.filter((m) => m !== monster);
+      state.score += 100 * POPS_AT;
+      state.harpoon = null;
+    }
+    return state;
+  }
+  const [dx, dy] = DIRS[state.player.dir];
+  for (let i = 1; i <= HARPOON; i++) {
+    const x = state.player.x + dx * i;
+    const y = state.player.y + dy * i;
+    if (!isDug(state.ground, x, y)) break;   // it does not go through dirt
+    const monster = state.monsters.find((m) => m.x === x && m.y === y);
+    if (monster) {
+      state.harpoon = { on: monster, x, y };
+      monster.pumped = 1;
+      return state;
+    }
+  }
+  return state;
+}
+
+export const DIGDUG = {
+  key: "digdug",
+  aliases: ["dig", "pooka"],
+  title: "DIG DUG",
+  blurb: "dig the tunnels, pump the monsters, drop rocks on the rest",
+  keys: "← ↑ ↓ → dig · space pump · q quit",
+  tickMs: 60,
+
+  create({ rng = Math.random } = {}) {
+    const state = {
+      ground: buildGround(),
+      player: { x: Math.floor(WIDTH / 2), y: SKY + 1, dir: "down" },
+      monsters: [],
+      rocks: [],
+      harpoon: null,
+      score: 0,
+      lives: LIVES,
+      level: 1,
+      clock: 0,
+      over: null,
+      rng,
+    };
+    state.ground.delete(key(state.player.x, state.player.y));
+    return populate(state, 1);
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    if (pressed === "space" || pressed === "enter") return pump(state);
+    const move = DIRS[pressed];
+    if (!move) return state;
+    // Moving is digging: the tunnel is wherever you have been.
+    state.harpoon = null;
+    state.player.dir = pressed;
+    const x = state.player.x + move[0];
+    const y = state.player.y + move[1];
+    if (x < 0 || x >= WIDTH || y <= SKY || y >= HEIGHT) return state;
+    if (state.rocks.some((r) => r.x === x && r.y === y && !r.falling)) return state;
+    if (state.ground.delete(key(x, y))) state.score += 1;
+    state.player.x = x;
+    state.player.y = y;
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? state.over
+      : `${state.score} · level ${state.level} · ${state.monsters.length} left · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, (_, y) => Array.from({ length: WIDTH }, (_, x) => (
+      state.ground.has(key(x, y)) ? soil("▒") : null
+    )));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const rock of state.rocks) put(rock.x, rock.y, ash("▣"));
+    for (const monster of state.monsters) {
+      // A monster part-way through being pumped is visibly bigger, which is the
+      // only feedback the pump gives you.
+      const art = monster.pumped >= 2 ? "◯" : monster.pumped ? "◎" : "◉";
+      put(monster.x, monster.y, (monster.ghost ? amber : danger)(art));
+    }
+    if (state.harpoon) {
+      const [dx, dy] = DIRS[state.player.dir];
+      for (let i = 1; i < HARPOON; i++) {
+        const x = state.player.x + dx * i;
+        const y = state.player.y + dy * i;
+        if (x === state.harpoon.x && y === state.harpoon.y) break;
+        put(x, y, bone(dx ? "─" : "│"));
+      }
+    }
+    put(state.player.x, state.player.y, state.over ? danger("✷") : acid("◈"));
+
+    return grid.map((row, y) => row.map((cell) => (
+      cell ?? (y <= SKY ? dim("·") : " ")
+    )).join(""));
+  },
+};

package/src/games-excitebike.mjs

@@ -0,0 +1,206 @@
+// Excitebike. The throttle is not the interesting part — the temperature gauge
+// is, and so is what your front wheel is doing when you land.
+//
+// Two things make this game rather than a side-scroller with ramps. Turbo is
+// free until it isn't: heat climbs while you hold it and the engine seizes at
+// the top of the gauge, so the fast lap is the one that cools off in the right
+// places. And a jump is only as good as its landing: you pitch the bike in the
+// air, and coming down nose-first puts you over the handlebars.
+import { acid, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 46;
+export const HEIGHT = 12;
+
+export const GROUND = HEIGHT - 3;
+export const RIDER = 8;          // your column; the track comes to you
+
+const BASE_SPEED = 0.35;
+const MAX_SPEED = 1.5;
+const TURBO = 0.55;              // extra columns per tick while it is held
+const HEAT_UP = 1.6;
+const HEAT_DOWN = 0.8;
+export const SEIZE_TICKS = 70;   // how long a cooked engine costs you
+const PITCH_LIMIT = 2.2;
+// The nose drops on its own all the way down. Without this the pitch you leave
+// the ramp with is the pitch you land on, and the landing — the whole second
+// half of this game — is something you can simply ignore.
+const PITCH_DROP = 0.075;
+export const LAND_OK = 1.1;      // how far from level you may land
+const CRASH_TICKS = 45;
+export const FINISH = 900;       // columns of track in a race
+const TIME = 2600;
+
+const dirt = rgb(170, 130, 90);
+
+/** A ramp is three columns of take-off; hit one moving and you are airborne. */
+export const RAMP_W = 3;
+
+export function spawn(state) {
+  const { rng } = state;
+  state.things.push({ kind: "ramp", x: WIDTH + 2 });
+  state.next = 18 + rng() * 22;
+  return state;
+}
+
+export const rampSpan = (thing) => {
+  const x = Math.round(thing.x);
+  return [x, x + RAMP_W - 1];
+};
+
+/** Speed right now, with everything that is holding it back applied. */
+export function speedOf(state) {
+  if (state.crash > 0) return 0;
+  if (state.seized > 0) return BASE_SPEED * 0.4;
+  return Math.min(MAX_SPEED, state.throttle + (state.turbo ? TURBO : 0));
+}
+
+function crash(state, why) {
+  state.crash = CRASH_TICKS;
+  state.air = 0;
+  state.pitch = 0;
+  state.throttle = BASE_SPEED;
+  state.spills++;
+  state.last = why;
+  return state;
+}
+
+/** One tick of track. Exported so a test can ride a whole race with no clock. */
+export function step(state) {
+  state.clock++;
+  if (state.clock >= TIME) {
+    state.over = `out of time · ${Math.round(state.dist)} of ${FINISH}`;
+    return state;
+  }
+  if (state.crash > 0) { state.crash--; return state; }
+
+  // The gauge. Turbo is a loan, and this is where it is called in.
+  if (state.turbo && !state.seized) state.heat = Math.min(100, state.heat + HEAT_UP);
+  else state.heat = Math.max(0, state.heat - HEAT_DOWN);
+  if (state.heat >= 100 && !state.seized) { state.seized = SEIZE_TICKS; state.turbo = false; }
+  if (state.seized > 0) { state.seized--; if (!state.seized) state.heat = 40; }
+
+  const speed = speedOf(state);
+  state.dist += speed;
+  for (const thing of state.things) thing.x -= speed;
+  state.things = state.things.filter((t) => rampSpan(t)[1] > -3);
+  state.next -= speed;
+  if (state.next <= 0) spawn(state);
+
+  if (state.air > 0) {
+    state.air--;
+    state.pitch = Math.min(PITCH_LIMIT, state.pitch + PITCH_DROP);
+    if (!state.air) {
+      // Landing: level enough is a landing, anything else is a tumble.
+      if (Math.abs(state.pitch) > LAND_OK) return crash(state, "over the handlebars");
+      // A flat landing carries the speed; a wobbly one scrubs some off.
+      state.throttle = Math.min(MAX_SPEED, state.throttle + (Math.abs(state.pitch) < 0.4 ? 0.12 : -0.1));
+      state.score += 50;
+      state.pitch = 0;
+    }
+  } else {
+    const ramp = state.things.find((t) => {
+      const [from, to] = rampSpan(t);
+      return RIDER >= from && RIDER <= to;
+    });
+    if (ramp && !ramp.used) {
+      ramp.used = true;
+      // The faster you hit it, the longer you are in the air — and the more time
+      // you have to get the pitch wrong.
+      state.air = Math.round(10 + speed * 14);
+      state.pitch = 0.6;   // it launches you nose-up, and you ride it down
+    }
+  }
+
+  if (state.dist >= FINISH) {
+    state.race++;
+    state.score += Math.max(200, 2000 - state.clock);
+    state.dist = 0;
+    state.clock = 0;
+    state.things = [];
+    state.heat = 0;
+  }
+  return state;
+}
+
+export const EXCITEBIKE = {
+  key: "excitebike",
+  aliases: ["bike", "moto", "excite"],
+  title: "EXCITEBIKE",
+  blurb: "turbo until it cooks, and land the way you took off",
+  keys: "← → throttle · space turbo · ↑ ↓ pitch in the air · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      things: [],
+      next: 16,
+      throttle: BASE_SPEED,
+      turbo: false,
+      heat: 0,
+      seized: 0,
+      air: 0,
+      pitch: 0,
+      crash: 0,
+      spills: 0,
+      dist: 0,
+      race: 1,
+      clock: 0,
+      score: 0,
+      last: null,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    if (state.crash > 0) return state;
+    if (pressed === "right") state.throttle = Math.min(MAX_SPEED, state.throttle + 0.12);
+    else if (pressed === "left") state.throttle = Math.max(BASE_SPEED * 0.5, state.throttle - 0.12);
+    else if (pressed === "space" || pressed === "enter") state.turbo = !state.turbo;
+    else if (pressed === "up" || pressed === "down") {
+      // Pitch only means anything off the ground; on it, this does nothing at
+      // all, which is the honest answer.
+      if (!state.air) return state;
+      state.pitch = Math.max(-PITCH_LIMIT, Math.min(PITCH_LIMIT, state.pitch + (pressed === "up" ? -0.35 : 0.35)));
+    }
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const gauge = Math.round(state.heat / 10);
+    const bar = `${"█".repeat(gauge)}${"░".repeat(10 - gauge)}`;
+    return `race ${state.race} · ${Math.round(state.dist)}/${FINISH} · heat ${bar}${state.seized ? " seized" : ""}`;
+  },
+
+  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 thing of state.things) {
+      const [from] = rampSpan(thing);
+      // A ramp climbs, so it is drawn climbing.
+      [...("▁▄█")].forEach((c, i) => put(from + i, GROUND - (i > 1 ? 1 : 0), dirt(c)));
+    }
+
+    const height = state.air ? Math.min(4, 1 + Math.round(state.air / 6)) : 0;
+    const nose = state.pitch < -LAND_OK ? "◜" : state.pitch > LAND_OK ? "◞" : state.air ? "◠" : "◉";
+    put(RIDER, GROUND - 1 - height, state.crash ? danger("✷") : acid(nose));
+    if (!state.air && !state.crash) put(RIDER + 1, GROUND - 1, ash("·"));
+
+    return grid.map((row, y) => row.map((cell, x) => {
+      if (cell) return cell;
+      if (y === GROUND) return dirt("▀");
+      if (y > GROUND) return dim("░");
+      // The finish, coming up the track.
+      const toGo = FINISH - state.dist;
+      if (toGo < WIDTH - RIDER && x === RIDER + Math.round(toGo)) return bone("┋");
+      return " ";
+    }).join(""));
+  },
+};

package/src/games-frogger.mjs

@@ -0,0 +1,194 @@
+// Frogger. Five lanes of traffic that kill you if they touch you, then five of
+// river that kill you if they don't.
+//
+// That inversion is the whole game and it is worth stating plainly in the code:
+// on the road, being on something is death; on the river, being on nothing is.
+// Everything else here — the lanes, the hops, the homes — is bookkeeping.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 40;
+
+/**
+ * The board, bottom to top. Row 0 is the top (the homes), and the frog starts
+ * on the bank at the bottom.
+ */
+export const HOME_ROW = 0;
+export const RIVER = [1, 2, 3, 4, 5];
+export const MEDIAN = 6;
+export const ROAD = [7, 8, 9, 10, 11];
+export const BANK = 12;
+export const HEIGHT = BANK + 1;
+
+/** Five places to get to, evenly spaced along the top. */
+export const HOMES = [3, 11, 19, 27, 35];
+const HOME_W = 3;
+
+const LIVES = 3;
+const water = rgb(60, 130, 220);
+const log = rgb(150, 100, 60);
+
+/** Each lane: which way it runs, how fast, and how thick the things in it are. */
+export const LANES = {
+  1: { dir: 1, speed: 0.16, len: 4, gap: 11, kind: "log" },
+  2: { dir: -1, speed: 0.22, len: 3, gap: 9, kind: "turtle" },
+  3: { dir: 1, speed: 0.13, len: 6, gap: 14, kind: "log" },
+  4: { dir: -1, speed: 0.28, len: 3, gap: 10, kind: "turtle" },
+  5: { dir: 1, speed: 0.2, len: 5, gap: 13, kind: "log" },
+  7: { dir: -1, speed: 0.26, len: 2, gap: 9, kind: "car" },
+  8: { dir: 1, speed: 0.19, len: 3, gap: 11, kind: "truck" },
+  9: { dir: -1, speed: 0.33, len: 2, gap: 12, kind: "car" },
+  10: { dir: 1, speed: 0.15, len: 4, gap: 13, kind: "truck" },
+  11: { dir: -1, speed: 0.24, len: 2, gap: 10, kind: "car" },
+};
+
+const ART = {
+  car: { paint: danger, art: "▄▄▄▄▄▄" },
+  truck: { paint: amber, art: "██████" },
+  log: { paint: log, art: "▓▓▓▓▓▓" },
+  turtle: { paint: acid, art: "◠◠◠◠◠◠" },
+};
+
+/** Every lane laid out end to end, evenly spaced. */
+export function buildTraffic() {
+  const things = [];
+  for (const [row, lane] of Object.entries(LANES)) {
+    for (let x = 0; x < WIDTH + lane.gap; x += lane.gap) {
+      things.push({ row: Number(row), x, len: lane.len, kind: lane.kind });
+    }
+  }
+  return things;
+}
+
+/** The thing under a cell, if there is one. */
+export const thingAt = (things, row, x) => things.find(
+  (t) => t.row === row && x >= Math.round(t.x) && x < Math.round(t.x) + t.len,
+) ?? null;
+
+/** Which home a frog at `x` has reached, or -1. */
+export const homeAt = (x) => HOMES.findIndex((h) => x >= h && x < h + HOME_W);
+
+const start = () => ({ x: Math.floor(WIDTH / 2), row: BANK });
+
+function drown(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  state.frog = start();
+  return state;
+}
+
+/** One tick. Exported so a test can get a frog home with no clock. */
+export function step(state) {
+  for (const thing of state.traffic) {
+    const lane = LANES[thing.row];
+    thing.x += lane.dir * lane.speed;
+    if (thing.x > WIDTH + 2) thing.x = -thing.len - 2;
+    if (thing.x < -thing.len - 2) thing.x = WIDTH + 2;
+  }
+
+  const frog = state.frog;
+  if (RIVER.includes(frog.row)) {
+    // The river carries you. Riding a log off the edge of the world still
+    // counts as losing the frog, which is the lesson every player learns twice.
+    const ride = thingAt(state.traffic, frog.row, Math.round(frog.drift ?? frog.x));
+    if (!ride) return drown(state, "into the river");
+    frog.drift = (frog.drift ?? frog.x) + LANES[frog.row].dir * LANES[frog.row].speed;
+    frog.x = Math.round(frog.drift);
+    if (frog.x < 0 || frog.x >= WIDTH) return drown(state, "carried off the edge");
+  } else if (ROAD.includes(frog.row)) {
+    if (thingAt(state.traffic, frog.row, frog.x)) return drown(state, "flattened");
+  }
+  return state;
+}
+
+/** Hop, and settle what the frog landed on. */
+export function hop(state, dx, dy) {
+  const frog = state.frog;
+  const row = Math.min(BANK, Math.max(HOME_ROW, frog.row + dy));
+  const x = Math.min(WIDTH - 1, Math.max(0, frog.x + dx));
+  frog.row = row;
+  frog.x = x;
+  frog.drift = RIVER.includes(row) ? x : null;
+
+  if (row === HOME_ROW) {
+    const home = homeAt(x);
+    if (home < 0 || state.homes[home]) {
+      // The bank between the homes is not a home, and neither is one you have
+      // already filled.
+      return drown(state, "nowhere to land");
+    }
+    state.homes[home] = true;
+    state.score += 100;
+    if (state.homes.every(Boolean)) {
+      state.level++;
+      state.homes = HOMES.map(() => false);
+      state.score += 500;
+    }
+    state.frog = start();
+    return state;
+  }
+  if (dy < 0) state.score += 10; // forwards only, so hopping on the spot pays nothing
+  return step(state);
+}
+
+export const FROGGER = {
+  key: "frogger",
+  aliases: ["frog", "hop"],
+  title: "FROGGER",
+  blurb: "the road kills what it touches, the river kills what it doesn't",
+  keys: "← ↑ ↓ → hop · q quit",
+  tickMs: 60,
+
+  create() {
+    return {
+      traffic: buildTraffic(),
+      frog: start(),
+      homes: HOMES.map(() => false),
+      score: 0,
+      lives: LIVES,
+      level: 1,
+      over: null,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    const moves = { left: [-1, 0], right: [1, 0], up: [0, -1], down: [0, 1] };
+    const move = moves[pressed];
+    if (!move) return state;
+    return hop(state, move[0], move[1]);
+  },
+
+  status(state) {
+    return state.over
+      ? state.over
+      : `${state.score} · level ${state.level} · ${state.homes.filter(Boolean).length}/5 home · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, (_, row) => Array.from({ length: WIDTH }, () => (
+      RIVER.includes(row) ? water("░") : ROAD.includes(row) ? dim("·") : null
+    )));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const [i, home] of HOMES.entries()) {
+      for (let j = 0; j < HOME_W; j++) put(home + j, HOME_ROW, state.homes[i] ? acid("▓") : ash("▒"));
+    }
+    for (const thing of state.traffic) {
+      const { paint, art } = ART[thing.kind];
+      for (let i = 0; i < thing.len; i++) put(Math.round(thing.x) + i, thing.row, paint(art[i % art.length]));
+    }
+    put(state.frog.x, state.frog.row, state.over ? danger("✷") : bone("◉"));
+
+    return grid.map((row, y) => row.map((cell) => (
+      cell ?? (y === MEDIAN || y === BANK ? ash("═") : " ")
+    )).join(""));
+  },
+};

package/src/games-hangman.mjs

@@ -54,7 +54,12 @@ export const HANGMAN = {
   aliases: ["hang", "gallows"],
   title: "HANGMAN",
   blurb: "six wrong letters and you are done for",
-  keys: "a–z guess · r new word · q quit",
+  keys: "a–z guess · r new word once it is over · q quit",
+  // Every letter has to reach the game: `h` is a guess, not the vim left it is
+  // in the games that read arrows, and `r` only restarts once the word is done.
+  // Without both, `refactor` was a word you could not spell at it.
+  vim: false,
+  restartable: false,
 
   create({ rng = Math.random } = {}) {
     return {