moshcode 0.40.0 → 0.42.0

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

@@ -0,0 +1,102 @@
+// Hangman. Type a letter; the gallows does the rest.
+import { acid, amber, ash, bone, danger, dim } from "./ui.mjs";
+
+/** Six wrong guesses, and the gallows is finished. */
+export const GALLOWS = [
+  ["  ┌────┐", "  │     ", "  │     ", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │     ", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │    │", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│╲", "  │     ", "  │     ", " ═╧══════"],
+  ["  ┌────┐", "  │    ○", "  │   ╱│╲", "  │    │", "  │   ╱ ", " ═╧══════"],
+  ["  ┌────┐", "  │    ☹", "  │   ╱│╲", "  │    │", "  │   ╱ ╲", " ═╧══════"],
+];
+
+export const MISSES_ALLOWED = GALLOWS.length - 1;
+
+/** Words a moshcoder might actually shout. Nothing needing a hyphen. */
+export const WORDS = [
+  "moshcode", "distortion", "compiler", "kernel", "segfault", "refactor",
+  "closure", "promise", "daemon", "binary", "pointer", "monorepo", "terminal",
+  "runtime", "abstraction", "recursion", "interface", "payload", "protocol",
+  "semaphore", "mutex", "stacktrace", "breakpoint", "heuristic", "idempotent",
+  "bytecode", "checksum", "firewall", "namespace", "regression", "sandbox",
+  "throughput", "waveform", "amplifier", "feedback", "headbang", "overdrive",
+  "fretboard", "downbeat", "crowdsurf", "backline", "encryption", "quantum",
+];
+
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+
+/** The word with everything unguessed still hidden. */
+export function mask(state) {
+  return state.word.split("").map((c) => (state.guessed.has(c) ? c.toUpperCase() : "_"));
+}
+
+/**
+ * Apply one letter. Repeats are free — guessing `e` twice costs nothing but
+ * also tells you nothing, which is the same deal every hangman has ever run.
+ */
+export function guess(state, letter) {
+  const c = String(letter).toLowerCase();
+  if (!LETTERS.includes(c) || state.guessed.has(c) || state.missed.includes(c)) return state;
+  if (state.word.includes(c)) {
+    state.guessed.add(c);
+    if (state.word.split("").every((ch) => state.guessed.has(ch))) state.over = "got it 🤘";
+    return state;
+  }
+  state.missed.push(c);
+  if (state.missed.length >= MISSES_ALLOWED) state.over = `hanged — it was ${state.word.toUpperCase()}`;
+  return state;
+}
+
+export const HANGMAN = {
+  key: "hangman",
+  aliases: ["hang", "gallows"],
+  title: "HANGMAN",
+  blurb: "six wrong letters and you are done for",
+  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 {
+      word: WORDS[Math.floor(rng() * WORDS.length) % WORDS.length],
+      guessed: new Set(),
+      missed: [],
+      over: null,
+    };
+  },
+
+  onKey(state, pressed) {
+    if (pressed.length !== 1) return state;
+    return guess(state, pressed);
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const left = MISSES_ALLOWED - state.missed.length;
+    return `${left} wrong ${left === 1 ? "guess" : "guesses"} left`;
+  },
+
+  render(state) {
+    const art = GALLOWS[Math.min(state.missed.length, MISSES_ALLOWED)];
+    const shown = state.over && state.over.startsWith("hanged")
+      ? state.word.split("").map((c) => c.toUpperCase())
+      : mask(state);
+    const word = shown.map((c) => (c === "_" ? ash("_") : acid(c))).join(" ");
+    const missed = state.missed.length
+      ? `${ash("missed ")}${danger(state.missed.join(" ").toUpperCase())}`
+      : dim("no wrong letters yet");
+    return [
+      ...art.map((line) => bone(line)),
+      "",
+      `  ${word}`,
+      "",
+      `  ${missed}`,
+      `  ${amber("✳".repeat(MISSES_ALLOWED - state.missed.length))}${dim("✳".repeat(state.missed.length))}`,
+    ];
+  },
+};

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(""));
+  },
+};