moshcode 0.41.0 → 0.42.0

package/src/games-breakout.mjs

@@ -0,0 +1,186 @@
+// Breakout. A wall, a paddle, and one ball that is always your fault.
+//
+// The bounce off the paddle is not a mirror: where the ball lands on the paddle
+// decides the angle it leaves at, so the paddle is a steering wheel rather than
+// a wall. Without that you cannot dig a channel up the side of the wall, and
+// digging a channel is the entire reason anybody still plays this.
+import { acid, amber, bone, danger, rgb } from "./ui.mjs";
+
+export const WIDTH = 40;
+export const HEIGHT = 17;
+
+export const BRICK_W = 4;
+export const BRICK_COLS = WIDTH / BRICK_W;  // 10
+export const BRICK_ROWS = 5;
+export const BRICK_TOP = 1;
+
+export const PADDLE_W = 7;
+export const PADDLE_ROW = HEIGHT - 1;
+const PADDLE_STEP = 2;
+
+const LIVES = 3;
+const BASE_VX = 0.62;
+const BASE_VY = 0.34;   // rows per tick — half of vx, because a row is two columns
+const SPIN = 0.5;
+const LEVEL_UP = 1.12;
+
+/** Top rows are worth more, which is what makes the ball worth risking. */
+export const ROW_POINTS = [50, 40, 30, 20, 10];
+const ROW_COLOR = [danger, amber, acid, rgb(90, 200, 250), rgb(190, 130, 255)];
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+/** A full wall: every brick standing. */
+export const buildWall = () => Array.from({ length: BRICK_ROWS }, () => Array.from({ length: BRICK_COLS }, () => true));
+
+export const bricksLeft = (wall) => wall.reduce((n, row) => n + row.filter(Boolean).length, 0);
+
+/** The brick under a cell, or null. */
+export function brickAt(wall, x, y) {
+  const row = y - BRICK_TOP;
+  if (row < 0 || row >= BRICK_ROWS) return null;
+  const col = Math.floor(x / BRICK_W);
+  if (col < 0 || col >= BRICK_COLS || !wall[row]?.[col]) return null;
+  return { row, col };
+}
+
+/** The ball sitting on the paddle, waiting for space. */
+function rest(state) {
+  state.ball = { x: state.paddle + PADDLE_W / 2, y: PADDLE_ROW - 1, vx: 0, vy: 0 };
+  state.stuck = true;
+  return state;
+}
+
+export function launch(state) {
+  if (!state.stuck) return state;
+  state.stuck = false;
+  state.ball.vx = (state.rng() < 0.5 ? -1 : 1) * BASE_VX * state.pace;
+  state.ball.vy = -BASE_VY * state.pace;
+  return state;
+}
+
+/** One tick. Exported so a test can clear a whole wall with no clock. */
+export function step(state) {
+  if (state.stuck) {
+    // A ball that has not been launched rides the paddle, so moving before you
+    // serve aims the serve.
+    state.ball.x = state.paddle + PADDLE_W / 2;
+    return state;
+  }
+
+  const ball = state.ball;
+  const wasCol = Math.round(ball.x);
+  const wasRow = Math.round(ball.y);
+  ball.x += ball.vx;
+  ball.y += ball.vy;
+
+  if (ball.x < 0) { ball.x = -ball.x; ball.vx = Math.abs(ball.vx); }
+  if (ball.x > WIDTH - 1) { ball.x = 2 * (WIDTH - 1) - ball.x; ball.vx = -Math.abs(ball.vx); }
+  if (ball.y < 0) { ball.y = -ball.y; ball.vy = Math.abs(ball.vy); }
+
+  const col = Math.round(ball.x);
+  const row = Math.round(ball.y);
+  const brick = brickAt(state.wall, col, row);
+  if (brick) {
+    state.wall[brick.row][brick.col] = false;
+    state.score += ROW_POINTS[brick.row];
+    // Which way it bounces depends on which way it came in: through a row means
+    // the ball flips vertically, along a row means it flips sideways.
+    if (row !== wasRow) ball.vy = -ball.vy;
+    else if (col !== wasCol) ball.vx = -ball.vx;
+    else ball.vy = -ball.vy;
+    if (!bricksLeft(state.wall)) return cleared(state);
+  }
+
+  if (ball.vy > 0 && ball.y >= PADDLE_ROW - 1) {
+    const off = ball.x - (state.paddle + (PADDLE_W - 1) / 2);
+    if (Math.abs(off) <= PADDLE_W / 2 + 0.5) {
+      ball.y = PADDLE_ROW - 1;
+      ball.vy = -Math.abs(ball.vy);
+      // The steering wheel: the further out you take it, the flatter it leaves.
+      ball.vx = clamp(ball.vx + (off / (PADDLE_W / 2)) * SPIN * 0.5, -1.4, 1.4);
+      if (Math.abs(ball.vx) < 0.15) ball.vx = ball.vx < 0 ? -0.15 : 0.15;
+    }
+  }
+
+  if (ball.y > PADDLE_ROW) {
+    state.lives--;
+    if (state.lives <= 0) {
+      state.lives = 0;
+      state.over = `out of balls · ${state.score} points`;
+      return state;
+    }
+    rest(state);
+  }
+  return state;
+}
+
+function cleared(state) {
+  state.level++;
+  state.pace *= LEVEL_UP;
+  state.wall = buildWall();
+  state.score += 100;
+  return rest(state);
+}
+
+export const BREAKOUT = {
+  key: "breakout",
+  aliases: ["arkanoid", "wall"],
+  title: "BREAKOUT",
+  blurb: "dig a channel up the side and let the ball do the rest",
+  keys: "← → paddle · space launch · q quit",
+  tickMs: 50,
+
+  create({ rng = Math.random } = {}) {
+    const state = {
+      wall: buildWall(),
+      paddle: Math.floor((WIDTH - PADDLE_W) / 2),
+      score: 0,
+      lives: LIVES,
+      level: 1,
+      pace: 1,
+      over: null,
+      rng,
+    };
+    return rest(state);
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    if (key === "left") state.paddle = clamp(state.paddle - PADDLE_STEP, 0, WIDTH - PADDLE_W);
+    else if (key === "right") state.paddle = clamp(state.paddle + PADDLE_STEP, 0, WIDTH - PADDLE_W);
+    else if (key === "space" || key === "up" || key === "enter") launch(state);
+    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 (let row = 0; row < BRICK_ROWS; row++) {
+      for (let col = 0; col < BRICK_COLS; col++) {
+        if (!state.wall[row][col]) continue;
+        // A brick is drawn exactly as wide as it is hit, with a seam so the wall
+        // reads as bricks rather than as one solid slab.
+        for (let i = 0; i < BRICK_W; i++) {
+          put(col * BRICK_W + i, BRICK_TOP + row, ROW_COLOR[row](i === BRICK_W - 1 ? "▓" : "█"));
+        }
+      }
+    }
+
+    for (let i = 0; i < PADDLE_W; i++) put(state.paddle + i, PADDLE_ROW, bone("▀"));
+    put(Math.round(state.ball.x), Math.round(state.ball.y), state.stuck ? amber("●") : bone("●"));
+
+    return grid.map((row) => row.map((cell) => cell ?? " ").join(""));
+  },
+};

