moshcode 0.41.0 → 0.42.0

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

package/src/games-pong.mjs

@@ -0,0 +1,147 @@
+// Pong. The oldest one in the cabinet, and still the one that explains itself
+// fastest: you are the left paddle, the ball is going that way, do something.
+//
+// The machine on the right is deliberately not perfect. It waits until the ball
+// crosses the halfway line before it starts tracking, and then it moves slowly
+// enough that it cannot reach a corner from the middle in the time it has left.
+// A flat return it will always get; one taken off the end of your paddle it will
+// not. That is the whole game, and it is why the angle off the paddle depends on
+// where the ball hit it.
+import { acid, bone, danger, dim } from "./ui.mjs";
+
+export const WIDTH = 44;
+export const HEIGHT = 16;
+
+/** A row is worth two columns, so the ball travels at the angle it looks like. */
+const ASPECT = 0.5;
+
+export const PADDLE = 4;          // rows tall
+export const YOU_COL = 2;
+export const THEM_COL = WIDTH - 3;
+export const TARGET = 7;          // first to this many
+
+const SERVE_SPEED = 0.85;
+const MAX_SPEED = 1.7;
+const SPIN = 0.55;                // how much the edge of the paddle bends the ball
+const THEM_SPEED = 0.3;           // slow enough that a ball into the corner beats it
+const YOU_STEP = 1;
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/** A ball in the middle, heading at whoever just lost the point. */
+export function serve(state, toward) {
+  state.ball = {
+    x: WIDTH / 2,
+    y: HEIGHT / 2,
+    vx: toward * SERVE_SPEED,
+    // Never dead flat: a ball with no angle is a rally nobody can lose.
+    vy: (state.rng() < 0.5 ? -1 : 1) * (0.15 + state.rng() * 0.2),
+  };
+  return state;
+}
+
+/** Where a paddle's rows are, given its top row. */
+export const paddleRows = (top) => Array.from({ length: PADDLE }, (_, i) => Math.round(top) + i);
+
+const catches = (top, y) => y >= top - 0.5 && y <= top + PADDLE - 0.5;
+
+/**
+ * Bounce off a paddle, steeper the further from its middle you take it. This is
+ * the only way a player gets to aim, so it does more work than the physics.
+ */
+function returned(ball, top, dir) {
+  const offset = (ball.y - (top + (PADDLE - 1) / 2)) / (PADDLE / 2);
+  ball.vx = dir * Math.min(MAX_SPEED, Math.abs(ball.vx) * 1.06);
+  ball.vy = clamp(offset * SPIN * ASPECT + ball.vy * 0.3, -0.5, 0.5);
+  // Never let a rally go flat. A ball with no angle is one the machine can park
+  // in front of forever, and a rally that cannot end is not a game.
+  if (Math.abs(ball.vy) < 0.08) ball.vy = (ball.vy < 0 ? -1 : 1) * 0.12;
+  return ball;
+}
+
+/** One tick of rally. Exported so a test can play a whole match with no clock. */
+export function step(state) {
+  const ball = state.ball;
+  ball.x += ball.vx;
+  ball.y += ball.vy;
+
+  // The top and bottom are walls, and the ball is put back inside rather than
+  // just reflected — at speed, a reflection alone can leave it outside.
+  if (ball.y < 0) { ball.y = -ball.y; ball.vy = Math.abs(ball.vy); }
+  if (ball.y > HEIGHT - 1) { ball.y = 2 * (HEIGHT - 1) - ball.y; ball.vy = -Math.abs(ball.vy); }
+
+  if (ball.vx < 0 && ball.x <= YOU_COL) {
+    if (catches(state.you, ball.y)) { ball.x = YOU_COL; returned(ball, state.you, 1); }
+  } else if (ball.vx > 0 && ball.x >= THEM_COL) {
+    if (catches(state.them, ball.y)) { ball.x = THEM_COL; returned(ball, state.them, -1); }
+  }
+
+  if (ball.x < 0) { state.theirs++; point(state, 1); }
+  else if (ball.x > WIDTH - 1) { state.yours++; point(state, -1); }
+
+  // The machine: idle in the middle until the ball is on its half, then chase
+  // the ball's row. Perfect tracking here would make the game unloseable for it,
+  // which is the same thing as unplayable.
+  const chasing = state.ball.vx > 0 && state.ball.x > WIDTH * 0.4;
+  const want = chasing ? state.ball.y - (PADDLE - 1) / 2 : (HEIGHT - PADDLE) / 2;
+  const move = clamp(want - state.them, -THEM_SPEED, chasing ? THEM_SPEED : THEM_SPEED / 2);
+  state.them = clamp(state.them + move, 0, HEIGHT - PADDLE);
+
+  return state;
+}
+
+function point(state, toward) {
+  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}`;
+  else serve(state, toward);
+}
+
+export const PONG = {
+  key: "pong",
+  aliases: ["tennis", "paddle"],
+  title: "PONG",
+  blurb: "first to seven, and the angle is all in where you hit it",
+  keys: "↑ ↓ move · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const state = {
+      you: (HEIGHT - PADDLE) / 2,
+      them: (HEIGHT - PADDLE) / 2,
+      yours: 0,
+      theirs: 0,
+      over: null,
+      rng,
+    };
+    return serve(state, rng() < 0.5 ? -1 : 1);
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "up") state.you = clamp(state.you - YOU_STEP, 0, HEIGHT - PADDLE);
+    if (key === "down") state.you = clamp(state.you + YOU_STEP, 0, HEIGHT - PADDLE);
+    return state;
+  },
+
+  status(state) {
+    return state.over ? state.over : `you ${state.yours} · machine ${state.theirs}`;
+  },
+
+  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 row of paddleRows(state.you)) put(YOU_COL, row, acid("█"));
+    for (const row of paddleRows(state.them)) put(THEM_COL, row, danger("█"));
+    put(Math.round(state.ball.x), Math.round(state.ball.y), bone("●"));
+
+    return grid.map((row, y) => row.map((cell, x) => (
+      // The net, which is only there so the middle of the table has a middle.
+      cell ?? (x === Math.floor(WIDTH / 2) && y % 2 === 0 ? dim("┊") : " ")
+    )).join(""));
+  },
+};

package/src/games-spyhunter.mjs

@@ -0,0 +1,230 @@
+// Spy Hunter. A road that will not hold still, traffic that will not get out of
+// the way, and a gun. Stay on the tarmac, shoot the ones shooting back, and do
+// not shoot the ones just driving home.
+//
+// The road is a list of rows, each one a left and a right edge, scrolled down
+// under a car that only ever moves sideways. Generating the next row from the
+// last one — rather than from a function of distance — is what makes the verge
+// bend instead of zig-zag, and it is the only reason it reads as a road.
+import { acid, amber, ash, bone, danger, dim } from "./ui.mjs";
+
+export const WIDTH = 40;
+export const HEIGHT = 18;
+
+/** The row your car is on. It never changes; the road comes to you. */
+export const CAR_ROW = HEIGHT - 3;
+export const CAR_W = 2;
+
+const MIN_ROAD = 13;
+const MAX_ROAD = 24;
+const BASE_SPEED = 0.34;   // rows of road per tick
+const MAX_SPEED = 0.75;
+const LIVES = 3;
+const GRACE = 25;          // ticks of "the road is clear" after a wreck
+const SHOT_SPEED = 1.6;    // rows per tick, travelled in halves so nothing is skipped
+
+/** The cars that are not you. */
+export const TRAFFIC = {
+  enemy: { art: "▜▛", paint: danger, points: 50, homing: 0.06 },
+  civilian: { art: "▐▌", paint: bone, points: -100, homing: 0 },
+};
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/**
+ * The next row of road, bent a little from the one before it.
+ *
+ * The bend is random but pulled towards the middle of the screen, in proportion
+ * to how far out it already is. A drift with no pull is a random walk, and a
+ * random walk parks the road against one edge and leaves it there — which looks
+ * less like a road than like a bug.
+ */
+export function nextRow(prev, rng) {
+  const width = clamp(prev.right - prev.left + (rng() < 0.3 ? (rng() < 0.5 ? -1 : 1) : 0), MIN_ROAD, MAX_ROAD);
+  const centre = (prev.left + prev.right) / 2;
+  const pull = clamp((WIDTH / 2 - centre) / 8, -0.45, 0.45);
+  const roll = rng() * 2 - 1 + pull;
+  const drift = Math.abs(roll) < 0.55 ? 0 : Math.sign(roll);
+  // One cell of verge on each side always stays on screen, so "the road bends"
+  // never reads as "the road ends".
+  const left = clamp(prev.left + drift, 1, WIDTH - width - 2);
+  return { left, right: left + width };
+}
+
+/** A straight run of road to start on, so the first thing you meet is not a bend. */
+export function openRoad() {
+  const left = Math.floor((WIDTH - 20) / 2);
+  return Array.from({ length: HEIGHT }, () => ({ left, right: left + 20 }));
+}
+
+export const onRoad = (row, x) => row && x >= row.left && x + CAR_W - 1 <= row.right;
+
+/** Whether two cars, each CAR_W wide, are in the same place. */
+export const overlaps = (ax, bx) => Math.abs(Math.round(ax) - Math.round(bx)) < CAR_W;
+
+function wreck(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  // A wreck clears the road ahead, or you respawn straight into the car that
+  // just got you and lose the rest of your lives in three ticks.
+  state.traffic = [];
+  state.grace = GRACE;
+  const row = state.road[CAR_ROW];
+  state.car = Math.round((row.left + row.right) / 2) - 1;
+  return state;
+}
+
+/** One tick of road. Exported so a test can drive a whole run with no clock. */
+export function step(state) {
+  const { rng } = state;
+  state.dist += state.speed;
+  state.speed = Math.min(MAX_SPEED, BASE_SPEED + state.dist / 900);
+  if (state.grace > 0) state.grace--;
+
+  // Scroll: the road only shifts on whole rows, so the verge never shimmers.
+  state.scroll += state.speed;
+  while (state.scroll >= 1) {
+    state.scroll -= 1;
+    state.road.pop();
+    state.road.unshift(nextRow(state.road[0], rng));
+    for (const car of state.traffic) car.y += 1;
+    for (const shot of state.shots) shot.y += 1;
+  }
+
+  // Shots move faster than a car is tall, so they travel in half-steps and are
+  // checked against the traffic after each one. Moving the whole way in one go
+  // lets a shot pass clean through a car that was between the two positions.
+  for (let half = 0; half < 2; half++) {
+    for (const shot of state.shots) shot.y -= SHOT_SPEED / 2;
+    hitTraffic(state);
+  }
+  state.shots = state.shots.filter((shot) => shot.y > -1);
+
+  for (const car of state.traffic) {
+    car.y += state.speed - car.speed;
+    // An enemy leans towards you; traffic just drives.
+    if (TRAFFIC[car.kind].homing) {
+      car.x += Math.sign(state.car - car.x) * TRAFFIC[car.kind].homing;
+    }
+    const row = state.road[Math.round(car.y)];
+    if (row) car.x = clamp(car.x, row.left, row.right - CAR_W + 1);
+  }
+  state.traffic = state.traffic.filter((car) => car.y < HEIGHT + 1 && car.y > -3);
+
+  if (!state.grace) {
+    const row = state.road[CAR_ROW];
+    if (!onRoad(row, state.car)) return wreck(state, "off the road");
+    const rammed = state.traffic.find((car) => Math.round(car.y) === CAR_ROW && overlaps(car.x, state.car));
+    if (rammed) return wreck(state, `rammed ${rammed.kind === "enemy" ? "an enemy" : "a civilian"}`);
+  }
+
+  if (!state.grace && state.traffic.length < 4 && rng() < 0.05) {
+    const row = state.road[0];
+    const kind = rng() < 0.6 ? "enemy" : "civilian";
+    state.traffic.push({
+      kind,
+      x: row.left + Math.floor(rng() * (row.right - row.left - CAR_W + 1)),
+      y: 0,
+      // Slower than you, or the road behind would never catch anybody up.
+      speed: 0.1 + rng() * 0.18,
+    });
+  }
+
+  state.score += Math.floor(state.dist / 10) - state.miles;
+  state.miles = Math.floor(state.dist / 10);
+  return state;
+}
+
+/** Shots meet traffic. A civilian you shoot is a civilian you pay for. */
+function hitTraffic(state) {
+  for (const shot of [...state.shots]) {
+    const hit = state.traffic.find((car) => Math.abs(car.y - shot.y) < 0.9 && overlaps(car.x, shot.x - 0.5));
+    if (!hit) continue;
+    state.shots = state.shots.filter((s) => s !== shot);
+    state.traffic = state.traffic.filter((c) => c !== hit);
+    state.score = Math.max(0, state.score + TRAFFIC[hit.kind].points);
+  }
+  return state;
+}
+
+export const SPYHUNTER = {
+  key: "spyhunter",
+  aliases: ["spy", "chase", "hunter"],
+  title: "SPY HUNTER",
+  blurb: "keep it on the tarmac, shoot the ones shooting back",
+  keys: "← → steer · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const road = openRoad();
+    return {
+      road,
+      traffic: [],
+      shots: [],
+      car: Math.round((road[CAR_ROW].left + road[CAR_ROW].right) / 2) - 1,
+      speed: BASE_SPEED,
+      scroll: 0,
+      dist: 0,
+      miles: 0,
+      score: 0,
+      lives: LIVES,
+      grace: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "left") state.car -= 1;
+    else if (key === "right") state.car += 1;
+    else if (key === "space" || key === "up" || key === "enter") {
+      if (state.shots.length < 3) state.shots.push({ x: state.car + 0.5, y: CAR_ROW - 1 });
+    }
+    // Steering off the edge of the screen is a wreck like any other, so the car
+    // is only kept on the board, not on the road.
+    state.car = clamp(state.car, 0, WIDTH - CAR_W);
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    return `${state.score} · ${state.miles} mi · ${"▲".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 car of state.traffic) {
+      const kind = TRAFFIC[car.kind];
+      [...kind.art].forEach((c, i) => put(Math.round(car.x) + i, Math.round(car.y), kind.paint(c)));
+    }
+    for (const shot of state.shots) put(Math.round(shot.x), Math.round(shot.y), amber("•"));
+    if (state.over) {
+      [...("✷✷")].forEach((c, i) => put(state.car + i, CAR_ROW, danger(c)));
+    } else if (!state.grace || Math.floor(state.grace / 3) % 2) {
+      [...("▟▙")].forEach((c, i) => put(state.car + i, CAR_ROW, acid(c)));
+    }
+
+    return grid.map((row, y) => {
+      const edge = state.road[y];
+      return row.map((cell, x) => {
+        if (cell) return cell;
+        if (x < edge.left || x > edge.right) return ash("▒");
+        // The centre line, dashed, and moving — without it the road is a
+        // stationary corridor and you cannot tell you are going anywhere.
+        const middle = Math.round((edge.left + edge.right) / 2);
+        return x === middle && (y + Math.floor(state.dist)) % 4 < 2 ? dim("┆") : " ";
+      }).join("");
+    });
+  },
+};