moshcode 0.41.0 → 0.42.0

package/README.md

@@ -50,7 +50,7 @@ or miss one that does. A test fails the build when it drifts.
 | `moshcode doh` | hosting | run the DNS-over-HTTPS resolver |
 | `moshcode site` <br>`serve` | hosting | install web-server config for a Moshpit name |
 | `moshcode template` <br>`templates` | hosting | scaffold a stack for a Moshpit-hosted service |
-| `moshcode games` <br>`game` `arcade` | arcade | the moshcode arcade — six games, no menus |
+| `moshcode games` <br>`game` `arcade` | arcade | the moshcode arcade — twenty-two games, no menus |
 | `moshcode pwd` <br>`where` | system | show the current directory and git context |
 | `moshcode engines` | engines | list engines and installation status |
 | `moshcode tools` | tools | list workflow tools and installation status |
@@ -584,7 +584,7 @@ the composer URL instead.
 
 ## The arcade (`/games`)
 
-Six games, in the pit or straight from a shell. There are no menus, no options
+Twenty-two games, in the pit or straight from a shell. There are no menus, no options
 screens and no difficulty prompts — `/games tetris` is already playing.
 
 ```sh
@@ -611,7 +611,23 @@ moshcode games --json         # the roster, for a machine
 | `tetris` | stack the bricks, clear the lines, outrun gravity |
 | `snake` | eat, grow, and try not to eat yourself |
 | `pacman` | eat the dots, dodge the ghosts, `✳` makes them edible |
+| `invaders` | forty of them, and the last one moves fastest |
+| `centipede` | shoot it in the middle and now there are two of them |
+| `asteroids` | turn, thrust, shoot — every rock you break becomes two |
+| `breakout` | dig a channel up the side and let the ball do the rest |
+| `pong` | first to seven, and the angle is all in where you hit it |
+| `tank` | two tanks, one yard, five hits — line it up and let go |
+| `digdug` | dig the tunnels, pump the monsters, drop rocks on the rest |
+| `frogger` | the road kills what it touches, the river kills what it doesn't |
+| `kong` | five girders, four ladders, and a barrel with your name on it |
+| `pitfall` | jump the logs, swing the pits, and get the gold before dark |
+| `choplifter` | fly out, land, fill the back, and get them home |
+| `spyhunter` | keep it on the tarmac, shoot the ones shooting back |
+| `outrun` | a road that bends, traffic that doesn't, and a clock that always wins |
+| `excitebike` | turbo until it cooks, and land the way you took off |
+| `stagedive` | run the barricade, hop the gear, duck the crowd, take the picks |
 | `tictactoe` | three in a row against an opponent that cannot be beaten |
+| `blackjack` | hit, stand, double, split — dealer stands on 17, and pays 3:2 |
 | `chess` | full rules — castling, en passant, promotion — and it plays back |
 | `hangman` | six wrong letters and you are done for |
 
@@ -620,6 +636,10 @@ another, and the controls are written along the bottom of the game itself. Each
 draws in place rather than on the alternate screen, so the board you finished on
 stays in your scrollback.
 
+The two games that read letters — `blackjack`, where `h` is hit, and `hangman`,
+where it is a guess — keep their letters: `h j k l` are not arrows there, and `r`
+only starts another once the game is over.
+
 Playing needs a real terminal, because they read single keypresses — `moshcode
 games` on its own lists them anywhere, including a pipe.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/cli-schema.mjs

@@ -396,7 +396,7 @@ export const CORE_CLI_COMMANDS = [
   {
     name: "games",
     group: "arcade",
-    description: "the moshcode arcade — six games, no menus",
+    description: "the moshcode arcade — twenty-two games, no menus",
     synopsis: [
       ["moshcode games", "the cabinet, and what each one is"],
       ["moshcode games <game>", "play it, right here in the terminal"],
@@ -407,6 +407,10 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode games tetris", ""],
       ["moshcode games chess", "real rules, and it plays back"],
       ["moshcode games pacman", "dots, ghosts, three lives"],
+      ["moshcode games asteroids", "turn, thrust, shoot"],
+      ["moshcode games 21", "blackjack, 100 chips, 3:2"],
+      ["moshcode games invaders", "forty of them, coming down"],
+      ["moshcode games stagedive", "jump the gear, take the picks"],
     ],
     seeAlso: ["help"],
     note: "every game works the same way: arrows move, q quits, r starts another. "
@@ -930,7 +934,7 @@ export const PIT_COMMANDS = [
   { name: "plugin", aliases: ["plugins"], args: "<verb> [name]", cli: "plugin",
     description: "install moshcode's slash commands into Claude Code" },
   { name: "games", aliases: ["game", "arcade", "play"], args: "[game]", cli: "games",
-    description: "the arcade — tetris, snake, pac-man, tic-tac-toe, chess, hangman" },
+    description: "the arcade — tetris, invaders, pac-man, frogger, kong, outrun, chess and more" },
   { name: "socials", aliases: ["social"], pitOnly: true,
     description: "list social networks available for posting" },
   { name: "post", args: '<social> "message"', pitOnly: true,

package/src/games-asteroids.mjs

@@ -0,0 +1,265 @@
+// Asteroids. Turn, thrust, shoot, and watch the rocks you shot become two
+// smaller rocks that are somehow worse.
+//
+// The one thing the 1979 cabinet did not have to worry about: a terminal cell is
+// about twice as tall as it is wide. Everything here measures distance in
+// columns, so a row counts double (see `span`) — without that, every rock is an
+// egg and the collisions land in places the screen never showed you.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 44;
+export const HEIGHT = 18;
+
+/** A row is worth this many columns. Half of everything vertical follows. */
+export const ASPECT = 0.5;
+
+const TURN = Math.PI / 8;      // 16 headings, which is as many as 8 glyphs can tell apart
+const THRUST = 0.14;
+const DRAG = 0.97;             // space has none; a 55ms terminal very much needs some
+const MAX_SPEED = 1.15;
+const BULLET_SPEED = 1.6;
+const BULLET_LIFE = 22;
+const BULLETS = 4;             // in flight at once — the arcade limit, and it is the game
+const COOLDOWN = 2;
+const INVULN = 30;             // ticks of blinking after a life is lost
+const LIVES = 3;
+
+/** Radius in columns, and what a hit is worth. Small ones pay most. */
+export const ROCKS = {
+  3: { r: 3.2, glyph: "█", points: 20, speed: 0.16 },
+  2: { r: 2.1, glyph: "▓", points: 50, speed: 0.24 },
+  1: { r: 1.1, glyph: "▒", points: 100, speed: 0.34 },
+};
+
+const HEADINGS = ["→", "↘", "↓", "↙", "←", "↖", "↑", "↗"];
+const FLAME = ["◄", "◤", "▲", "◥", "►", "◢", "▼", "◣"];
+
+export const wrap = (v, max) => ((v % max) + max) % max;
+
+/**
+ * The starfield: fixed, scattered, and free. Hashed from the coordinates rather
+ * than stored or rolled, so the sky is the same on every repaint — and hashed
+ * rather than `(x * 7 + y * 23) % 37`, which is a diagonal line, not a sky.
+ */
+export const star = (x, y) => ((((x * 73856093) ^ (y * 19349663)) >>> 4) % 53) === 0;
+
+/** The shorter way round a wrapping axis — the screen has no edges. */
+const delta = (a, b, max) => {
+  const d = a - b;
+  return d > max / 2 ? d - max : d < -max / 2 ? d + max : d;
+};
+
+/** Distance between two things, in columns, the short way round. */
+export function span(a, b) {
+  const dx = delta(a.x, b.x, WIDTH);
+  const dy = delta(a.y, b.y, HEIGHT) / ASPECT;
+  return Math.hypot(dx, dy);
+}
+
+const drift = (thing) => {
+  thing.x = wrap(thing.x + thing.vx, WIDTH);
+  thing.y = wrap(thing.y + thing.vy, HEIGHT);
+};
+
+/** A rock of `size`, moving somewhere, starting where it is put. */
+export function rock(size, x, y, rng) {
+  const angle = rng() * Math.PI * 2;
+  const speed = ROCKS[size].speed * (0.7 + rng() * 0.6);
+  return {
+    size, x, y,
+    vx: Math.cos(angle) * speed,
+    vy: Math.sin(angle) * speed * ASPECT,
+  };
+}
+
+/**
+ * A wave. Rocks arrive at the edges of the screen and never on top of the ship —
+ * spawning one on the ship is the cheapest way to make a game feel broken.
+ */
+export function spawnWave(wave, ship, rng) {
+  const rocks = [];
+  for (let i = 0; i < 3 + wave; i++) {
+    let x = 0;
+    let y = 0;
+    let tries = 0;
+    do {
+      x = rng() * WIDTH;
+      y = rng() * HEIGHT;
+      tries++;
+    } while (span({ x, y }, ship) < 14 && tries < 60);
+    rocks.push(rock(3, x, y, rng));
+  }
+  return rocks;
+}
+
+const newShip = () => ({ x: WIDTH / 2, y: HEIGHT / 2, vx: 0, vy: 0, angle: -Math.PI / 2 });
+
+/**
+ * One tick: everything moves, then everything that touched something else
+ * finds out. Exported so a test can fly a whole game without a clock.
+ */
+export function step(state) {
+  const { rng } = state;
+  const ship = state.ship;
+
+  ship.vx *= DRAG;
+  ship.vy *= DRAG;
+  const speed = Math.hypot(ship.vx, ship.vy / ASPECT);
+  if (speed > MAX_SPEED) {
+    ship.vx *= MAX_SPEED / speed;
+    ship.vy *= MAX_SPEED / speed;
+  }
+  drift(ship);
+
+  for (const bullet of state.bullets) { drift(bullet); bullet.life--; }
+  state.bullets = state.bullets.filter((b) => b.life > 0);
+  for (const r of state.rocks) drift(r);
+
+  if (state.cooldown > 0) state.cooldown--;
+  if (state.thrusting > 0) state.thrusting--;
+  if (state.invuln > 0) state.invuln--;
+
+  // Bullets first: a rock shot on the same tick it reaches you does not also
+  // get to take a life.
+  for (const bullet of [...state.bullets]) {
+    const hit = state.rocks.find((r) => span(bullet, r) <= ROCKS[r.size].r + 0.4);
+    if (!hit) continue;
+    state.bullets = state.bullets.filter((b) => b !== bullet);
+    state.rocks = state.rocks.filter((r) => r !== hit);
+    state.score += ROCKS[hit.size].points;
+    if (hit.size > 1) {
+      state.rocks.push(rock(hit.size - 1, hit.x, hit.y, rng), rock(hit.size - 1, hit.x, hit.y, rng));
+    }
+  }
+
+  if (!state.invuln) {
+    const struck = state.rocks.find((r) => span(ship, r) <= ROCKS[r.size].r + 0.9);
+    if (struck) {
+      state.lives--;
+      if (state.lives <= 0) {
+        state.lives = 0;
+        state.over = `wrecked on wave ${state.wave}`;
+        return state;
+      }
+      state.ship = newShip();
+      state.bullets = [];
+      state.invuln = INVULN;
+      // The rock that got you is pushed clear rather than deleted, so the
+      // respawn is not immediately fatal a second time.
+      struck.x = wrap(struck.x + WIDTH / 2, WIDTH);
+      struck.y = wrap(struck.y + HEIGHT / 2, HEIGHT);
+    }
+  }
+
+  if (!state.rocks.length) {
+    state.wave++;
+    state.rocks = spawnWave(state.wave, state.ship, rng);
+    state.invuln = Math.max(state.invuln, 12);
+  }
+  return state;
+}
+
+export const ASTEROIDS = {
+  key: "asteroids",
+  aliases: ["rocks", "asteroid"],
+  title: "ASTEROIDS",
+  blurb: "turn, thrust, shoot — every rock you break becomes two",
+  keys: "← → turn · ↑ thrust · ↓ retro · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const ship = newShip();
+    return {
+      ship,
+      bullets: [],
+      rocks: spawnWave(1, ship, rng),
+      score: 0,
+      lives: LIVES,
+      wave: 1,
+      cooldown: 0,
+      thrusting: 0,
+      invuln: INVULN,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    const ship = state.ship;
+    if (key === "left") ship.angle -= TURN;
+    else if (key === "right") ship.angle += TURN;
+    else if (key === "up" || key === "down") {
+      // Retro is half power, because a reverse as strong as the throttle turns
+      // the ship into something that cannot drift, and drifting is the game.
+      const push = key === "up" ? THRUST : -THRUST / 2;
+      ship.vx += Math.cos(ship.angle) * push;
+      ship.vy += Math.sin(ship.angle) * push * ASPECT;
+      if (key === "up") state.thrusting = 3;
+    } else if (key === "space" || key === "enter") {
+      if (state.cooldown > 0 || state.bullets.length >= BULLETS) return state;
+      state.bullets.push({
+        // Out of the nose, not the middle, or the ship shoots itself in the face
+        // at close range and the muzzle flash lands inside the hull.
+        x: wrap(ship.x + Math.cos(ship.angle) * 1.6, WIDTH),
+        y: wrap(ship.y + Math.sin(ship.angle) * 1.6 * ASPECT, HEIGHT),
+        vx: ship.vx + Math.cos(ship.angle) * BULLET_SPEED,
+        vy: ship.vy + Math.sin(ship.angle) * BULLET_SPEED * ASPECT,
+        life: BULLET_LIFE,
+      });
+      state.cooldown = COOLDOWN;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? `${state.over} · ${state.score} points`
+      : `score ${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) => {
+      const col = wrap(Math.round(x), WIDTH);
+      const row = wrap(Math.round(y), HEIGHT);
+      grid[row][col] = glyph;
+    };
+
+    for (const r of state.rocks) {
+      const { r: radius, glyph } = ROCKS[r.size];
+      const paint = r.size === 3 ? ash : r.size === 2 ? rgb(150, 158, 150) : rgb(190, 196, 188);
+      // A disc, measured in columns — hence the row doubling, which is the only
+      // reason these come out round instead of squashed.
+      for (let dy = -Math.ceil(radius * ASPECT); dy <= Math.ceil(radius * ASPECT); dy++) {
+        for (let dx = -Math.ceil(radius); dx <= Math.ceil(radius); dx++) {
+          if (Math.hypot(dx, dy / ASPECT) > radius) continue;
+          put(r.x + dx, r.y + dy, paint(glyph));
+        }
+      }
+    }
+
+    for (const bullet of state.bullets) put(bullet.x, bullet.y, amber("•"));
+
+    const heading = ((Math.round(state.ship.angle / (Math.PI / 4)) % 8) + 8) % 8;
+    if (state.thrusting) {
+      put(
+        state.ship.x - Math.cos(state.ship.angle) * 1.4,
+        state.ship.y - Math.sin(state.ship.angle) * 1.4 * ASPECT,
+        danger(FLAME[heading]),
+      );
+    }
+    if (!state.over) {
+      // Blinking is the only tell that the ship cannot be hit yet.
+      const shield = state.invuln && state.invuln % 6 < 3;
+      put(state.ship.x, state.ship.y, (shield ? bone : acid)(HEADINGS[heading]));
+    } else {
+      put(state.ship.x, state.ship.y, danger("✷"));
+    }
+
+    return grid.map((row, y) => row.map((cell, x) => (
+      cell ?? (star(x, y) ? dim("·") : " ")
+    )).join(""));
+  },
+};

