moshcode 0.41.0 → 0.42.0

package/src/games-stagedive.mjs

@@ -0,0 +1,206 @@
+// Stagedive. You are running the barricade, the stage is coming at you, and it
+// does not stop. Hop the monitor wedges and the amp stacks, duck the
+// crowdsurfers, take the picks. One mistake is the whole run.
+//
+// A side-scroller in a terminal is really a scrolling list: the runner never
+// moves along the x axis at all. Everything else slides left past a fixed
+// column, which is why `speed` is measured in columns per tick and why the gap
+// between hazards is multiplied by it — a jump lasts a fixed number of ticks, so
+// a fair gap has to get longer as the stage gets faster.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 50;
+export const HEIGHT = 9;
+
+/** The row the runner's feet are on, and the stage edge under it. */
+export const GROUND = 7;
+const FLOOR = GROUND + 1;
+
+/** The runner's column. It never changes — the stage moves, not you. */
+export const RUNNER = 8;
+
+const BASE_SPEED = 0.85;
+const MAX_SPEED = 1.75;
+const GRAVITY = 0.15;
+const JUMP = -1.3;    // ~5 rows up and ~17 ticks in the air
+const DUCK_TICKS = 8; // a tap of ↓ stays crouched this long, so a repeat holds it
+const SLAM = 0.7;     // ↓ in mid-air comes down early, which is how you save a bad jump
+
+const crowd = rgb(255, 120, 180);
+
+/**
+ * What is on the stage. `art` is one row's worth of cells and `rows` is which
+ * rows it fills, so its width and its hitbox are the same number by
+ * construction — a hazard that is drawn wider than it hits is the oldest bug in
+ * the genre. `death` is what the status line says when it gets you.
+ */
+export const HAZARDS = {
+  wedge: { art: "██", rows: [GROUND], paint: ash, death: "tripped over a monitor wedge" },
+  stack: { art: "███", rows: [GROUND - 1, GROUND], paint: bone, death: "ran into an amp stack" },
+  // Head height: a standing runner wears it, a crouched one does not.
+  surfer: { art: "╾●╼", rows: [GROUND - 1], paint: crowd, death: "wore a crowdsurfer" },
+};
+
+const PICK = amber("♦");
+
+/** The cells a thing covers, so a hit is decided by what the screen showed. */
+export function cells(thing) {
+  const x = Math.round(thing.x);
+  if (thing.kind === "pick") return { cols: [x, x], rows: [thing.row] };
+  const { art, rows } = HAZARDS[thing.kind];
+  return { cols: [x, x + art.length - 1], rows };
+}
+
+/** The runner: two rows standing, one crouched — which is the whole point of ↓. */
+export function runnerRows(state) {
+  const y = Math.round(state.y);
+  if (state.duck > 0 && !state.airborne) return [GROUND];
+  return [y - 1, y];
+}
+
+const hits = (thing, rows) => {
+  const { cols, rows: theirs } = cells(thing);
+  return RUNNER >= cols[0] && RUNNER <= cols[1] && theirs.some((r) => rows.includes(r));
+};
+
+/**
+ * Put the next thing on the far edge, and decide how far behind it the one
+ * after that will be. The gap scales with speed because a jump is a fixed
+ * number of ticks: without that, the stage eventually outruns the jump and the
+ * game stops being losable-by-mistake and starts being unfair.
+ */
+export function spawn(state) {
+  const { rng } = state;
+  const edge = WIDTH + 2;
+  const roll = rng();
+
+  if (roll < 0.3) {
+    // A line of picks. Low ones are free; a high arc is paid for with a jump.
+    const high = rng() < 0.55;
+    const count = 3 + Math.floor(rng() * 3);
+    for (let i = 0; i < count; i++) {
+      state.things.push({ kind: "pick", x: edge + i * 2, row: high ? (i === 0 || i === count - 1 ? 5 : 4) : GROUND });
+    }
+    state.next = (10 + rng() * 8) * state.speed;
+    return state;
+  }
+
+  const kind = roll < 0.55 ? "wedge" : roll < 0.8 ? "stack" : "surfer";
+  state.things.push({ kind, x: edge });
+  state.next = (16 + rng() * 14) * state.speed;
+  return state;
+}
+
+export const meters = (state) => Math.floor(state.dist / 2);
+
+/** One tick of stage. Exported so a test can run the whole set without a clock. */
+export function step(state) {
+  state.dist += state.speed;
+  state.speed = Math.min(MAX_SPEED, BASE_SPEED + state.dist / 2200);
+
+  if (state.airborne) {
+    state.vy += GRAVITY;
+    state.y += state.vy;
+    if (state.y >= GROUND) { state.y = GROUND; state.vy = 0; state.airborne = false; }
+  }
+  if (state.duck > 0) state.duck--;
+
+  for (const thing of state.things) thing.x -= state.speed;
+  state.things = state.things.filter((t) => !t.taken && t.x > -4);
+
+  state.next -= state.speed;
+  if (state.next <= 0) spawn(state);
+
+  const rows = runnerRows(state);
+  for (const thing of state.things) {
+    if (!hits(thing, rows)) continue;
+    if (thing.kind === "pick") { thing.taken = true; state.picks++; continue; }
+    state.over = `${HAZARDS[thing.kind].death} · ${meters(state)} m`;
+    return state;
+  }
+  return state;
+}
+
+export const STAGEDIVE = {
+  key: "stagedive",
+  aliases: ["dive", "runner", "stage"],
+  title: "STAGEDIVE",
+  blurb: "run the barricade, hop the gear, duck the crowd, take the picks",
+  keys: "↑ jump · ↓ duck (and slam) · space jump · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      y: GROUND,
+      vy: 0,
+      airborne: false,
+      duck: 0,
+      dist: 0,
+      speed: BASE_SPEED,
+      picks: 0,
+      things: [],
+      next: 24, // a moment of clear stage before the first thing arrives
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "up" || key === "space" || key === "enter") {
+      if (state.airborne) return state; // no second jump; the floor is the rule
+      state.vy = JUMP;
+      state.airborne = true;
+      state.duck = 0;
+      return state;
+    }
+    if (key === "down") {
+      // In the air this is a slam, on the ground it is a crouch. Both are the
+      // same key because both are "get low", and one key is easier to mean.
+      if (state.airborne) state.vy = Math.max(state.vy, SLAM);
+      else state.duck = DUCK_TICKS;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? `${state.over} · ${state.picks} picks`
+      : `${meters(state)} m · ${state.picks} picks`;
+  },
+
+  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 { cols, rows } = cells(thing);
+      if (thing.kind === "pick") { put(cols[0], rows[0], PICK); continue; }
+      const { art, paint } = HAZARDS[thing.kind];
+      for (const row of rows) [...art].forEach((c, i) => put(cols[0] + i, row, paint(c)));
+    }
+
+    const y = Math.round(state.y);
+    if (state.over) {
+      put(RUNNER, GROUND, danger("✷"));
+    } else if (state.duck > 0 && !state.airborne) {
+      put(RUNNER, GROUND, acid("▄"));
+    } else {
+      put(RUNNER, y - 1, acid("○"));
+      // The legs alternate with the stage, so standing still looks like running.
+      put(RUNNER, y, acid(state.airborne ? "⋏" : Math.floor(state.dist) % 2 ? "⋀" : "⋏"));
+    }
+
+    return grid.map((row, ry) => row.map((cell, x) => {
+      if (cell) return cell;
+      if (ry !== FLOOR) return " ";
+      // The stage edge, with a mark every few cells so the speed is visible even
+      // when nothing else is on screen.
+      return (x + Math.floor(state.dist)) % 7 === 0 ? dim("╪") : ash("═");
+    }).join(""));
+  },
+};

