@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/match3/tests/endings.og.ts

@@ -0,0 +1,40 @@
+// The two endings, through Tune writes: with the target at 30 the first line
+// wins the round; with one move and a target out of reach, that move loses
+// it. Each end card waits for a press, which deals the next round.
+import { playtest } from "@origingame/engine/playtest";
+import { CASCADE_BOARD, PHASE, matchOf, tap } from "./lib.ts";
+
+export default playtest({
+  name: "reaching the target wins, running out of moves loses, a press deals again",
+  commands: [
+    "0.1:set:board.Tuning.target=30",
+    tap(0.5),
+    `0.8:deal:${CASCADE_BOARD}`,
+    "1.0:swap:2,0:2,1",
+    "3.0:dump_entity:board:won.json",
+    "3.0:screenshot:won.png",
+    "3.1:set:board.Tuning.target=10000",
+    "3.1:set:board.Tuning.moves=1",
+    tap(3.2),
+    "3.3:dump_entity:board:second.json",
+    `3.5:deal:${CASCADE_BOARD}`,
+    "3.7:swap:2,0:2,1",
+    "5.7:dump_entity:board:lost.json",
+    "5.7:screenshot:lost.png",
+    "5.8:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const won = matchOf(run, "won.json");
+    t.equal(won.phase, PHASE.won, "the first line reached the target of 30");
+    t.equal(won.best, won.score, "the best score took the round's");
+    const second = matchOf(run, "second.json");
+    t.equal(second.phase, PHASE.idle, "a press after the card's hold dealt round two");
+    t.equal(second.rounds, 2, "two rounds");
+    t.equal(second.movesLeft, 1, "round two has the tuned single move");
+    const lost = matchOf(run, "lost.json");
+    t.equal(lost.phase, PHASE.lost, "the last move ran out below the target");
+    t.equal(lost.movesLeft, 0, "no moves left");
+    t.equal(lost.best, won.best, "the best score is kept");
+  },
+});

package/archetypes/match3/tests/frames.og.ts

@@ -0,0 +1,49 @@
+// Three frames at 1280x720 compared with references/<tier>/: the dealt
+// board (the nine-sliced panel, the checker tilemap, the gems' idle clips),
+// the swap's line mid-clear (the burst clip, the squash to nothing, the
+// floating +30) and the cascade mid-clear (the gold crit +60 and the
+// camera shake). Every motion is a tween or a flipbook clip on scaled time
+// and the shake is seeded by the tick, so the same script draws the same
+// frames. Record a tier's references with `OG_FX_CAPTURE=1 og test .`.
+import { playtest } from "@origingame/engine/playtest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { checkFrames, decodePng, outDir } from "./frames.ts";
+import { CASCADE_BOARD, PHASE, matchOf, tap } from "./lib.ts";
+
+const FILES = ["dealt.png", "clearing.png", "cascade.png"];
+
+export default playtest({
+  name: "the dealt board, a clear and a cascade match their reference frames",
+  size: "1280x720",
+  commands: [
+    tap(0.5),
+    `0.8:deal:${CASCADE_BOARD}`,
+    "1.2:screenshot:dealt.png",
+    "1.3:swap:2,0:2,1",
+    "1.53:screenshot:clearing.png",
+    "1.53:dump_entity:board:clearing.json",
+    "2.14:screenshot:cascade.png",
+    "2.14:dump_entity:board:cascade.json",
+    "2.2:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    const clearing = matchOf(run, "clearing.json");
+    t.equal([clearing.phase, clearing.chain], [PHASE.clear, 1], "the first frame of play is the swap's own line clearing");
+    const cascade = matchOf(run, "cascade.json");
+    t.equal([cascade.phase, cascade.chain], [PHASE.clear, 2], "the last is the cascade clearing");
+    t.frame(FILES, () => {
+      for (const f of FILES) t.equal(run.png(f).width, 1280, `${f} is 1280 wide`);
+    });
+    // The calm ground: away from the board the frame is the brand ink #14161b.
+    t.frame("dealt.png", () => {
+      const dealt = decodePng(readFileSync(join(outDir(), "dealt.png")));
+      const at = (700 * dealt.width + 20) * 4;
+      const ink = [dealt.rgba[at]!, dealt.rgba[at + 1]!, dealt.rgba[at + 2]!];
+      t.ok(Math.abs(ink[0]! - 0x14) <= 3 && Math.abs(ink[1]! - 0x16) <= 3 && Math.abs(ink[2]! - 0x1b) <= 3, `the corner is the brand ink (${ink.join(", ")})`);
+    });
+    checkFrames(run, t, FILES, "");
+  },
+});

