moshcode 0.41.0 → 0.43.0

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

package/src/games-pitfall.mjs

@@ -0,0 +1,211 @@
+// Pitfall. The jungle goes past whether you are ready or not: pits, logs,
+// scorpions, and a vine over the worst of them.
+//
+// The vine is the reason this is not just another jumping game. A jump is short
+// and you commit to it the moment you press it; a swing is long, and you can
+// only start one where a vine is hanging — so the hazards that are too wide to
+// jump are the ones that have a vine over them, and reading which is which as
+// it comes at you is the game.
+import { acid, ash, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 46;
+export const HEIGHT = 13;
+
+export const GROUND = 9;      // the row you run along
+const CANOPY = 2;             // where the vines hang from
+export const RUNNER = 9;      // your column; the jungle moves, you do not
+
+const JUMP = 10;              // ticks in the air — about five columns of jungle
+const SWING = 21;             // ticks on a vine — a five-wide pit takes about sixteen
+const REACH = 1;              // how close to a vine you must be to catch it
+const LIVES = 3;
+const SPEED = 0.55;           // columns of jungle per tick
+const TIME = 2400;            // ticks on the clock
+
+const jungle = rgb(60, 140, 70);
+const gold = rgb(255, 200, 60);
+
+/** What the jungle throws at you, and what gets you past it. */
+export const HAZARDS = {
+  pit: { w: 5, art: "     ", paint: ash, cleared: "swing", death: "down a pit" },
+  log: { w: 2, art: "◙◙", paint: rgb(150, 100, 60), cleared: "jump", death: "rolled over by a log" },
+  scorpion: { w: 1, art: "%", paint: danger, cleared: "jump", death: "stung" },
+};
+
+/** The columns a thing covers. A vine and a bar of gold are one cell each. */
+export const span = (thing) => {
+  const x = Math.round(thing.x);
+  return [x, x + (HAZARDS[thing.kind]?.w ?? 1) - 1];
+};
+
+const touching = (thing) => {
+  const [from, to] = span(thing);
+  return RUNNER >= from && RUNNER <= to;
+};
+
+/**
+ * The next thing down the trail, and how far behind it the one after that will
+ * be. A pit always comes with a vine over it: it is five columns wide and a
+ * jump covers three, so a pit with no vine is a pit nobody gets past.
+ */
+export function spawn(state) {
+  const { rng } = state;
+  const edge = WIDTH + 2;
+  const roll = rng();
+  if (roll < 0.22) {
+    state.things.push({ kind: "treasure", x: edge });
+    state.next = 8 + rng() * 8;
+  } else if (roll < 0.5) {
+    state.things.push({ kind: "pit", x: edge });
+    state.things.push({ kind: "vine", x: edge - 3 });
+    state.next = 22 + rng() * 10;
+  } else if (roll < 0.78) {
+    state.things.push({ kind: "log", x: edge });
+    state.next = 16 + rng() * 10;
+  } else {
+    state.things.push({ kind: "scorpion", x: edge });
+    state.next = 16 + rng() * 10;
+  }
+  return state;
+}
+
+function lose(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.treasure} treasure`;
+    return state;
+  }
+  state.things = state.things.filter((t) => span(t)[1] < RUNNER - 2 || span(t)[0] > RUNNER + 12);
+  state.air = 0;
+  state.swinging = false;
+  state.clock = Math.max(0, state.clock - 120); // a fall costs you time as well
+  return state;
+}
+
+/** One tick of jungle. Exported so a test can run the trail with no clock. */
+export function step(state) {
+  state.clock++;
+  state.dist += SPEED;
+  if (state.clock >= TIME) {
+    state.over = `out of daylight · ${state.treasure} treasure`;
+    return state;
+  }
+
+  if (state.air > 0) {
+    state.air--;
+    if (!state.air) state.swinging = false;
+  }
+
+  for (const thing of state.things) thing.x -= SPEED;
+  state.things = state.things.filter((t) => !t.taken && span(t)[1] > -3);
+
+  state.next -= SPEED;
+  if (state.next <= 0) spawn(state);
+
+  for (const thing of state.things) {
+    if (!touching(thing)) continue;
+    if (thing.kind === "vine") continue;             // a vine is scenery until you grab it
+    if (thing.kind === "treasure") {
+      if (state.air) continue;                       // you cannot scoop it up mid-swing
+      thing.taken = true;
+      state.treasure++;
+      state.score += 500;
+      continue;
+    }
+    // In the air is past it, whichever way you got there.
+    if (state.air > 0) continue;
+    return lose(state, HAZARDS[thing.kind].death);
+  }
+  return state;
+}
+
+/** Grab the vine you are under, if there is one. */
+export function grab(state) {
+  if (state.air) return state;
+  const vine = state.things.find((t) => t.kind === "vine" && Math.abs(Math.round(t.x) - RUNNER) <= REACH);
+  if (!vine) return state;
+  state.air = SWING;
+  state.swinging = true;
+  return state;
+}
+
+export const PITFALL = {
+  key: "pitfall",
+  aliases: ["jungle", "vine"],
+  title: "PITFALL",
+  blurb: "jump the logs, swing the pits, and get the gold before dark",
+  keys: "space jump · ↑ grab a vine · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      things: [],
+      air: 0,
+      swinging: false,
+      next: 20,
+      dist: 0,
+      clock: 0,
+      treasure: 0,
+      score: 0,
+      lives: LIVES,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    if (pressed === "up") return grab(state);
+    if (pressed === "space" || pressed === "enter") {
+      if (!state.air) state.air = JUMP;
+    }
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const left = Math.max(0, Math.round((TIME - state.clock) / 20));
+    return `${state.score} · ${state.treasure} gold · ${left}s · ${"▲".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 thing of state.things) {
+      const [from] = span(thing);
+      if (thing.kind === "vine") {
+        for (let y = CANOPY; y < GROUND - 2; y++) put(from, y, jungle("│"));
+        continue;
+      }
+      if (thing.kind === "treasure") { put(from, GROUND - 1, gold("▮")); continue; }
+      const { art, paint, w } = HAZARDS[thing.kind];
+      for (let i = 0; i < w; i++) {
+        // A pit is a hole in the floor rather than something drawn on it.
+        if (thing.kind === "pit") put(from + i, GROUND, dim(" "));
+        else put(from + i, GROUND - 1, paint(art[i]));
+      }
+    }
+
+    const y = state.swinging ? GROUND - 4 : state.air ? GROUND - 3 : GROUND - 1;
+    put(RUNNER, y, state.over ? danger("✷") : acid(state.swinging ? "⌾" : "◉"));
+    if (state.swinging) for (let v = CANOPY; v < y; v++) put(RUNNER, v, jungle("│"));
+
+    return grid.map((row, ry) => row.map((cell, x) => {
+      if (cell) return cell;
+      if (ry === GROUND) {
+        // The floor, with the pits left out of it.
+        const overPit = state.things.some((t) => t.kind === "pit" && x >= span(t)[0] && x <= span(t)[1]);
+        return overPit ? " " : jungle("▀");
+      }
+      if (ry === CANOPY - 1) return dim("╌");
+      if (ry > GROUND) return ash("░");
+      return " ";
+    }).join(""));
+  },
+};