@origingame/create-game 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,35 @@
+// Three frames at 1280×720 compared with references/<tier>/: the title,
+// the highway in bar 9 (the lead's notes on three lanes, a Perfect, the
+// combo) and the results of a song cleared from bar 23. `OG_FX_CAPTURE=1
+// og test .` records this tier's references.
+import { playtest } from "@origingame/engine/playtest";
+import { checkFrames } from "./frames.ts";
+import { BEAT, chart, play, songStart, sorted } from "./lib.ts";
+
+const FILES = ["title.png", "highway.png", "results.png"];
+const notes = chart();
+const t0 = songStart(1.2, 7);
+const t1 = songStart(9.0, 23);
+const last = notes[notes.length - 1]!.beat;
+
+export default playtest({
+  name: "the title, the highway and the results match their reference frames",
+  size: "1280x720",
+  commands: sorted([
+    "1.0:screenshot:title.png",
+    "1.2:play:7",
+    ...play(notes, t0, 24, 33.5),
+    `${(t0 + 33.6 * BEAT).toFixed(3)}:screenshot:highway.png`,
+    "9.0:play:23",
+    ...play(notes, t1, 88, last + 1),
+    `${(t1 + last * BEAT + 2.4).toFixed(3)}:screenshot:results.png`,
+    `${(t1 + last * BEAT + 2.5).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.frame(FILES, () => {
+      for (const f of FILES) t.equal(run.png(f).width, 1280, `${f} is 1280 wide`);
+    });
+    checkFrames(run, t, FILES, "");
+  },
+});

package/archetypes/rhythm/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/rhythm/tests/lib.ts

@@ -0,0 +1,123 @@
+// Shared readers and the chart for Three-Lane Beat's playtests.
+// `get:Game:<file>` writes the play's resource, the state the game's
+// `facts` (src/main.ts) report to the probe; `dump_ui` the screen;
+// `dump_entity` a row; `dump_platform` the calls to og.platform. The chart
+// is read from assets/charts/neon-pulse.ogt (data), so a script can press
+// each lane at its notes' times.
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Game {
+  phase: number;
+  paused: boolean;
+  held: boolean;
+  songStart: number;
+  pausedAt: number;
+  countTo: number;
+  score: number;
+  combo: number;
+  maxCombo: number;
+  perfect: number;
+  great: number;
+  good: number;
+  miss: number;
+  hits: number;
+  judged: number;
+  notes: number;
+  taps: number;
+  groove: number;
+  failed: boolean;
+  cleared: boolean;
+  lastJudgement: number;
+  lastOffsetMs: number;
+  calTaps: number;
+  calSum: number;
+  best: number;
+  newBest: boolean;
+  language: number;
+}
+
+/** Phase.* of src/components.ts. */
+export const TITLE = 0;
+export const PLAY = 1;
+export const RESULTS = 2;
+export const CALIBRATE = 3;
+
+/** The Game resource from a `get:Game:<file>` step. */
+export function game(run: PlaytestRun, file: string): Game {
+  return run.json<{ value: Game }>(file).value;
+}
+
+export interface UiElement { id: string; parent: string; kind: string; text: string; x: number; y: number; width: number; height: number }
+
+export function ui(run: PlaytestRun, file: string): { surface: { width: number; height: number }; elements: UiElement[] } {
+  return run.json(file);
+}
+
+/** The text of the first element with this id (under `parent` when given). */
+export function text(run: PlaytestRun, file: string, id: string, parent?: string): string | undefined {
+  return ui(run, file).elements.find((e) => e.id === id && (parent === undefined || e.parent === parent))?.text;
+}
+
+export interface PlatformDump {
+  calls: Array<{ method: string; args: Record<string, unknown>; tick: number; result?: { ok: boolean; data?: Record<string, unknown> } }>;
+}
+
+/** The chart's notes in time order: lane and beat. */
+export interface ChartNote { lane: number; beat: number }
+
+/** The project's assets/charts/neon-pulse.ogt: from the bundled playtest's directory up (og test runs it from og-out/test/<name>/, og polish from elsewhere), else from the working directory. */
+function chartPath(): string {
+  const rel = join("assets", "charts", "neon-pulse.ogt");
+  for (let dir = dirname(fileURLToPath(import.meta.url)), n = 0; n < 8; dir = dirname(dir), n++) {
+    if (existsSync(join(dir, rel)) && existsSync(join(dir, "project.ogt"))) return join(dir, rel);
+  }
+  return resolve(process.cwd(), rel);
+}
+
+/** The chart's notes, read as data. */
+export function chart(): ChartNote[] {
+  const textOf = readFileSync(chartPath(), "utf8");
+  const notes: ChartNote[] = [];
+  const re = /Note \{\s*index (\d+)\s*lane (\d+)\s*beat ([\d.]+)\s*\}/g;
+  for (let m = re.exec(textOf); m !== null; m = re.exec(textOf)) notes.push({ lane: Number(m[2]), beat: Number(m[3]) });
+  return notes;
+}
+
+/** The song's beat (120 BPM). */
+export const BEAT = 0.5;
+
+/**
+ * Where bar 1 starts for a `play` (or a Play tap's start) at time t: the
+ * next whole tick a quarter second on, then the four beats of the count-in
+ * (src/ui.ts `begin`), less the bars skipped by `play:<bar>`.
+ */
+export function songStart(t: number, fromBar = 1): number {
+  return Math.ceil((Math.round(t * 60) / 60 + 0.25) * 60) / 60 + 4 * BEAT - (fromBar - 1) * 4 * BEAT;
+}
+
+/** The lanes' keys. */
+export const KEYS = ["KeyA", "KeyS", "KeyD"] as const;
+
+/** A key pressed at t (down, then up two ticks later). */
+export const press = (key: string, t: number) => `${t.toFixed(4)}:key_down:${key};${(t + 0.034).toFixed(4)}:key_up:${key}`;
+
+/** Presses for the notes in [fromBeat, toBeat), each `late` seconds after its time (a chord's lanes together). */
+export function play(notes: readonly ChartNote[], start: number, fromBeat: number, toBeat: number, late = 0): string[] {
+  return notes.filter((n) => n.beat >= fromBeat && n.beat < toBeat).map((n) => press(KEYS[n.lane]!, start + n.beat * BEAT + late));
+}
+
+/** Commands in time order (the probe wants ascending times). */
+export function sorted(cmds: readonly string[]): string {
+  return cmds
+    .flatMap((c) => c.split(";"))
+    .map((c) => ({ t: Number(c.slice(0, c.indexOf(":"))), c }))
+    .sort((a, b) => a.t - b.t)
+    .map((x) => x.c)
+    .join(";");
+}
+
+/** A tap on a UI element by its id path (pressed, released a tick later). */
+export const tap = (id: string, t: number) => `${t}:touch_move_to:${id};${(t + 0.017).toFixed(3)}:touch_start;${(t + 0.05).toFixed(3)}:touch_end`;

package/archetypes/rhythm/tests/pad.og.ts

@@ -0,0 +1,41 @@
+// A gamepad alone: the d-pad and A play from the title; bar 1 and bar 2
+// are hit with the d-pad (left, down, right) and the face buttons (X, A,
+// B); Start pauses, the d-pad moves the menu's focus and A on Resume
+// resumes.
+import { playtest } from "@origingame/engine/playtest";
+import { BEAT, chart, game, PLAY, songStart, sorted } from "./lib.ts";
+
+const notes = chart();
+/** A pad button pressed at t and let go 0.05 s later (the pad set aside, so the release is no input of its own). */
+const pad = (button: string, t: number) => `${t.toFixed(4)}:gamepad:${button};${(t + 0.05).toFixed(4)}:gamepad:off`;
+const t0 = songStart(1.1);
+const DPAD = ["left", "down", "right"];
+const FACE = ["x", "a", "b"];
+
+export default playtest({
+  name: "the d-pad and the face buttons hit the lanes; Start pauses, A resumes",
+  commands: sorted([
+    // The title's first item holds the focus when the menu opens (og-ui §4), so A plays at once; no d-pad press first.
+    pad("a", 1.1),
+    "1.4:get:Game:started.json",
+    ...notes.filter((n) => n.beat < 8).map((n) => pad(n.beat < 4 ? DPAD[n.lane]! : FACE[n.lane]!, t0 + n.beat * BEAT)),
+    `${(t0 + 7.9 * BEAT).toFixed(3)}:get:Game:hit.json`,
+    pad("start", t0 + 8.2 * BEAT),
+    `${(t0 + 8.8 * BEAT).toFixed(3)}:get:Game:paused.json`,
+    pad("down", t0 + 9.0 * BEAT),
+    pad("up", t0 + 9.2 * BEAT),
+    pad("a", t0 + 9.4 * BEAT),
+    `${(t0 + 10 * BEAT).toFixed(3)}:get:Game:resumed.json`,
+    `${(t0 + 10.1 * BEAT).toFixed(3)}:gamepad:off`,
+    `${(t0 + 10.2 * BEAT).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(game(run, "started.json").phase, PLAY, "the pad started the song from the title");
+    const h = game(run, "hit.json");
+    t.equal(h.hits, 8, "the d-pad hit bar 1's notes and the face buttons bar 2's");
+    t.equal(h.miss, 0, "none missed");
+    t.equal(game(run, "paused.json").paused, true, "Start paused");
+    t.equal(game(run, "resumed.json").paused, false, "A on Resume resumed");
+  },
+});

package/archetypes/rhythm/tests/pause.og.ts

@@ -0,0 +1,77 @@
+// Pause, settings and the resume: bar 1 hit, then Escape in bar 2: the
+// clock freezes (no note is missed while paused), the band stops, the
+// time scale holds; the settings switch to 简体中文 and save; Resume counts
+// in again and continues from the beat it paused on: the drums start again
+// part-way into bar 2's stem (AudioSource.startOffset), and bar 2's last
+// notes are hit at their new times.
+import { playtest } from "@origingame/engine/playtest";
+import { BEAT, chart, game, type PlatformDump, play, press, songStart, sorted, tap, text } from "./lib.ts";
+
+const notes = chart();
+const t0 = songStart(1.0);
+const pauseAt = t0 + 5.3 * BEAT;
+/** The resume (the `unhold` command, as Resume does): the count-in ends where a start's would. */
+const resumeAt = 10.0;
+const countTo = songStart(resumeAt);
+/** The beat Escape paused on: its tick's time into the song. */
+const pausedBeat = (Math.round(pauseAt * 60) / 60 - t0) / BEAT;
+/** Bar 1's time after the resume: the paused beat comes at the count-in's end. */
+const t1 = countTo - pausedBeat * BEAT;
+
+export default playtest({
+  name: "Escape freezes the clock and stops the band; 简体中文 is saved; Resume counts in and continues from the beat it paused on",
+  commands: sorted([
+    "1.0:play",
+    ...play(notes, t0, 0, 5.3),
+    press("Escape", pauseAt),
+    `${(pauseAt + 0.3).toFixed(3)}:get:Game:paused.json`,
+    `${(pauseAt + 0.3).toFixed(3)}:get:og.TimeScale.scale:scale.json`,
+    `${(pauseAt + 0.3).toFixed(3)}:dump_entity:stem-drums:drums.json`,
+    `${(pauseAt + 0.4).toFixed(3)}:screenshot:pause.png`,
+    tap("settings", 6.6),
+    "7.2:move_to_text:简体中文",
+    "7.22:touch_start",
+    "7.25:touch_end",
+    "7.6:screenshot:settings-zh.png",
+    tap("Done", 7.8),
+    "8.9:get:Game:held.json",
+    "8.9:get:Prefs:prefs.json",
+    "8.9:dump_platform:platform.json",
+    `${resumeAt}:unhold`,
+    `${(resumeAt + 0.1).toFixed(3)}:get:Game:resumed.json`,
+    `${(resumeAt + 0.15).toFixed(3)}:dump_entity:stem-drums:drums2.json`,
+    ...play(notes, t1, pausedBeat, 8),
+    `${(t1 + 7.9 * BEAT).toFixed(3)}:get:Game:after.json`,
+    `${(t1 + 7.9 * BEAT).toFixed(3)}:dump_ui:play-zh.json`,
+    `${(t1 + 7.95 * BEAT).toFixed(3)}:screenshot:play-zh.png`,
+    `${(t1 + 8.0 * BEAT).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const p = game(run, "paused.json");
+    t.equal(p.paused, true, "Escape paused");
+    t.equal(p.judged, 6, "after bar 1's four notes and bar 2's first two");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "the time scale holds at 0");
+    t.equal(run.json<{ components: { "og.AudioSource": { playing: boolean } } }>("drums.json").components["og.AudioSource"].playing, false, "the band stopped");
+    const h = game(run, "held.json");
+    t.ok(h.judged === 6 && h.miss === 0, "three seconds later nothing was missed: the clock is frozen");
+    const prefs = run.json<{ value: { language: number; saves: number } }>("prefs.json").value;
+    t.ok(prefs.language === 1 && prefs.saves === 1, "简体中文 was chosen and saved");
+    const pd = run.json<PlatformDump>("platform.json");
+    t.ok(pd.calls.some((c) => c.method === "store.set" && c.args["key"] === "og.settings" && (c.args["value"] as { language?: string }).language === "zh-CN"), "through og.platform");
+    const r = game(run, "resumed.json");
+    t.equal(r.paused, false, "Resume");
+    t.ok(Math.abs(r.songStart - t1) < 1e-6, `continued from beat ${pausedBeat.toFixed(3)}: bar 1 now at ${t1.toFixed(3)} s, the paused beat at the count-in's end`);
+    t.ok(Math.abs(r.countTo - countTo) < 1e-6, `after a count-in to ${countTo.toFixed(3)} s`);
+    const drums = run.json<{ components: { "og.AudioSource": { startAt: number; startOffset: number } } }>("drums2.json").components["og.AudioSource"];
+    t.ok(Math.abs(drums.startAt - countTo) < 1e-6, "the drums start again at the count-in's end");
+    t.ok(Math.abs(drums.startOffset - (pausedBeat - 4) * BEAT) < 1e-6, `part-way into bar 2's stem: ${((pausedBeat - 4) * BEAT).toFixed(3)} s in, not from its start`);
+    const a = game(run, "after.json");
+    t.equal(a.perfect, 8, "bar 2's last two notes were hit at their new times: eight Perfects");
+    t.equal(a.miss, 0, "and nothing missed, bar 1 not judged twice");
+    t.equal(text(run, "play-zh.json", "Label", "Score"), "得分", "the HUD speaks 简体中文");
+    t.frame(["pause.png", "settings-zh.png", "play-zh.png"], () => {
+      for (const f of ["pause.png", "settings-zh.png", "play-zh.png"]) t.equal(run.png(f).width, 1280, `${f} captured`);
+    });
+  },
+});

package/archetypes/rhythm/tests/phone.og.ts

@@ -0,0 +1,44 @@
+// The phone layout (390×844 at 3×, a notch and a home bar): the title's
+// menu, then the score, the groove and Pause below the notch, the combo
+// above the highway, three 2 m lanes across the width with the hit line
+// above the home bar; a finger on a lane at its note's time hits it.
+import { playtest } from "@origingame/engine/playtest";
+import { BEAT, chart, game, songStart, sorted, tap, type UiElement, ui } from "./lib.ts";
+
+const notes = chart();
+const t0 = songStart(1.0);
+/** CSS px per metre: the camera is 7.2 m across 390 px. */
+const scale = 390 / 7.2;
+const laneX = (lane: number) => 195 + (lane - 1) * 2 * scale;
+const touch = (lane: number, t: number) => `${t.toFixed(4)}:touch_move:${laneX(lane).toFixed(1)},690;${(t + 0.0001).toFixed(4)}:touch_start;${(t + 0.05).toFixed(4)}:touch_end`;
+
+export default playtest({
+  name: "the phone layout: a HUD inside the safe area, three lanes across, fingers hit the notes",
+  size: "1170x2532",
+  commands: sorted([
+    "0.1:viewport:phone",
+    "0.9:dump_ui:title.json",
+    "1.0:play",
+    ...notes.filter((n) => n.beat < 8).map((n) => touch(n.lane, t0 + n.beat * BEAT)),
+    `${(t0 + 7.9 * BEAT).toFixed(3)}:get:Game:hit.json`,
+    `${(t0 + 7.9 * BEAT).toFixed(3)}:dump_ui:hud.json`,
+    `${(t0 + 7.95 * BEAT).toFixed(3)}:screenshot:play.png`,
+    `${(t0 + 8 * BEAT).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const title = ui(run, "title.json").elements;
+    t.ok(title.some((e) => e.id === "play") && title.every((e) => e.y >= 47 && e.y + e.height <= 844 - 34), "the title's menu sits inside the safe area");
+    const h = game(run, "hit.json");
+    t.equal(h.hits, 8, "eight notes hit by fingers on their lanes");
+    t.equal(h.perfect, 8, "all on time");
+    const hud = ui(run, "hud.json");
+    const el = (id: string): UiElement | undefined => hud.elements.find((e) => e.id === id);
+    t.equal(hud.surface.width, 390, "laid out for a 390 px wide phone");
+    for (const id of ["Status", "Corner", "Combo"]) t.ok((el(id)?.y ?? 0) >= 47, `${id} sits below the notch`);
+    t.ok(hud.elements.every((e) => e.x >= 0 && e.x + e.width <= 390 && e.y + e.height <= 844 - 34), "nothing runs off the sides or under the home bar");
+    const pause = el("Pause");
+    t.ok(pause !== undefined && pause.width >= 44 && pause.height >= 44, "Pause is touch-sized");
+    t.frame("play.png", () => t.equal(run.png("play.png").width, 1170, "play.png captured at the phone's device pixels"));
+  },
+});

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

@@ -0,0 +1,27 @@
+// Determinism: a play with hits on time, late and early, misses and the
+// band's stems, run twice in fresh processes, ends on the same world hash.
+import { playtest } from "@origingame/engine/playtest";
+import { chart, game, play, songStart, sorted } from "./lib.ts";
+
+const notes = chart();
+const t0 = songStart(1.0);
+
+export default playtest({
+  name: "a play with hits, misses and the band replays to the same hash",
+  runs: 2,
+  commands: sorted([
+    "1.0:play",
+    ...play(notes, t0, 0, 4),
+    ...play(notes, t0, 4, 8, 0.07),
+    ...play(notes, t0, 8, 10, -0.1),
+    `${(t0 + 13 * 0.5).toFixed(3)}:get:Game:end.json`,
+    `${(t0 + 13.1 * 0.5).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(run.hashes.length, 2, "two runs");
+    t.equal(run.hashes[1], run.hashes[0], `both runs end on hash ${run.hashes[0]}`);
+    const end = game(run, "end.json");
+    t.ok(end.perfect >= 4 && end.great >= 4 && end.good >= 1 && end.miss >= 1, `perfects, greats, goods and misses (${end.perfect}, ${end.great}, ${end.good}, ${end.miss})`);
+  },
+});

package/archetypes/rhythm/tests/timing.og.ts

@@ -0,0 +1,37 @@
+// A press is judged when it happened, not at the start of the tick that
+// reads it: bars 1 and 2's notes pressed 44 ms late and early (a tick's
+// start would read them 50 ms off: Great), 7 ms either way, 89 ms either
+// way (Great, inside 90), 20 ms late and 30 ms early. Each judgement's
+// error is the press's offset to a tenth of a millisecond: the key's
+// og.KeyDown carries its time within the tick (the command step's here,
+// the browser event's timeStamp in a page).
+import { playtest } from "@origingame/engine/playtest";
+import { BEAT, chart, game, KEYS, press, songStart, sorted, tap } from "./lib.ts";
+
+const notes = chart().filter((n) => n.beat < 8);
+const t0 = songStart(1.05);
+const offsets = [44, -44, 7, -7, 89, -89, 20, -30];
+/** Perfect within 45 ms, Great within 90 (Judgement.* of src/components.ts: Perfect 0, Great 1). */
+const expected = offsets.map((ms) => (Math.abs(ms) <= 45 ? 0 : 1));
+
+export default playtest({
+  name: "a press is judged at the millisecond it happened within its tick",
+  commands: sorted([
+    tap("play", 1.0),
+    ...notes.flatMap((n, i) => {
+      const at = t0 + n.beat * BEAT;
+      return [press(KEYS[n.lane]!, at + offsets[i]! / 1000), `${(at + 0.2).toFixed(4)}:get:Game:note-${i}.json`];
+    }),
+    `${(t0 + 8 * BEAT).toFixed(3)}:quit`,
+  ]),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(notes.length, 8, "bars 1 and 2 hold eight notes");
+    for (let i = 0; i < notes.length; i++) {
+      const g = game(run, `note-${i}.json`) as unknown as { lastOffsetMs: number; lastJudgement: number; judged: number };
+      t.equal(g.judged, i + 1, `note ${i} was judged`);
+      t.near(g.lastOffsetMs, offsets[i]!, 0.1, `note ${i}'s error is the press's ${offsets[i]} ms`);
+      t.equal(g.lastJudgement, expected[i], `note ${i} at ${offsets[i]} ms is ${expected[i] === 0 ? "Perfect" : "Great"}`);
+    }
+  },
+});