package/archetypes/match3/tests/frames.ts

@@ -0,0 +1,134 @@
+// The reference-frame check: decode the PNGs a run wrote and compare them
+// with references/<tier>/ under og-tests' tolerance (a channel off by more
+// than 32/255 is an outlier; fail above 0.5 % outliers or an RGB RMSE above
+// 0.01). A tier without its own references compares with `metal` and says
+// so. `OG_FX_CAPTURE=1 og test .` records this tier's references instead.
+// (Copied from templates/fx-showcase/tests/frames.ts, so the archetype stands alone.)
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { inflateSync } from "node:zlib";
+import type { PlaytestChecks, PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Image {
+  width: number;
+  height: number;
+  /** RGBA8 rows. */
+  rgba: Uint8Array;
+}
+
+/** An 8-bit RGB or RGBA, non-interlaced PNG, unfiltered. */
+export function decodePng(bytes: Uint8Array): Image {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = 8;
+  let width = 0;
+  let height = 0;
+  let channels = 4;
+  const idat: Uint8Array[] = [];
+  while (at < bytes.length) {
+    const len = view.getUint32(at);
+    const type = String.fromCharCode(...bytes.subarray(at + 4, at + 8));
+    const data = bytes.subarray(at + 8, at + 8 + len);
+    if (type === "IHDR") {
+      width = view.getUint32(at + 8);
+      height = view.getUint32(at + 12);
+      const depth = data[8]!;
+      const color = data[9]!;
+      if (depth !== 8 || (color !== 6 && color !== 2) || data[12] !== 0) throw new Error(`unsupported PNG (depth ${depth}, colour ${color}, interlace ${data[12]})`);
+      channels = color === 6 ? 4 : 3;
+    } else if (type === "IDAT") idat.push(data);
+    else if (type === "IEND") break;
+    at += 12 + len;
+  }
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * channels;
+  const out = new Uint8Array(width * height * 4);
+  const prev = new Uint8Array(stride);
+  const cur = new Uint8Array(stride);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)]!;
+    const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    for (let i = 0; i < stride; i++) {
+      const a = i >= channels ? cur[i - channels]! : 0;
+      const b = prev[i]!;
+      const c = i >= channels ? prev[i - channels]! : 0;
+      let v = line[i]!;
+      if (filter === 1) v += a;
+      else if (filter === 2) v += b;
+      else if (filter === 3) v += (a + b) >> 1;
+      else if (filter === 4) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+        v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      }
+      cur[i] = v & 255;
+    }
+    for (let x = 0; x < width; x++) {
+      for (let k = 0; k < 4; k++) out[(y * width + x) * 4 + k] = k < channels ? cur[x * channels + k]! : 255;
+    }
+    prev.set(cur);
+  }
+  return { width, height, rgba: out };
+}
+
+/** og-tests' rule: outlier fraction and RGB RMSE between two equal-size frames. */
+export function difference(a: Image, b: Image): { outliers: number; rmse: number } {
+  if (a.width !== b.width || a.height !== b.height) return { outliers: 1, rmse: 1 };
+  let outliers = 0;
+  let sum = 0;
+  const n = a.width * a.height;
+  for (let p = 0; p < n; p++) {
+    let out = false;
+    for (let k = 0; k < 3; k++) {
+      const d = Math.abs(a.rgba[p * 4 + k]! - b.rgba[p * 4 + k]!);
+      if (d > 32) out = true;
+      const f = d / 255;
+      sum += f * f;
+    }
+    if (out) outliers++;
+  }
+  return { outliers: outliers / n, rmse: Math.sqrt(sum / (n * 3)) };
+}
+
+/** The playtest's output directory (the bundled playtest runs from it). */
+export function outDir(): string {
+  return dirname(fileURLToPath(import.meta.url));
+}
+
+/** The project's references/, from its og-out/test/<name>/. */
+export function referencesDir(): string {
+  return resolve(outDir(), "..", "..", "..", "references");
+}
+
+/** Compares each screenshot with its reference (`<prefix><file>`), or records it. */
+export function checkFrames(run: PlaytestRun, t: PlaytestChecks, files: readonly string[], prefix: string): void {
+  // Read only where there is a renderer: without one (tier `none`) each frame is
+  // reported "no renderer, frame unchecked" and every other check still runs.
+  t.frame(files, () => {
+    const refs = referencesDir();
+    t.ok(existsSync(refs) || process.env.OG_FX_CAPTURE !== undefined, `the references directory exists at ${refs}`);
+    const own = join(refs, run.tier);
+    const capture = process.env.OG_FX_CAPTURE !== undefined;
+    for (const f of files) {
+      const actual = join(outDir(), f);
+      // Each file on its own: this tier's reference where it has one, metal's otherwise.
+      const mine = join(own, prefix + f);
+      const ref = capture || existsSync(mine) ? mine : join(refs, "metal", prefix + f);
+      if (ref !== mine) process.stdout.write(`  note: no ${run.tier} reference for ${prefix}${f}; comparing with metal\n`);
+      if (capture) {
+        mkdirSync(own, { recursive: true });
+        copyFileSync(actual, ref);
+        t.ok(true, `recorded ${ref}`);
+        continue;
+      }
+      if (!existsSync(ref)) {
+        t.ok(false, `${ref} is missing: record it with OG_FX_CAPTURE=1 og test .`);
+        continue;
+      }
+      const d = difference(decodePng(readFileSync(actual)), decodePng(readFileSync(ref)));
+      process.stdout.write(`  ${f}: ${(d.outliers * 100).toFixed(3)} % outliers, RMSE ${d.rmse.toFixed(5)} against ${ref}\n`);
+      t.ok(d.outliers <= 0.005 && d.rmse <= 0.01, `${f} matches ${prefix}${f}: ${(d.outliers * 100).toFixed(3)} % outliers (≤ 0.5 %), RMSE ${d.rmse.toFixed(5)} (≤ 0.01)`);
+    }
+  });
+}