package/src/games-centipede.mjs

@@ -0,0 +1,241 @@
+// Centipede. It comes down through the mushrooms, and every piece you shoot out
+// of the middle leaves you two of them.
+//
+// The trick that makes this cheap: the centipede is not a linked body, it is a
+// list of segments that each obey the same rule — walk sideways, and when
+// something is in the way, drop a row and turn round. Kept that way, a shot to
+// the middle needs no surgery at all. You remove one segment and the ones
+// behind it simply carry on, which is exactly what splitting looks like.
+import { acid, amber, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 38;
+export const HEIGHT = 18;
+
+/** The bottom strip is yours; the centipede comes down into it. */
+export const ZONE_TOP = HEIGHT - 5;
+const MUSHROOM_HP = 4;
+const LIVES = 3;
+const SHOTS = 3;
+const SHOT_SPEED = 2;
+
+const shroom = rgb(120, 190, 40);
+const MUSH_ART = ["▁", "▄", "▆", "█"]; // fuller the healthier
+
+const key = (x, y) => `${x},${y}`;
+
+/** A field of mushrooms, none of them in the row you stand on. */
+export function seedField(rng, count = 34) {
+  const field = new Map();
+  for (let i = 0; i < count; i++) {
+    const x = Math.floor(rng() * WIDTH);
+    const y = 1 + Math.floor(rng() * (HEIGHT - 3));
+    if (y >= HEIGHT - 1) continue;
+    field.set(key(x, y), MUSHROOM_HP);
+  }
+  return field;
+}
+
+/** Chip a mushroom, and say whether one was there. A dead one is worth points. */
+export function bite(field, x, y) {
+  const hp = field.get(key(x, y));
+  if (!hp) return 0;
+  if (hp <= 1) { field.delete(key(x, y)); return 5; }
+  field.set(key(x, y), hp - 1);
+  return 1;
+}
+
+/** A fresh centipede, strung out along the top row. */
+export function newCentipede(length = 10) {
+  return Array.from({ length }, (_, i) => ({ x: length - 1 - i, y: 0, dir: 1, down: 1 }));
+}
+
+const blocked = (state, x, y) => x < 0 || x >= WIDTH || state.field.has(key(x, y));
+
+/** Walk one segment: sideways if it can, otherwise down a row and about turn. */
+export function walk(state, seg) {
+  if (!blocked(state, seg.x + seg.dir, seg.y)) { seg.x += seg.dir; return seg; }
+  seg.dir *= -1;
+  seg.y += seg.down;
+  // It bounces off the floor and climbs back up rather than vanishing, which is
+  // what keeps the bottom of the board dangerous instead of a safe corner.
+  if (seg.y >= HEIGHT - 1) { seg.y = HEIGHT - 1; seg.down = -1; }
+  if (seg.y <= 0) { seg.y = 0; seg.down = 1; }
+  return seg;
+}
+
+/** How many ticks between steps — shorter as the wave goes on. */
+export const cadence = (state) => Math.max(2, 7 - state.wave);
+
+/**
+ * The spider: in from the side, bouncing diagonally through your strip, eating
+ * mushrooms as it goes.
+ *
+ * It is here because without it the bottom of the board is safe. The centipede
+ * only reaches your row on the sweeps it happens to end on, so a player who
+ * simply never moves can survive a long time — which is not a game. The spider
+ * is the reason you cannot stand still.
+ */
+export function spiderStep(state) {
+  const spider = state.spider;
+  if (!spider) return state;
+  spider.x += spider.dx;
+  spider.y += spider.dy;
+  if (spider.y < ZONE_TOP) { spider.y = ZONE_TOP; spider.dy = 1; }
+  if (spider.y > HEIGHT - 1) { spider.y = HEIGHT - 1; spider.dy = -1; }
+  // It leaves the way it came in rather than turning round at the wall, so it
+  // is a visitor and not a permanent resident.
+  if (spider.x < 0 || spider.x >= WIDTH) { state.spider = null; return state; }
+  state.field.delete(key(spider.x, spider.y));
+  return state;
+}
+
+export function spawnSpider(state) {
+  const fromLeft = state.rng() < 0.5;
+  state.spider = {
+    x: fromLeft ? 0 : WIDTH - 1,
+    y: HEIGHT - 1 - Math.floor(state.rng() * 3),
+    dx: fromLeft ? 1 : -1,
+    dy: state.rng() < 0.5 ? -1 : 1,
+  };
+  return state;
+}
+
+function hitPlayer(state) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `eaten · ${state.score} points`;
+    return state;
+  }
+  state.centipede = newCentipede(10);
+  state.shots = [];
+  state.spider = null;
+  state.player = { x: Math.floor(WIDTH / 2), y: HEIGHT - 1 };
+  return state;
+}
+
+/** One tick. Exported so a test can clear a wave with no clock. */
+export function step(state) {
+  for (let i = 0; i < SHOT_SPEED; i++) {
+    for (const shot of [...state.shots]) {
+      shot.y -= 1;
+      if (shot.y < 0) { state.shots = state.shots.filter((s) => s !== shot); continue; }
+      const points = bite(state.field, shot.x, shot.y);
+      if (points) { state.score += points; state.shots = state.shots.filter((s) => s !== shot); continue; }
+      if (state.spider && state.spider.x === shot.x && state.spider.y === shot.y) {
+        state.spider = null;
+        state.shots = state.shots.filter((s) => s !== shot);
+        state.score += 300;
+        continue;
+      }
+      const seg = state.centipede.find((s) => s.x === shot.x && s.y === shot.y);
+      if (!seg) continue;
+      state.shots = state.shots.filter((s) => s !== shot);
+      state.centipede = state.centipede.filter((s) => s !== seg);
+      state.score += 10;
+      // Every piece you take out of it leaves a mushroom where it fell, which
+      // is how the field thickens and the next wave gets harder for free.
+      state.field.set(key(seg.x, seg.y), MUSHROOM_HP);
+    }
+  }
+
+  if (!state.centipede.length) {
+    state.wave++;
+    state.centipede = newCentipede(10);
+    state.score += 100;
+    return state;
+  }
+
+  state.clock++;
+  if (state.clock >= cadence(state)) {
+    state.clock = 0;
+    for (const seg of state.centipede) walk(state, seg);
+    if (state.centipede.some((s) => s.x === state.player.x && s.y === state.player.y)) return hitPlayer(state);
+  }
+
+  state.spiderClock++;
+  if (state.spiderClock % 3 === 0) {
+    spiderStep(state);
+    const spider = state.spider;
+    if (spider && spider.x === state.player.x && spider.y === state.player.y) return hitPlayer(state);
+  }
+  if (!state.spider && state.rng() < 0.02) spawnSpider(state);
+  return state;
+}
+
+export const CENTIPEDE = {
+  key: "centipede",
+  aliases: ["cent", "bug", "millipede"],
+  title: "CENTIPEDE",
+  blurb: "shoot it in the middle and now there are two of them",
+  keys: "← ↑ ↓ → move · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      field: seedField(rng),
+      centipede: newCentipede(10),
+      player: { x: Math.floor(WIDTH / 2), y: HEIGHT - 1 },
+      shots: [],
+      spider: null,
+      spiderClock: 0,
+      score: 0,
+      lives: LIVES,
+      wave: 1,
+      clock: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    const p = state.player;
+    // You are free in the bottom strip and nowhere else — the whole game is
+    // fought in five rows.
+    if (pressed === "left") p.x = Math.max(0, p.x - 1);
+    else if (pressed === "right") p.x = Math.min(WIDTH - 1, p.x + 1);
+    else if (pressed === "up") p.y = Math.max(ZONE_TOP, p.y - 1);
+    else if (pressed === "down") p.y = Math.min(HEIGHT - 1, p.y + 1);
+    else if (pressed === "space" || pressed === "enter") {
+      if (state.shots.length < SHOTS) state.shots.push({ x: p.x, y: p.y - 1 });
+      return state;
+    }
+    // Walking into a mushroom is walking into a wall.
+    if (state.field.has(key(p.x, p.y))) {
+      if (pressed === "left") p.x += 1;
+      else if (pressed === "right") p.x -= 1;
+      else if (pressed === "up") p.y += 1;
+      else if (pressed === "down") p.y -= 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 (const [at, hp] of state.field) {
+      const [x, y] = at.split(",").map(Number);
+      put(x, y, shroom(MUSH_ART[hp - 1] ?? "▁"));
+    }
+    for (const seg of state.centipede) put(seg.x, seg.y, danger("◍"));
+    if (state.spider) put(state.spider.x, state.spider.y, rgb(190, 130, 255)("✻"));
+    for (const shot of state.shots) put(shot.x, shot.y, amber("│"));
+    put(state.player.x, state.player.y, state.over ? danger("✷") : acid("▲"));
+
+    return grid.map((row, y) => row.map((cell) => (
+      cell ?? (y === ZONE_TOP - 1 ? dim("┈") : " ")
+    )).join(""));
+  },
+};