package/src/games-tank.mjs

@@ -0,0 +1,230 @@
+// Tank. Two of them in a walled yard, one shell each in the air at a time, five
+// hits and it is over.
+//
+// Everything is on the grid and turned in quarter turns, because a tank you
+// cannot line up is a tank you cannot aim, and lining up *is* the shot. Your
+// keys are one action each — a press turns you or moves you one cell — so
+// holding an arrow drives, and tapping it nudges.
+import { acid, ash, bone, danger, dim } from "./ui.mjs";
+
+export const TARGET = 5;
+
+/**
+ * The yard. `#` is wall, and the outer ring is closed — a shell that leaves the
+ * board is a shell nobody saw stop.
+ */
+export const YARD = [
+  "##########################################",
+  "#                                        #",
+  "#    ####        ######        ####      #",
+  "#       #             #           #      #",
+  "#       #    ####     #    ####   #      #",
+  "#            #  #          #  #          #",
+  "#    #####   #  #   ####   #  #   ####   #",
+  "#            #  #          #  #          #",
+  "#       #    ####     #    ####   #      #",
+  "#       #             #           #      #",
+  "#    ####        ######        ####      #",
+  "#                                        #",
+  "##########################################",
+];
+
+export const isWall = (x, y) => (YARD[y]?.[x] ?? "#") === "#";
+
+// Derived from the yard rather than declared beside it, so the two can never
+// disagree about how big the board is.
+export const WIDTH = YARD[0].length;
+export const HEIGHT = YARD.length;
+
+/** Quarter turns, and the glyph a tank wears pointing that way. */
+export const HEADINGS = [
+  { dx: 0, dy: -1, glyph: "▲" },
+  { dx: 1, dy: 0, glyph: "▶" },
+  { dx: 0, dy: 1, glyph: "▼" },
+  { dx: -1, dy: 0, glyph: "◀" },
+];
+
+const SHELL_SPEED = 1;   // cells per tick
+const THEM_EVERY = 4;    // the machine gets a move every this many ticks
+
+const spawnYou = () => ({ x: 2, y: 6, dir: 1, cool: 0 });
+const spawnThem = () => ({ x: WIDTH - 3, y: 6, dir: 3, cool: 0 });
+
+/** Move a tank one cell if there is floor there. Walls simply refuse. */
+export function drive(tank, sign) {
+  const { dx, dy } = HEADINGS[tank.dir];
+  const x = tank.x + dx * sign;
+  const y = tank.y + dy * sign;
+  if (isWall(x, y)) return false;
+  tank.x = x;
+  tank.y = y;
+  return true;
+}
+
+export const fire = (tank, owner) => ({
+  x: tank.x + HEADINGS[tank.dir].dx,
+  y: tank.y + HEADINGS[tank.dir].dy,
+  dir: tank.dir,
+  owner,
+});
+
+/**
+ * Whether a tank can see another down the barrel: same row or column, nothing
+ * but floor in between. This is both how the machine decides to shoot and the
+ * only thing it is good at.
+ */
+export function lineOfSight(from, to) {
+  const { dx, dy } = HEADINGS[from.dir];
+  let x = from.x + dx;
+  let y = from.y + dy;
+  for (let i = 0; i < Math.max(WIDTH, HEIGHT); i++) {
+    if (isWall(x, y)) return false;
+    if (x === to.x && y === to.y) return true;
+    x += dx;
+    y += dy;
+  }
+  return false;
+}
+
+/**
+ * The next cell on the shortest way from one point to another, and the heading
+ * that gets there.
+ *
+ * This is a breadth-first search of the whole yard on every decision, which
+ * sounds extravagant for 546 cells and is not: it is the difference between a
+ * tank that comes around the block after you and one that drives into the same
+ * wall forever, which is what "just turn towards the enemy" does the moment
+ * there is anything between the two of you.
+ */
+export function stepToward(from, to) {
+  if (from.x === to.x && from.y === to.y) return null;
+  const seen = new Set([`${from.x},${from.y}`]);
+  const queue = [{ x: from.x, y: from.y, first: null }];
+  for (let head = 0; head < queue.length; head++) {
+    const cur = queue[head];
+    for (let dir = 0; dir < HEADINGS.length; dir++) {
+      const x = cur.x + HEADINGS[dir].dx;
+      const y = cur.y + HEADINGS[dir].dy;
+      const key = `${x},${y}`;
+      if (isWall(x, y) || seen.has(key)) continue;
+      seen.add(key);
+      const first = cur.first ?? { x, y, dir };
+      if (x === to.x && y === to.y) return first;
+      queue.push({ x, y, first });
+    }
+  }
+  return null;
+}
+
+/** One quarter turn from `dir` towards `want`, the short way round. */
+export const quarterTurn = (dir, want) => (dir + ((want - dir + 4) % 4 === 3 ? 3 : 1)) % 4;
+
+function hit(state, who) {
+  if (who === "you") state.yours++; else state.theirs++;
+  state.shells = [];
+  state.you = spawnYou();
+  state.them = spawnThem();
+  if (state.yours >= TARGET) state.over = `you take it ${state.yours}–${state.theirs} 🤘`;
+  else if (state.theirs >= TARGET) state.over = `the machine takes it ${state.theirs}–${state.yours}`;
+  return state;
+}
+
+/** One tick: shells first, then the machine takes its turn. */
+export function step(state) {
+  for (const shell of [...state.shells]) {
+    for (let i = 0; i < SHELL_SPEED; i++) {
+      const { dx, dy } = HEADINGS[shell.dir];
+      shell.x += dx;
+      shell.y += dy;
+      if (isWall(shell.x, shell.y)) { state.shells = state.shells.filter((s) => s !== shell); break; }
+      const target = shell.owner === "you" ? state.them : state.you;
+      if (shell.x === target.x && shell.y === target.y) {
+        state.shells = state.shells.filter((s) => s !== shell);
+        hit(state, shell.owner);
+        return state;
+      }
+    }
+  }
+  if (state.over) return state;
+
+  if (state.you.cool > 0) state.you.cool--;
+  if (state.them.cool > 0) state.them.cool--;
+
+  state.clock++;
+  if (state.clock % THEM_EVERY) return state;
+
+  // The machine: shoot if it is looking at you, otherwise turn towards you, and
+  // drive when it is already pointed the right way. It is not clever, but it is
+  // relentless, and in a yard this size that is enough.
+  const them = state.them;
+  if (lineOfSight(them, state.you)) {
+    if (!them.cool && !state.shells.some((s) => s.owner === "them")) {
+      state.shells.push(fire(them, "them"));
+      them.cool = 6;
+    }
+    return state;
+  }
+  const next = stepToward(them, state.you);
+  if (!next) return state;
+  if (them.dir !== next.dir) them.dir = quarterTurn(them.dir, next.dir);
+  else drive(them, 1);
+  return state;
+}
+
+export const TANK = {
+  key: "tank",
+  aliases: ["tanks", "combat"],
+  title: "TANK",
+  blurb: "two tanks, one yard, five hits — line it up and let go",
+  keys: "← → turn · ↑ drive · ↓ reverse · space fire · q quit",
+  tickMs: 60,
+
+  create() {
+    return {
+      you: spawnYou(),
+      them: spawnThem(),
+      shells: [],
+      yours: 0,
+      theirs: 0,
+      clock: 0,
+      over: null,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    const you = state.you;
+    if (key === "left") you.dir = (you.dir + 3) % 4;
+    else if (key === "right") you.dir = (you.dir + 1) % 4;
+    else if (key === "up") drive(you, 1);
+    else if (key === "down") drive(you, -1);
+    else if (key === "space" || key === "enter") {
+      // One shell of yours in the air at a time, same as the machine. Two would
+      // turn a duel into a hosepipe.
+      if (you.cool || state.shells.some((s) => s.owner === "you")) return state;
+      const shell = fire(you, "you");
+      if (!isWall(shell.x, shell.y)) state.shells.push(shell);
+      you.cool = 4;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over ? state.over : `you ${state.yours} · machine ${state.theirs}`;
+  },
+
+  render(state) {
+    const grid = YARD.map((row) => [...row].map((c) => (c === "#" ? ash("█") : null)));
+    const put = (x, y, glyph) => {
+      if (!grid[y] || x < 0 || x >= grid[y].length) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const shell of state.shells) put(shell.x, shell.y, (shell.owner === "you" ? bone : danger)("•"));
+    put(state.you.x, state.you.y, acid(HEADINGS[state.you.dir].glyph));
+    put(state.them.x, state.them.y, danger(HEADINGS[state.them.dir].glyph));
+
+    return grid.map((row) => row.map((cell) => cell ?? dim("·")).join(""));
+  },
+};

package/src/games.mjs

@@ -1,8 +1,8 @@
 // The moshcode arcade — `/games` in the pit, `moshcode games` from a shell.
 //
-// Six games, one frame. Every game here is the same shape (see GAME_SHAPE
+// Twenty-two games, one frame. Every game here is the same shape (see GAME_SHAPE
 // below) and is drawn by the same `frame()`, so they look like one arcade
-// rather than six weekend projects: a title, a status line, a boxed board, and
+// rather than twenty-two weekend projects: a title, a status line, a boxed board, and
 // one line of keys along the bottom. There is no menu, no options screen and no
 // difficulty prompt — `/games tetris` is already playing by the time the frame
 // lands, and `q` is always the way out.
@@ -18,6 +18,22 @@ import { PACMAN } from "./games-pacman.mjs";
 import { TICTACTOE } from "./games-tictactoe.mjs";
 import { HANGMAN } from "./games-hangman.mjs";
 import { CHESS } from "./games-chess.mjs";
+import { ASTEROIDS } from "./games-asteroids.mjs";
+import { BLACKJACK } from "./games-blackjack.mjs";
+import { STAGEDIVE } from "./games-stagedive.mjs";
+import { INVADERS } from "./games-invaders.mjs";
+import { BREAKOUT } from "./games-breakout.mjs";
+import { PONG } from "./games-pong.mjs";
+import { TANK } from "./games-tank.mjs";
+import { SPYHUNTER } from "./games-spyhunter.mjs";
+import { CENTIPEDE } from "./games-centipede.mjs";
+import { FROGGER } from "./games-frogger.mjs";
+import { DIGDUG } from "./games-digdug.mjs";
+import { KONG } from "./games-kong.mjs";
+import { PITFALL } from "./games-pitfall.mjs";
+import { CHOPLIFTER } from "./games-choplifter.mjs";
+import { EXCITEBIKE } from "./games-excitebike.mjs";
+import { OUTRUN } from "./games-outrun.mjs";
 
 /**
  * @typedef {object} Game  — the whole contract, so a seventh game is an import.
@@ -27,6 +43,8 @@ import { CHESS } from "./games-chess.mjs";
  * @property {string} blurb      one line, for /games list
  * @property {string} keys       the footer; the only place controls are ever explained
  * @property {number|Function} [tickMs]  real-time games only — a number, or (state) => number
+ * @property {boolean} [vim]     false when a game wants h/j/k/l as letters, not arrows
+ * @property {boolean} [restartable]  false when `r` is only a restart once the game is over
  * @property {Function} create   ({ rng }) => state
  * @property {Function} onKey    (state, key, { rng }) => state
  * @property {Function} [tick]   (state, { rng }) => state
@@ -35,7 +53,11 @@ import { CHESS } from "./games-chess.mjs";
  */
 
 /** The cabinet. Order is the order `/games` lists them. */
-export const GAMES = [TETRIS, SNAKE, PACMAN, TICTACTOE, CHESS, HANGMAN];
+export const GAMES = [
+  TETRIS, SNAKE, PACMAN, INVADERS, CENTIPEDE, ASTEROIDS, BREAKOUT, PONG, TANK, DIGDUG,
+  FROGGER, KONG, PITFALL, CHOPLIFTER, SPYHUNTER, OUTRUN, EXCITEBIKE, STAGEDIVE,
+  TICTACTOE, BLACKJACK, CHESS, HANGMAN,
+];
 
 /** Games by name, following aliases. Case- and slash-insensitive. */
 export function resolveGame(name) {
@@ -98,8 +120,12 @@ export function frame({ title = "", status = "", rows = [], keys = "" } = {}) {
  * Games never see an escape sequence; they see "up", "enter", "a". A chunk can
  * hold several keypresses (hold an arrow key down and they arrive in batches),
  * which is why this returns a list.
+ *
+ * `vim: false` is for the games that read letters — hangman cannot ask for a
+ * word with an `h` in it while `h` means left, and blackjack wants `h` to be
+ * hit. Arrows are unaffected either way; they arrive as escape sequences.
  */
-export function decodeKeys(chunk) {
+export function decodeKeys(chunk, { vim = true } = {}) {
   const input = String(chunk);
   const keys = [];
   for (let i = 0; i < input.length; i++) {
@@ -119,10 +145,10 @@ export function decodeKeys(chunk) {
     if (c === "\x03" || c === "\x04") { keys.push("quit"); continue; }
     if (c === "\x7f" || c === "\b") { keys.push("backspace"); continue; }
     if (c === "\t") { keys.push("tab"); continue; }
-    // vim keys, everywhere, for free — every game reads arrows, so mapping
-    // hjkl here means no game has to know about them.
-    const vim = { h: "left", j: "down", k: "up", l: "right" }[c];
-    if (vim) { keys.push(vim); continue; }
+    // vim keys, everywhere, for free — every game that reads arrows gets them
+    // without knowing about them. A game that reads letters opts out.
+    const vimKey = vim ? { h: "left", j: "down", k: "up", l: "right" }[c] : null;
+    if (vimKey) { keys.push(vimKey); continue; }
     if (c >= " " && c <= "~") keys.push(c.toLowerCase());
   }
   return keys;
@@ -241,7 +267,7 @@ export async function runGame(game, deps = {}) {
   const onSignal = () => { restore(); process.exit(130); };
 
   function onData(chunk) {
-    for (const key of decodeKeys(chunk)) {
+    for (const key of decodeKeys(chunk, { vim: game.vim !== false })) {
       if (key === "quit" || key === "q" || key === "escape") { restore(); resolve(); return; }
       if (key === "r" && (state.over || game.restartable !== false)) {
         state = game.create(ctx);