package/archetypes/match3/tests/hidpi.og.ts

@@ -0,0 +1,41 @@
+// A high-DPR screen: the play surface is 640×360 CSS px at 2× over the
+// same 1280×720 render target. The pointer arrives in CSS pixels, so the
+// mapping Pick works out is too (half the 1× numbers), and a tap on a
+// cell's CSS pixel selects that cell.
+import { playtest } from "@origingame/engine/playtest";
+import { cellCentre } from "../src/layout.ts";
+import { CASCADE_BOARD, MAPPING, PHASE, matchOf } from "./lib.ts";
+
+/** The 2× surface's mapping: the same view over half the CSS pixels. */
+const HALF = { pxPerM: MAPPING.pxPerM / 2, screenX0: MAPPING.screenX0 / 2, screenY0: MAPPING.screenY0 / 2 } as const;
+
+function tapCell(t: number, col: number, row: number): string {
+  const c = cellCentre(col, row);
+  const at = `${Math.round(HALF.screenX0 + c.x * HALF.pxPerM)},${Math.round(HALF.screenY0 - c.y * HALF.pxPerM)}`;
+  return `${t}:touch_move:${at};${t}:touch_start;${(t + 0.05).toFixed(2)}:touch_end`;
+}
+
+export default playtest({
+  name: "on a 2× screen the pointer maps in CSS pixels and a tap selects the cell under it",
+  commands: [
+    "0.05:viewport:2x",
+    "0.5:touch_move:320,340;0.5:touch_start;0.55:touch_end",
+    `0.8:deal:${CASCADE_BOARD}`,
+    "0.9:dump_entity:board:dealt.json",
+    tapCell(1.0, 5, 0),
+    "1.1:dump_entity:board:selected.json",
+    tapCell(1.3, 1, 4),
+    "1.4:dump_entity:board:moved.json",
+    "1.5:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const dealt = matchOf(run, "dealt.json");
+    t.equal(dealt.phase, PHASE.idle, "a tap on the title dealt a round");
+    t.equal(dealt.pxPerM, HALF.pxPerM, "30 CSS px per metre on the 360 px tall surface");
+    t.equal(dealt.screenX0, HALF.screenX0, "the world origin is at CSS x 320");
+    t.equal(dealt.screenY0, HALF.screenY0, "and at CSS y 195");
+    t.equal(matchOf(run, "selected.json").selected, 5, "a tap on (5,0) selected cell 5");
+    t.equal(matchOf(run, "moved.json").selected, 4 * 7 + 1, "a tap on (1,4), not a neighbour, selected cell 29 instead");
+  },
+});