package/src/games-blackjack.mjs

@@ -0,0 +1,284 @@
+// Blackjack. One hand at a time against a dealer with no choices to make.
+//
+// House rules, printed here rather than in an options screen nobody reads:
+// dealer stands on all 17s, blackjack pays 3:2, double on any first two cards,
+// split a pair once, split aces get one card each. The stack is 100 chips and
+// the game is over when it is gone.
+import { acid, amber, ash, bone, danger, dim } from "./ui.mjs";
+
+export const SUITS = ["♠", "♥", "♦", "♣"];
+export const RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
+
+export const START_CHIPS = 100;
+export const MIN_BET = 5;
+export const BET_STEP = 5;
+const RESHUFFLE_AT = 15;
+
+/** A shuffled deck. Fisher–Yates, so the seeded rng in a test gives one deal. */
+export function freshDeck(rng = Math.random) {
+  const deck = [];
+  for (const suit of SUITS) for (const rank of RANKS) deck.push({ rank, suit });
+  for (let i = deck.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1)) % (i + 1);
+    [deck[i], deck[j]] = [deck[j], deck[i]];
+  }
+  return deck;
+}
+
+/** Face value; an ace counts eleven here and is talked down by `handValue`. */
+export const cardValue = (card) => (card.rank === "A" ? 11 : ["J", "Q", "K"].includes(card.rank) ? 10 : Number(card.rank));
+
+/**
+ * The total, and whether an ace is still counting as eleven — which is the only
+ * thing that makes a 17 worth hitting.
+ */
+export function handValue(cards) {
+  let total = cards.reduce((sum, c) => sum + cardValue(c), 0);
+  let aces = cards.filter((c) => c.rank === "A").length;
+  while (total > 21 && aces > 0) { total -= 10; aces--; }
+  return { total, soft: aces > 0 };
+}
+
+/** Twenty-one on the first two cards, and nothing else. */
+export const isBlackjack = (cards) => cards.length === 2 && handValue(cards).total === 21;
+
+const clampBet = (bet, chips) => Math.max(Math.min(MIN_BET, chips), Math.min(bet, chips));
+
+function draw(state) {
+  if (!state.deck.length) state.deck = freshDeck(state.rng);
+  return state.deck.pop();
+}
+
+const newHand = (cards, bet) => ({ cards, bet, done: false, doubled: false, result: null, payout: 0 });
+
+/** Chips won or lost, the way a table would say it. */
+const signed = (n) => (n > 0 ? acid(`+${n}`) : n < 0 ? danger(`−${Math.abs(n)}`) : ash("even"));
+
+/**
+ * Start a hand. The wager leaves the stack now and comes back on settlement,
+ * so the chip count on screen is always what you could still walk away with.
+ */
+export function deal(state) {
+  if (state.chips <= 0) { state.over = `broke after ${state.played} hands`; return state; }
+  if (state.deck.length < RESHUFFLE_AT) state.deck = freshDeck(state.rng);
+
+  state.bet = clampBet(state.bet, state.chips);
+  state.chips -= state.bet;
+  state.hands = [newHand([draw(state), draw(state)], state.bet)];
+  state.dealer = [draw(state), draw(state)];
+  state.hole = true;
+  state.active = 0;
+  state.phase = "player";
+  state.message = "";
+
+  // A natural on either side ends it before anybody gets a decision.
+  if (isBlackjack(state.hands[0].cards) || isBlackjack(state.dealer)) settle(state);
+  return state;
+}
+
+/** The dealer's whole turn: show the hole card, then hit until 17. */
+function dealerPlays(state) {
+  state.hole = false;
+  // With every player hand busted there is nothing to beat, and the dealer does
+  // not draw for an audience.
+  if (!state.hands.some((h) => handValue(h.cards).total <= 21)) return;
+  // A natural is already paid; the dealer does not draw for it. Split hands are
+  // not naturals, so two 21s off a pair of aces still get a dealer's turn.
+  if (state.hands.length === 1 && isBlackjack(state.hands[0].cards)) return;
+  while (handValue(state.dealer).total < 17) state.dealer.push(draw(state));
+}
+
+/** Pay the hands out, and notice when the stack is gone. */
+export function settle(state) {
+  dealerPlays(state);
+  const dealer = handValue(state.dealer).total;
+  const dealerBJ = isBlackjack(state.dealer);
+  let net = 0;
+
+  for (const hand of state.hands) {
+    const total = handValue(hand.cards).total;
+    // A split hand that reaches 21 is twenty-one, not blackjack — it does not
+    // pay 3:2, which is the rule everybody's home version gets wrong.
+    const natural = isBlackjack(hand.cards) && state.hands.length === 1;
+    if (total > 21) { hand.result = "bust"; hand.payout = 0; }
+    else if (natural && !dealerBJ) { hand.result = "blackjack 🤘"; hand.payout = hand.bet + Math.floor(hand.bet * 1.5); }
+    else if (dealerBJ && !natural) { hand.result = "dealer blackjack"; hand.payout = 0; }
+    else if (dealer > 21) { hand.result = "dealer busts"; hand.payout = hand.bet * 2; }
+    else if (total > dealer) { hand.result = "you win"; hand.payout = hand.bet * 2; }
+    else if (total < dealer) { hand.result = "dealer wins"; hand.payout = 0; }
+    else { hand.result = "push"; hand.payout = hand.bet; }
+    state.chips += hand.payout;
+    net += hand.payout - hand.bet;
+  }
+
+  state.phase = "settled";
+  state.played++;
+  state.message = `${state.hands.map((h) => h.result).join(" · ")}  ${signed(net)}`;
+  if (state.chips <= 0) state.over = `broke after ${state.played} hands`;
+  return state;
+}
+
+/** Move to the next hand with a decision left, or let the dealer answer. */
+function advance(state) {
+  const next = state.hands.findIndex((h, i) => i > state.active && !h.done);
+  if (next >= 0) { state.active = next; return state; }
+  if (state.hands.every((h) => h.done)) return settle(state);
+  return state;
+}
+
+const current = (state) => state.hands[state.active];
+
+export function hit(state) {
+  const hand = current(state);
+  hand.cards.push(draw(state));
+  // Twenty-one stands itself — there is no card that improves it, and asking is
+  // just a way to let someone bust a made hand by reflex.
+  if (handValue(hand.cards).total >= 21) hand.done = true;
+  return hand.done ? advance(state) : state;
+}
+
+export function double(state) {
+  const hand = current(state);
+  if (hand.cards.length !== 2 || state.chips < hand.bet) return state;
+  state.chips -= hand.bet;
+  hand.bet *= 2;
+  hand.doubled = true;
+  hand.cards.push(draw(state));
+  hand.done = true;
+  return advance(state);
+}
+
+export const canSplit = (state) => state.hands.length === 1
+  && current(state).cards.length === 2
+  && cardValue(current(state).cards[0]) === cardValue(current(state).cards[1])
+  && state.chips >= current(state).bet;
+
+export function split(state) {
+  if (!canSplit(state)) return state;
+  const [a, b] = current(state).cards;
+  const bet = current(state).bet;
+  state.chips -= bet;
+  state.hands = [newHand([a, draw(state)], bet), newHand([b, draw(state)], bet)];
+  state.active = 0;
+  // Split aces get one card each and that is the hand — the same deal every
+  // casino offers, and the reason splitting them is still worth it.
+  if (a.rank === "A") {
+    for (const hand of state.hands) hand.done = true;
+    return settle(state);
+  }
+  return state;
+}
+
+/* ------------------------------------------------------------------ render */
+
+const RED = ["♥", "♦"];
+const face = (card) => {
+  const label = `${card.rank}${card.suit}`.padStart(3);
+  return (RED.includes(card.suit) ? danger : bone)(label);
+};
+const BACK = dim("▚▚▚");
+
+/** Three rows of little cards, side by side. */
+export function cardRows(cards, { hole = false } = {}) {
+  const faces = cards.map((c, i) => (hole && i === 1 ? BACK : face(c)));
+  return [
+    faces.map(() => ash("┌───┐")).join(" "),
+    faces.map((f) => `${ash("│")}${f}${ash("│")}`).join(" "),
+    faces.map(() => ash("└───┘")).join(" "),
+  ];
+}
+
+const beside = (blocks, gap = "   ") => blocks[0].map((_, i) => blocks.map((b) => b[i]).join(gap));
+
+/**
+ * The table is this wide, always. The footer is padded to it so the box does
+ * not breathe in and out between hands as the hint under it changes length —
+ * every other game in the arcade has a board of a fixed size, and this is how
+ * one made of cards gets one.
+ */
+const TABLE = 52;
+
+export const BLACKJACK = {
+  key: "blackjack",
+  aliases: ["21", "bj", "twentyone"],
+  title: "BLACKJACK",
+  blurb: "hit, stand, double, split — dealer stands on 17",
+  keys: "h hit · s stand · d double · p split · enter next hand · ← → bet · q quit",
+  // Letters mean letters here: `h` is hit, not the vim left it is everywhere
+  // else in the arcade. Arrows still work, and this game only needs two.
+  vim: false,
+  // `r` is not a control in blackjack, so it only starts a new stack once this
+  // one is gone.
+  restartable: false,
+
+  create({ rng = Math.random } = {}) {
+    const state = {
+      deck: freshDeck(rng),
+      chips: START_CHIPS,
+      bet: 10,
+      hands: [],
+      dealer: [],
+      hole: true,
+      active: 0,
+      phase: "player",
+      message: "",
+      played: 0,
+      over: null,
+      rng,
+    };
+    return deal(state); // dealt and waiting on you before the frame lands
+  },
+
+  onKey(state, key) {
+    if (state.phase === "settled") {
+      if (key === "enter" || key === "space") return deal(state);
+      // Between hands the arrows are the chips: the only setting in the arcade,
+      // and it lives on the table rather than in a menu.
+      if (key === "left") state.bet = clampBet(Math.max(MIN_BET, state.bet - BET_STEP), state.chips);
+      if (key === "right") state.bet = clampBet(state.bet + BET_STEP, state.chips);
+      return state;
+    }
+    if (key === "h") return hit(state);
+    if (key === "s") { current(state).done = true; return advance(state); }
+    if (key === "d") return double(state);
+    if (key === "p") return split(state);
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return `${state.over} · ${state.played} hands played`;
+    const staked = state.hands.reduce((sum, h) => sum + h.bet, 0);
+    return `chips ${state.chips} · ${state.phase === "settled" ? `next bet ${state.bet}` : `bet ${staked}`}`;
+  },
+
+  render(state) {
+    const shown = state.hole ? handValue(state.dealer.slice(0, 1)).total : handValue(state.dealer).total;
+    const dealerLabel = state.hole
+      ? `${ash("dealer")} ${dim(`shows ${shown}`)}`
+      : `${ash("dealer")} ${bone(String(shown))}${shown > 21 ? danger(" bust") : ""}`;
+
+    const split = state.hands.length > 1;
+    const label = (hand, i) => {
+      const { total, soft } = handValue(hand.cards);
+      const live = split && state.phase === "player" && i === state.active;
+      const value = total > 21 ? danger(`${total} bust`) : acid(`${soft ? "soft " : ""}${total}`);
+      const bet = hand.doubled ? amber(` ·2× ${hand.bet}`) : "";
+      // The marker only exists when there is a second hand to point away from.
+      return `${live ? acid("▸") : split ? " " : ""}${ash(split ? `hand ${i + 1}` : "you")} ${value}${bet}`;
+    };
+
+    const footer = state.phase === "settled" && !state.over
+      ? `enter deals the next hand · ← → sets the bet (${state.bet})`
+      : "blackjack pays 3:2 · dealer stands on 17";
+    return [
+      `  ${dealerLabel}`,
+      ...cardRows(state.dealer, { hole: state.hole }).map((r) => `  ${r}`),
+      "",
+      `  ${state.hands.map(label).join("      ")}`,
+      ...beside(state.hands.map((h) => cardRows(h.cards))).map((r) => `  ${r}`),
+      "",
+      `  ${state.message || dim(state.phase === "player" ? "h hit · s stand · d double" : "")}`,
+      `  ${dim(footer.padEnd(TABLE))}`,
+    ];
+  },
+};