package/src/games-choplifter.mjs

@@ -0,0 +1,179 @@
+// Choplifter. Fly out, land, load them up, fly home. Do it before the tanks
+// work out where you are going.
+//
+// The world is wider than the screen, which is the whole point — the camera
+// follows the chopper and the base sits off the left edge, so "get back" is a
+// real journey rather than a step. Everything is stored in world columns and
+// only turned into screen columns at the very end, in render().
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 46;          // what you can see
+export const HEIGHT = 14;
+export const WORLD = 150;         // how far it actually goes
+
+export const GROUND = HEIGHT - 2;
+export const BASE = 6;            // the pad, at the left-hand end of the world
+const BASE_W = 7;
+export const SEATS = 4;           // how many fit in the back
+const LIVES = 3;
+const SHELL_EVERY = 46;           // ticks between a tank taking a shot
+
+const sand = rgb(200, 170, 110);
+
+export const onPad = (x) => x >= BASE - 1 && x <= BASE + BASE_W;
+
+/** Hostages waiting in the desert, and the tanks that would rather they stayed. */
+export function populate(rng) {
+  const people = [];
+  for (let i = 0; i < 12; i++) {
+    people.push({ x: 40 + Math.floor(rng() * (WORLD - 55)), waving: true });
+  }
+  const tanks = [];
+  for (let i = 0; i < 4; i++) {
+    tanks.push({ x: 55 + Math.floor(rng() * (WORLD - 70)), dir: rng() < 0.5 ? -1 : 1 });
+  }
+  return { people, tanks };
+}
+
+function hit(state, why) {
+  state.lives--;
+  // Anybody in the back goes down with it. That is the cost of one more pickup.
+  state.aboard = 0;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.home} home`;
+    return state;
+  }
+  state.chopper = { x: BASE + 2, y: GROUND - 1, vy: 0 };
+  state.shells = [];
+  return state;
+}
+
+/** One tick. Exported so a test can fly a whole rescue with no clock. */
+export function step(state) {
+  const chop = state.chopper;
+  chop.x = Math.max(0, Math.min(WORLD - 1, chop.x + state.throttle));
+  chop.y = Math.max(1, Math.min(GROUND, chop.y + chop.vy));
+  // Both axes drift to a stop rather than stopping dead, so it hovers when you
+  // let go instead of dropping out of the sky the moment you stop pressing up.
+  state.throttle *= 0.72;
+  if (Math.abs(state.throttle) < 0.05) state.throttle = 0;
+  chop.vy *= 0.72;
+  if (Math.abs(chop.vy) < 0.05) chop.vy = 0;
+
+  const landed = chop.y >= GROUND;
+
+  if (landed) {
+    // On the ground at the base: everybody out, and that is the score.
+    if (onPad(Math.round(chop.x))) {
+      state.home += state.aboard;
+      state.score += state.aboard * 100;
+      state.aboard = 0;
+    } else {
+      // Out in the desert: anybody close enough climbs in.
+      for (const person of state.people) {
+        if (state.aboard >= SEATS) break;
+        if (Math.abs(person.x - chop.x) > 2 || person.rescued) continue;
+        person.rescued = true;
+        state.aboard++;
+      }
+      state.people = state.people.filter((p) => !p.rescued);
+    }
+  }
+
+  state.clock++;
+  for (const tank of state.tanks) {
+    if (state.clock % 5 === 0) {
+      tank.x += tank.dir;
+      if (tank.x < 30 || tank.x > WORLD - 4) tank.dir *= -1;
+    }
+    // A tank shoots when you are overhead, and only then — you can outrun them.
+    if (state.clock % SHELL_EVERY === 0 && Math.abs(tank.x - chop.x) < 12) {
+      state.shells.push({ x: tank.x, y: GROUND - 1, vy: -0.55 });
+    }
+  }
+
+  for (const shell of state.shells) shell.y += shell.vy;
+  state.shells = state.shells.filter((s) => s.y > 0);
+  const struck = state.shells.find((s) => Math.abs(s.x - chop.x) < 2 && Math.abs(s.y - chop.y) < 1);
+  if (struck) return hit(state, "shot down");
+
+  const run_over = state.tanks.find((t) => landed && Math.abs(t.x - chop.x) < 2);
+  if (run_over) return hit(state, "flattened on the ground");
+
+  if (!state.people.length && !state.aboard) {
+    state.over = `everyone out · ${state.home} home`;
+  }
+  return state;
+}
+
+export const CHOPLIFTER = {
+  key: "choplifter",
+  aliases: ["chopper", "rescue", "heli"],
+  title: "CHOPLIFTER",
+  blurb: "fly out, land, fill the back, and get them home",
+  keys: "← → fly · ↑ ↓ climb and land · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const { people, tanks } = populate(rng);
+    return {
+      chopper: { x: BASE + 2, y: GROUND - 1, vy: 0 },
+      throttle: 0,
+      people,
+      tanks,
+      shells: [],
+      aboard: 0,
+      home: 0,
+      score: 0,
+      lives: LIVES,
+      clock: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    const chop = state.chopper;
+    if (pressed === "left") state.throttle = Math.max(-1.4, state.throttle - 0.7);
+    else if (pressed === "right") state.throttle = Math.min(1.4, state.throttle + 0.7);
+    else if (pressed === "up") chop.vy = Math.max(-0.7, chop.vy - 0.45);
+    else if (pressed === "down") chop.vy = Math.min(0.7, chop.vy + 0.45);
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    return `${state.home} home · ${state.aboard}/${SEATS} aboard · ${state.people.length} waiting · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    // The camera keeps the chopper in the middle until the world runs out.
+    const camera = Math.max(0, Math.min(WORLD - WIDTH, Math.round(state.chopper.x) - Math.floor(WIDTH / 2)));
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (worldX, y, glyph) => {
+      const x = Math.round(worldX) - camera;
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (let i = 0; i < BASE_W; i++) put(BASE + i, GROUND, acid("═"));
+    for (const person of state.people) put(person.x, GROUND - 1, bone("Ω"));
+    for (const tank of state.tanks) put(tank.x, GROUND - 1, danger("▙"));
+    for (const shell of state.shells) put(shell.x, shell.y, amber("•"));
+    const chop = state.chopper;
+    put(chop.x, Math.round(chop.y), state.over ? danger("✷") : acid("╤"));
+    put(chop.x - 1, Math.round(chop.y), state.over ? danger("✷") : ash("─"));
+    put(chop.x + 1, Math.round(chop.y), state.over ? danger("✷") : ash("─"));
+
+    return grid.map((row, y) => row.map((cell, x) => {
+      if (cell) return cell;
+      if (y === GROUND) return sand("▀");
+      if (y > GROUND) return sand("░");
+      // A horizon marker every ten columns of world, so flying feels like it.
+      return (x + camera) % 12 === 0 && y === 1 ? dim("│") : " ";
+    }).join(""));
+  },
+};