package/archetypes/match3/tests/lib.ts

@@ -0,0 +1,64 @@
+// Shared helpers for the match3 playtests: the board's Match as dump_entity
+// writes it, and pointer pixels for cells at the playtests' 1280x720 surface.
+import type { PlaytestRun } from "@origingame/engine/playtest";
+import { cellCentre } from "../src/layout.ts";
+
+export interface MatchDump {
+  phase: number;
+  score: number;
+  best: number;
+  movesLeft: number;
+  chain: number;
+  maxChain: number;
+  cleared: number;
+  lastCleared: number;
+  rounds: number;
+  selected: number;
+  pxPerM: number;
+  screenX0: number;
+  screenY0: number;
+}
+
+export const PHASE = { title: 0, idle: 1, swap: 2, swapBack: 3, clear: 4, fall: 5, won: 6, lost: 7 } as const;
+
+export function matchOf(run: PlaytestRun, file: string): MatchDump {
+  const dump = run.json<{ components: Record<string, unknown> }>(file);
+  const m = dump.components["Match"];
+  if (!m) throw new Error(`${file} has no Match`);
+  return m as MatchDump;
+}
+
+/**
+ * The pointer mapping these scripts assume at 1280x720: the view is 12 m
+ * tall (60 px per metre) and centred 0.9 m above the board's centre, so the
+ * world origin is at (640, 390). Each playtest checks the dumped mapping
+ * against it, so a layout change fails loudly instead of tapping elsewhere.
+ */
+export const MAPPING = { pxPerM: 60, screenX0: 640, screenY0: 390 } as const;
+
+/** The CSS pixel at the centre of a cell (col 0 is the left, row 0 the bottom), offset by (dx, dy) metres. */
+export function px(col: number, row: number, dx = 0, dy = 0): string {
+  const c = cellCentre(col, row);
+  return `${Math.round(MAPPING.screenX0 + (c.x + dx) * MAPPING.pxPerM)},${Math.round(MAPPING.screenY0 - (c.y + dy) * MAPPING.pxPerM)}`;
+}
+
+/** A tap on a cell at t seconds. */
+export const tapCell = (t: number, col: number, row: number) =>
+  `${t}:touch_move:${px(col, row)};${t}:touch_start;${(t + 0.05).toFixed(2)}:touch_end`;
+
+/** A tap anywhere (starts a round from the title or an end card). */
+export const tap = (t: number) => `${t}:touch_move:640,700;${t}:touch_start;${(t + 0.05).toFixed(2)}:touch_end`;
+
+/**
+ * A board with no line (top row first): swapping (2,0) with (2,1) makes a
+ * line of 3s along the bottom row, and when it clears, the tiles that fall
+ * make a line of 0s at (1..3, 0): a cascade. Swapping (5,0) with (6,0)
+ * makes nothing.
+ */
+export const CASCADE_BOARD = "2340123/0123401/3401234/1234012/4022340/2031123/3300401";
+
+export function checkMapping(m: MatchDump, t: { equal<T>(a: T, b: T, what: string): void }): void {
+  t.equal(m.pxPerM, MAPPING.pxPerM, "the pointer mapping is 60 px per metre at 1280x720");
+  t.equal(m.screenX0, MAPPING.screenX0, "the world origin is at x 640");
+  t.equal(m.screenY0, MAPPING.screenY0, "the world origin is at y 390");
+}

package/archetypes/match3/tests/replay.og.ts

@@ -0,0 +1,28 @@
+// The same script twice, in fresh processes, ends in the same world: a
+// refused swap (a yoyo tween), a swap whose line clears and cascades (tween
+// groups, flipbook clips, floating scores, camera shake and the refill's
+// dice), stopped mid-fall so running tweens, clips and floating text are in
+// the hash too.
+import { playtest } from "@origingame/engine/playtest";
+import { CASCADE_BOARD, PHASE, matchOf, tap } from "./lib.ts";
+
+export default playtest({
+  name: "a replay of swaps, clears and a cascade lands on the same world hash",
+  runs: 2,
+  commands: [
+    tap(0.5),
+    `0.8:deal:${CASCADE_BOARD}`,
+    "1.0:swap:5,0:6,0",
+    "1.5:swap:2,0:2,1",
+    "2.75:dump_entity:board:falling.json",
+    "2.75:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    const m = matchOf(run, "falling.json");
+    t.equal([m.phase, m.chain, m.cleared], [PHASE.fall, 2, 6], "it stops while the cascade's gems fall");
+    t.equal(run.hashes.length, 2, "the script ran twice");
+    t.equal(run.hashes[1], run.hashes[0], "both runs end in the same world");
+  },
+});

package/archetypes/match3/tests/sounds.og.ts

@@ -0,0 +1,50 @@
+// Sounds: a selection, a refused swap, a swap, its clear and the cascade,
+// the win and (in a second round of one move) the loss each start their own
+// voice once (Sfx.plays on the sfx-<bit> entity); the mix is heard.
+import { playtest } from "@origingame/engine/playtest";
+import { CASCADE_BOARD, tap, tapCell } from "./lib.ts";
+
+interface EntityDump {
+  components: Record<string, Record<string, unknown>>;
+}
+
+const VOICES = [
+  [1, "a selection", 2],
+  [2, "a swap", 1],
+  [4, "a refused swap", 1],
+  [8, "a clear", 1],
+  [16, "a cascade", 1],
+  [32, "the win", 1],
+  [64, "the loss", 1],
+] as const;
+
+export default playtest({
+  name: "selections, swaps, clears, a cascade, the win and the loss each play their sound",
+  commands: [
+    "0.1:set:board.Tuning.target=30",
+    "0.45:listen:title.wav:0.3",
+    tap(0.5),
+    `0.8:deal:${CASCADE_BOARD}`,
+    tapCell(1.0, 5, 0),
+    tapCell(1.2, 6, 0),
+    tapCell(2.0, 2, 0),
+    tapCell(2.2, 2, 1),
+    "2.5:listen:clear.wav:0.3",
+    "4.3:set:board.Tuning.target=10000",
+    "4.3:set:board.Tuning.moves=1",
+    tap(4.5),
+    `4.8:deal:${CASCADE_BOARD}`,
+    "5.0:swap:2,0:2,1",
+    ...VOICES.map(([bit]) => `7.2:dump_entity:sfx-${bit}:sfx-${bit}.json`),
+    "7.3:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.wav("title.wav").peak < 0.001, `the title is silent (peak ${run.wav("title.wav").peak})`);
+    t.ok(run.wav("clear.wav").peak > 0.05, `the swap and its clear are heard (peak ${run.wav("clear.wav").peak})`);
+    for (const [bit, what, least] of VOICES) {
+      const plays = Number(run.json<EntityDump>(`sfx-${bit}.json`).components["Sfx"]?.["plays"] ?? 0);
+      t.ok(plays >= least, `${what} played its sound (${plays} time(s), at least ${least})`);
+    }
+  },
+});

package/archetypes/match3/tests/swap.og.ts

@@ -0,0 +1,67 @@
+// Swapping by two taps on an authored board: the swap that makes a line of
+// three clears it, scores, spends one move, and the tiles that fall make a
+// second line (a cascade worth double). A swap that makes nothing goes back
+// and costs nothing.
+import { playtest } from "@origingame/engine/playtest";
+import { SIZE } from "../src/layout.ts";
+import { CASCADE_BOARD, PHASE, checkMapping, matchOf, tap, tapCell } from "./lib.ts";
+
+export default playtest({
+  name: "a swap that makes a line clears, scores and cascades; one that makes nothing is free",
+  commands: [
+    "0.3:screenshot:title.png",
+    tap(0.5),
+    `0.8:deal:${CASCADE_BOARD}`,
+    "0.9:dump_entity:board:dealt.json",
+    "0.9:screenshot:play.png",
+    // The refused swap first: (5,0) then (6,0).
+    tapCell(1.0, 5, 0),
+    "1.1:dump_entity:board:selected.json",
+    tapCell(1.2, 6, 0),
+    "1.42:dump_entity:board:swapping-back.json",
+    "1.8:dump_entity:board:refused.json",
+    // The line: (2,0) then (2,1).
+    tapCell(2.0, 2, 0),
+    tapCell(2.2, 2, 1),
+    "2.45:screenshot:clearing.png",
+    "2.45:dump_entity:board:clearing.json",
+    "4.0:dump_entity:board:settled.json",
+    "4.0:screenshot:settled.png",
+    "4.0:dump_world:world.json",
+    "4.1:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    const dealt = matchOf(run, "dealt.json");
+    checkMapping(dealt, t);
+    t.equal(dealt.phase, PHASE.idle, "a tap on the title deals a round");
+    t.equal(dealt.movesLeft, 20, "the round starts with Tuning.moves");
+
+    t.equal(matchOf(run, "selected.json").selected, 5, "the first tap selects cell (5,0)");
+    t.equal(matchOf(run, "swapping-back.json").phase, PHASE.swapBack, "the swap that makes nothing goes back");
+    const refused = matchOf(run, "refused.json");
+    t.equal(refused.phase, PHASE.idle, "back to idle");
+    t.equal(refused.movesLeft, 20, "the refused swap cost no move");
+    t.equal(refused.score, 0, "and scored nothing");
+
+    const clearing = matchOf(run, "clearing.json");
+    t.equal(clearing.phase, PHASE.clear, "the line is clearing");
+    t.equal(clearing.movesLeft, 19, "the swap that made a line spent a move");
+
+    const settled = matchOf(run, "settled.json");
+    t.equal(settled.phase, PHASE.idle, "the board settled");
+    t.ok(settled.maxChain >= 2, `the fall made a second line: a cascade (chain ${settled.maxChain})`);
+    t.ok(settled.cleared >= 6, `both lines cleared (${settled.cleared} tiles)`);
+    t.ok(settled.score >= 3 * 10 + 3 * 10 * 2, `three tiles at 10, then three at 10 x 2 (score ${settled.score})`);
+
+    const world = run.json<{ systems: Array<{ name: string; matched: number | null }> }>("world.json");
+    // The backdrop, the board, the 49 gems and the selection frame; the checker tilemap is no row.
+    const rows = SIZE * SIZE + 3;
+    for (const s of ["Flow", "Pick", "Resolve", "Animate"]) {
+      const sys = world.systems.find((x) => x.name === s);
+      t.equal(sys?.matched, rows, `${s} sees every row`);
+    }
+    t.equal(world.systems.find((x) => x.name === "Hud")?.matched, 1, "Hud sees the board row only");
+  },
+});