@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/third-person/tests/flow.og.ts

@@ -0,0 +1,70 @@
+// The core loop through real input: Set out on the title starts a run at
+// the south end of the vale with three hearts, no beacon lit and the clock
+// at half past three; W walks the hero north on the character controller,
+// Shift runs, and on into the lake it wades (slower, splashing). Then by
+// the first beacon the prompt shows, holding F kindles it: the right hand
+// reaches into the bowl (og.IkChain, solved within its tolerance) and after
+// Tuning.kindleSeconds the beacon catches, the HUD counts it and says so.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY, position, tap, texts, TITLE, value } from "./lib.ts";
+
+export default playtest({
+  name: "Set out, walk, run and wade on the terrain, kindle a beacon with the hand in the bowl",
+  commands: [
+    "0.3:get:Game:title.json",
+    tap("play", 0.5),
+    "0.7:get:Game:started.json",
+    "0.7:get:hero.og.Transform:start.json",
+    "0.8:key_down:KeyW",
+    "1.8:get:Game:walk.json",
+    "1.9:key_down:ShiftLeft",
+    "2.9:get:Game:run.json",
+    "7.6:get:Game:wade.json",
+    "7.6:get:hero.og.Transform:wade-at.json",
+    "7.7:key_up:ShiftLeft",
+    "7.7:key_up:KeyW",
+    "7.8:warp:0",
+    "8.1:get:Game:near.json",
+    "8.1:dump_ui:prompt.json",
+    "8.2:key_down:KeyF",
+    "9.3:get:hero-reach.og.IkChain:reach.json",
+    "9.3:get:Game:kindling.json",
+    "10.4:key_up:KeyF",
+    "10.5:get:Game:lit.json",
+    "10.5:get:beacon-0.Beacon:beacon.json",
+    "10.5:dump_ui:lit-ui.json",
+    "10.6:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    t.equal(game(run, "title.json").phase, TITLE, "the game opens on the title");
+    const started = game(run, "started.json");
+    t.equal(started.phase, PLAY, "Set out started a run");
+    t.ok(started.hearts === 3 && started.lit === 0 && started.runs === 1, "with three hearts, no beacon lit, the first run");
+    t.ok(started.hour >= 15.5 && started.hour < 15.6, `at half past three (${started.hour.toFixed(2)})`);
+    const walk = game(run, "walk.json");
+    t.ok(walk.grounded && Math.abs(walk.speed - 3) < 0.1, `W walks on the ground at the walk speed (${walk.speed.toFixed(2)} m/s)`);
+    t.ok(Math.abs(game(run, "run.json").speed - 6) < 0.1, "Shift runs at the run speed");
+    const wade = game(run, "wade.json");
+    t.ok(wade.wading, "on into the lake the hero wades");
+    t.ok(Math.abs(wade.speed - 6 * 0.45) < 0.15, `slowed to Tuning.wade of a run (${wade.speed.toFixed(2)} m/s)`);
+    t.ok(wade.splashes >= 1, `and splashes (${wade.splashes})`);
+    const [, , z0] = position(run, "start.json");
+    const [x1, , z1] = position(run, "wade-at.json");
+    t.ok(z0 - z1 > 20 && Math.abs(x1) < 0.5, `the hero went north across the terrain (z ${z0.toFixed(1)} → ${z1.toFixed(1)})`);
+    t.equal(game(run, "near.json").near, 0, "by the first beacon it is within reach");
+    t.ok(texts(run, "prompt.json").includes("Hold F to kindle the beacon"), "and the prompt says how to kindle it");
+    const k = game(run, "kindling.json");
+    t.ok(k.kindling && k.kindle > 0.5, `holding F kindles it (${k.kindle.toFixed(2)} s)`);
+    const reach = value<{ reached: boolean; error: number; weight: number }>(run, "reach.json");
+    t.ok(reach.weight > 0.9, `the arm's IK chain is on (weight ${reach.weight.toFixed(2)})`);
+    t.ok(reach.reached && reach.error <= 0.02, `the hand reached into the bowl (${(reach.error * 100).toFixed(1)} cm off)`);
+    const lit = game(run, "lit.json");
+    t.ok(lit.lit === 1 && lit.litMask === 1, "the beacon caught");
+    const b = value<{ lit: boolean; litAt: number }>(run, "beacon.json");
+    t.ok(b.lit && b.litAt - k.time > 0 && b.litAt < k.time + 1.6, `after Tuning.kindleSeconds of kindling (at ${b.litAt.toFixed(2)} s)`);
+    const words = texts(run, "lit-ui.json");
+    t.ok(words.includes("1/4") && words.includes("Beacon 1 of 4 burns"), "the HUD counts it and says so");
+  },
+});

package/archetypes/third-person/tests/frames.og.ts

@@ -0,0 +1,35 @@
+// Three frames at 1280×720 compared with references/<tier>/: the title over
+// the vale at late afternoon, the first beacon just lit with the hero's
+// hand in the bowl (fire, smoke, the ember burst, its light, the toast),
+// and the dawn summary once the other beacons' toasts have gone (the last
+// beacon raises none). `OG_FX_CAPTURE=1 og test .` records this tier's
+// references.
+import { playtest } from "@origingame/engine/playtest";
+import { checkFrames } from "./frames.ts";
+
+const FILES = ["title.png", "beacon.png", "dawn.png"];
+
+export default playtest({
+  name: "the title, a beacon catching and the dawn summary match their reference frames",
+  size: "1280x720",
+  commands: [
+    "0.9:screenshot:title.png",
+    "1.0:run",
+    "1.1:warp:0",
+    "1.3:key_down:KeyF",
+    "3.4:screenshot:beacon.png",
+    "3.5:key_up:KeyF",
+    "3.6:light:1",
+    "3.7:light:2",
+    "3.8:light:3",
+    "7.2:screenshot:dawn.png",
+    "7.3:quit",
+  ].join(";"),
+  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/third-person/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/third-person/tests/hitstop.og.ts

@@ -0,0 +1,26 @@
+// A pause pressed during a hit-stop: a grab freezes scaled time
+// (og.time.hitStop, here held 20 ticks), and Escape pressed inside that
+// freeze still pauses the run.
+import { playtest } from "@origingame/engine/playtest";
+import { game, press } from "./lib.ts";
+
+export default playtest({
+  name: "Escape pressed during a grab's hit-stop pauses the run",
+  commands: [
+    "0.3:run",
+    "0.4:set:Tuning.hitStop=20",
+    "0.5:warp:-27:13.2",
+    "0.6:grab:0",
+    press("Escape", 0.65),
+    "1.0:get:Game:after.json",
+    "1.0:get:og.TimeScale.scale:scale.json",
+    "1.1:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const g = game(run, "after.json");
+    t.equal(g.hearts, 2, "the west sentinel's grab landed (the hit-stop ran)");
+    t.equal(g.paused, true, "Escape inside the hit-stop paused the run");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "and the run holds: time scale 0");
+  },
+});

package/archetypes/third-person/tests/lib.ts

@@ -0,0 +1,87 @@
+// Shared readers for Ember Vale's playtests. `get:Game:<file>` writes the
+// run's resource, the state the game's `facts` (src/main.ts) report to the
+// probe; `get:<entity>.<component>:<file>` one component of a named row;
+// `dump_ui:<file>` the laid-out interface; `dump_platform:<file>` the calls
+// to og.platform.
+import type { PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Game {
+  phase: number;
+  ending: number;
+  paused: boolean;
+  settingsOpen: boolean;
+  runs: number;
+  wins: number;
+  best: number;
+  recordConflicts: number;
+  newBest: boolean;
+  hearts: number;
+  hurts: number;
+  lit: number;
+  litMask: number;
+  time: number;
+  hour: number;
+  near: number;
+  kindle: number;
+  kindling: boolean;
+  wading: boolean;
+  grounded: boolean;
+  speed: number;
+  jumps: number;
+  splashes: number;
+  grabs: number;
+  alarms: number;
+  language: number;
+}
+
+/** Phase.* and Ending.* of src/components.ts. */
+export const TITLE = 0;
+export const PLAY = 1;
+export const OVER = 2;
+export const DAWN = 1;
+export const NIGHT = 2;
+export const CAUGHT = 3;
+
+/** The summary's buttons answer once its entrance has played (about 1.6 s after the run ends). */
+export const SUMMARY_READY = 1.7;
+
+/** The Game resource from a `get:Game:<file>` step. */
+export function game(run: PlaytestRun, file: string): Game {
+  return run.json<{ value: Game }>(file).value;
+}
+
+/** The value of a `get:<target>:<file>` step. */
+export function value<T>(run: PlaytestRun, file: string): T {
+  return run.json<{ value: T }>(file).value;
+}
+
+/** A position from a `get:<entity>.og.Transform:<file>` step. */
+export function position(run: PlaytestRun, file: string): [number, number, number] {
+  return value<{ position: [number, number, number] }>(run, file).position;
+}
+
+export interface PlatformDump {
+  host: string;
+  calls: Array<{ method: string; args: Record<string, unknown>; tick: number; state: string; result?: { ok: boolean; data?: Record<string, unknown>; error?: { code: string } } }>;
+}
+
+export interface Element { id: string; parent: string; kind: string; text: string; x: number; y: number; width: number; height: number }
+
+/** The laid-out elements from a `dump_ui:<file>` step. */
+export function elements(run: PlaytestRun, file: string): Element[] {
+  return run.json<{ elements: Element[] }>(file).elements;
+}
+
+/** The UI's labels from a `dump_ui:<file>` step. */
+export function texts(run: PlaytestRun, file: string): string[] {
+  return elements(run, file).filter((e) => e.kind === "label" && e.text !== "").map((e) => e.text);
+}
+
+/** A key pressed at t (down, then up two ticks later). */
+export const press = (key: string, t: number) => `${t}:key_down:${key};${(t + 0.034).toFixed(3)}:key_up:${key}`;
+
+/** A key held from t for `seconds`. */
+export const hold = (key: string, t: number, seconds: number) => `${t}:key_down:${key};${(t + seconds).toFixed(3)}:key_up:${key}`;
+
+/** 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/third-person/tests/lose.og.ts

@@ -0,0 +1,44 @@
+// The two losses and the way back: the last heart gone ends the run caught
+// (the summary with the skull); Again starts afresh; the clock run to
+// Tuning.duskSeconds brings night (the vale goes dark, the summary says
+// night took it); Title goes back to the title, the vale reset behind it.
+import { playtest } from "@origingame/engine/playtest";
+import { CAUGHT, game, NIGHT, OVER, PLAY, SUMMARY_READY, tap, texts, TITLE } from "./lib.ts";
+
+export default playtest({
+  name: "caught with no hearts left, night at dusk's end, Again and Title",
+  commands: [
+    "0.3:run",
+    "0.5:hearts:0",
+    "0.6:get:Game:caught.json",
+    "2.3:get:Game:caught-over.json",
+    "2.6:dump_ui:caught-ui.json",
+    tap("Again", 2.1 + SUMMARY_READY),
+    "4.1:get:Game:again.json",
+    "4.2:dusk:149.6",
+    "4.7:get:Game:night.json",
+    "6.4:get:Game:night-over.json",
+    "6.7:dump_ui:night-ui.json",
+    tap("Menu", 6.2 + SUMMARY_READY),
+    "8.6:get:Game:title.json",
+    "8.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(game(run, "caught.json").ending, CAUGHT, "no hearts left: caught");
+    const co = game(run, "caught-over.json");
+    t.equal(co.phase, OVER, "the summary after a beat");
+    t.ok(texts(run, "caught-ui.json").includes("The sentinels caught you"), "it says the sentinels caught you");
+    const again = game(run, "again.json");
+    t.ok(again.phase === PLAY && again.hearts === 3 && again.ending === 0 && again.time < 0.5, "Again started a fresh run");
+    const night = game(run, "night.json");
+    t.equal(night.ending, NIGHT, "dusk's end brings night");
+    t.ok(night.hour >= 19.5, `at half past seven (${night.hour.toFixed(2)})`);
+    t.equal(game(run, "night-over.json").phase, OVER, "the summary after a beat");
+    const words = texts(run, "night-ui.json");
+    t.ok(words.includes("Night took the vale") && words.includes("0/4"), "it says night took the vale, no beacon lit");
+    const title = game(run, "title.json");
+    t.equal(title.phase, TITLE, "Title went back to the title");
+    t.ok(title.hour > 16 && title.hour < 17, "where the vale is in late afternoon again");
+  },
+});

package/archetypes/third-person/tests/pause.og.ts

@@ -0,0 +1,64 @@
+// Pause and settings: Escape holds the run (time scale 0, the clock stops,
+// W moves nothing), the pause menu opens Settings, 简体中文 switches every
+// string, the music slider moves, Done saves the settings through
+// og.platform, and Resume gives the run back, in the chosen language.
+import { playtest } from "@origingame/engine/playtest";
+import { game, type PlatformDump, position, press, tap, texts } from "./lib.ts";
+
+export default playtest({
+  name: "Escape pauses, settings switch the language and save, Resume gives the run back",
+  commands: [
+    "0.3:run",
+    press("Escape", 0.8),
+    "1.0:get:Game:paused.json",
+    "1.0:get:og.TimeScale.scale:scale.json",
+    "1.0:get:hero.og.Transform:before.json",
+    "1.05:key_down:KeyW",
+    "1.6:key_up:KeyW",
+    "1.7:get:Game:held.json",
+    "1.7:get:hero.og.Transform:after.json",
+    "1.75:screenshot:pause.png",
+    tap("settings", 1.8),
+    "2.4:move_to_text:简体中文",
+    "2.42:touch_start",
+    "2.45:touch_end",
+    "2.7:touch_move_to:Music/Slider",
+    "2.72:touch_start",
+    "2.75:touch_end",
+    "3.2:screenshot:settings-zh.png",
+    tap("Done", 3.4),
+    "3.9:get:Prefs:prefs.json",
+    "3.9:dump_platform:platform.json",
+    tap("resume", 4.0),
+    "4.3:warp:0",
+    "4.8:dump_ui:play-zh.json",
+    "5.0:get:Game:resumed.json",
+    "5.1:screenshot:play-zh.png",
+    "5.2:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const paused = game(run, "paused.json");
+    t.equal(paused.paused, true, "Escape paused the run");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "the run holds: time scale 0");
+    const held = game(run, "held.json");
+    t.equal(held.time, paused.time, "the clock stopped");
+    const [bx, , bz] = position(run, "before.json");
+    const [ax, , az] = position(run, "after.json");
+    t.ok(Math.hypot(ax - bx, az - bz) < 1e-3, "W while paused moves nothing");
+    const prefs = run.json<{ value: { language: number; music: number; saves: number } }>("prefs.json").value;
+    t.equal(prefs.language, 1, "简体中文 was chosen");
+    t.ok(prefs.music < 0.7, `the music slider moved (${prefs.music.toFixed(2)})`);
+    t.equal(prefs.saves, 1, "Done saved once");
+    const p = run.json<PlatformDump>("platform.json");
+    const saved = p.calls.find((c) => c.method === "store.set" && c.args["key"] === "og.settings");
+    t.equal((saved?.args["value"] as { language?: string } | undefined)?.language, "zh-CN", "the settings went to og.platform with the language");
+    t.ok(texts(run, "play-zh.json").includes("按住 F 点燃烽火"), "the HUD speaks 简体中文");
+    const resumed = game(run, "resumed.json");
+    t.equal(resumed.paused, false, "Resume closed the pause menu");
+    t.ok(resumed.time > held.time + 0.5, "and the clock runs again");
+    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/third-person/tests/phone.og.ts

@@ -0,0 +1,65 @@
+// The phone layout (390×844 at 3×, a notch and a home bar): the title's
+// menu inside the safe area with the touch footer; the HUD in it too, the
+// hearts, the beacons, the clock and Pause along the top and the joystick,
+// Kindle and Jump along the bottom, all touch-sized. The joystick walks
+// the hero, Jump jumps, and holding Kindle by a beacon lights it.
+import { playtest } from "@origingame/engine/playtest";
+import { elements, game, PLAY, position, tap, texts } from "./lib.ts";
+
+export default playtest({
+  name: "the phone layout: a HUD inside the safe area, a joystick that walks, Jump and Kindle",
+  size: "1170x2532",
+  commands: [
+    "0.1:viewport:phone",
+    "0.9:dump_ui:title.json",
+    tap("play", 1.0),
+    "1.1:touch_move:200,400",
+    "1.7:get:Game:started.json",
+    "1.7:get:hero.og.Transform:from.json",
+    "1.8:dump_ui:hud.json",
+    "1.9:touch_move_to:Stick",
+    "1.92:touch_start",
+    "2.0:touch_move:86,664",
+    "2.5:get:Game:walking.json",
+    "3.0:touch_end",
+    "3.0:get:hero.og.Transform:to.json",
+    tap("Jump", 3.3),
+    "3.5:get:Game:jumped.json",
+    "4.4:warp:0",
+    "4.6:touch_move_to:Kindle",
+    "4.62:touch_start",
+    "6.6:touch_end",
+    "6.7:get:Game:lit.json",
+    "6.75:screenshot:play.png",
+    "6.8:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const title = elements(run, "title.json");
+    t.ok(title.some((e) => e.id === "play") && title.every((e) => e.y + e.height <= 844 - 34 && e.y >= 47), "the title's menu sits inside the safe area");
+    t.ok(texts(run, "title.json").includes("The stick moves · Jump jumps · hold Kindle by a beacon · the view swings behind you"), "with the touch controls in its footer");
+    t.equal(game(run, "started.json").phase, PLAY, "a tap on Set out started a run");
+    const ui = run.json<{ surface: { width: number } }>("hud.json");
+    const hud = elements(run, "hud.json");
+    const el = (id: string) => hud.find((e) => e.id === id);
+    t.equal(ui.surface.width, 390, "laid out for a 390 px wide phone");
+    for (const id of ["Hearts", "Beacons", "Clock", "Pause"]) t.ok((el(id)?.y ?? 0) >= 47, `${id} sits below the notch`);
+    for (const id of ["Stick", "Kindle", "Jump"]) {
+      const e = el(id);
+      t.ok(e !== undefined && e.y + e.height <= 844 - 34, `${id} sits above the home bar`);
+    }
+    for (const id of ["Pause", "Stick", "Kindle", "Jump"]) {
+      const e = el(id);
+      t.ok(e !== undefined && e.width >= 44 && e.height >= 44, `${id} is at least 44 px square (${e?.width}×${e?.height})`);
+    }
+    t.ok(hud.every((e) => e.x >= 0 && e.x + e.width <= 390), "nothing runs off the sides");
+    t.ok(game(run, "walking.json").speed > 2, "the joystick pushed up walks the hero");
+    const [, , z0] = position(run, "from.json");
+    const [, , z1] = position(run, "to.json");
+    t.ok(z0 - z1 > 1.5, `north, away from the camera (${(z0 - z1).toFixed(2)} m)`);
+    const jumped = game(run, "jumped.json");
+    t.ok(jumped.jumps === 1 && !jumped.grounded, "Jump jumped");
+    t.equal(game(run, "lit.json").lit, 1, "holding Kindle by a beacon lit it");
+    t.frame("play.png", () => t.equal(run.png("play.png").width, 1170, "play.png captured at the phone's device pixels"));
+  },
+});

package/archetypes/third-person/tests/replay.og.ts

@@ -0,0 +1,32 @@
+// Determinism: a run with walking, running, a jump, a beacon kindled and
+// a sentinel's chase and grab (the character controller, the animation
+// graph and IK, og.nav and og.ai), run twice in fresh processes, ends on
+// the same world hash.
+import { playtest } from "@origingame/engine/playtest";
+import { game, press, tap } from "./lib.ts";
+
+export default playtest({
+  name: "a run with movement, a jump, kindling and a sentinel's grab replays to the same hash",
+  runs: 2,
+  commands: [
+    tap("play", 0.7),
+    "1.0:key_down:KeyW",
+    "1.2:key_down:ShiftLeft",
+    press("Space", 1.6),
+    "2.2:key_up:ShiftLeft",
+    "2.4:key_up:KeyW",
+    "2.5:warp:0",
+    "2.7:key_down:KeyF",
+    "4.6:key_up:KeyF",
+    "4.7:warp:-29.5:1",
+    "8.0:get:Game:end.json",
+    "8.1:quit",
+  ].join(";"),
+  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.jumps === 1 && end.lit === 1 && end.grabs >= 1, `the run jumped, lit a beacon and was grabbed (${end.jumps}, ${end.lit}, ${end.grabs})`);
+  },
+});

package/archetypes/third-person/tests/restart.og.ts

@@ -0,0 +1,28 @@
+// A new run calms the sentinels: one chasing the hero when the run
+// restarts goes back to its round in `patrol` (its machine started afresh)
+// instead of searching where it last saw the hero.
+import { playtest } from "@origingame/engine/playtest";
+import { value } from "./lib.ts";
+
+interface Agent { state: number }
+interface Sentinel { alert: boolean }
+
+export default playtest({
+  name: "a sentinel chasing when the run restarts is back on patrol",
+  commands: [
+    "0.3:run",
+    "2.6:warp:-28.5:3",
+    "3.25:get:sentinel-0.og.AiAgent:chasing.json",
+    "3.3:run",
+    "3.6:get:sentinel-0.og.AiAgent:restarted.json",
+    "3.6:get:sentinel-0.Sentinel:calm.json",
+    "3.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const chasing = value<Agent>(run, "chasing.json").state;
+    t.ok(chasing === 1 || chasing === 2, `the west sentinel saw the hero and left its patrol (state ${chasing})`);
+    t.equal(value<Agent>(run, "restarted.json").state, 0, "after the restart it patrols (state 0), not searching");
+    t.equal(value<Sentinel>(run, "calm.json").alert, false, "and its eye is calm");
+  },
+});

package/archetypes/third-person/tests/sentinels.og.ts

@@ -0,0 +1,48 @@
+// The sentinels on the navmesh: the west one walks its round (og.NavAgent
+// moving it at the patrol speed); the hero standing ahead on its round raises
+// its alarm (og.ai's behaviour enters `alert` and commands `alarm`), its
+// eye burns red and it chases; within reach its grab costs a heart, throws
+// the hero back and spares it a moment (no second grab while spared).
+import { playtest } from "@origingame/engine/playtest";
+import { game, position, value } from "./lib.ts";
+
+interface Sentinel { alarms: number; grabs: number; alert: boolean; speed: number }
+
+export default playtest({
+  name: "a sentinel on its round sees the hero, raises the alarm, chases and grabs a heart",
+  commands: [
+    "0.3:run",
+    "2.0:get:sentinel-0.og.Transform:round-a.json",
+    "2.5:get:sentinel-0.og.Transform:round-b.json",
+    "2.5:get:sentinel-0.Sentinel:calm.json",
+    "2.6:warp:-28.5:3",
+    "3.2:get:Game:seen.json",
+    "3.2:get:sentinel-0.Sentinel:alert.json",
+    "3.2:get:sentinel-0-eye.og.PointLight:eye.json",
+    "3.25:screenshot:alarm.png",
+    "7.6:get:Game:grabbed.json",
+    "7.6:get:sentinel-0.Sentinel:grabber.json",
+    "7.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const [ax, , az] = position(run, "round-a.json");
+    const [bx, , bz] = position(run, "round-b.json");
+    const walked = Math.hypot(bx - ax, bz - az);
+    t.ok(walked > 0.4 && walked < 1.2, `the west sentinel walks its round at the patrol pace (${walked.toFixed(2)} m in 0.5 s, after its first wait)`);
+    const calm = value<Sentinel>(run, "calm.json");
+    t.ok(!calm.alert && calm.alarms === 0, "calm while the hero is far");
+    const seen = game(run, "seen.json");
+    const alert = value<Sentinel>(run, "alert.json");
+    t.ok(alert.alert && alert.alarms === 1 && seen.alarms >= 1, "the hero in its sight: the alarm, and it gives chase");
+    t.ok(value<{ intensity: number }>(run, "eye.json").intensity > 5, "its eye burns red");
+    const grabbed = game(run, "grabbed.json");
+    const grabber = value<Sentinel>(run, "grabber.json");
+    t.ok(grabber.grabs >= 1, `it caught the hero (${grabber.grabs} grabs)`);
+    t.equal(grabbed.hearts, 3 - grabbed.grabs, `each grab cost a heart (${grabbed.hearts} left)`);
+    t.equal(grabbed.hurts, grabbed.grabs, "and counts as a heart lost");
+    t.ok(grabbed.grabs <= 2, `spared a moment after each grab: at most two in 4.4 s (${grabbed.grabs})`);
+    t.equal(grabbed.phase, 1, "the run goes on with hearts left");
+    t.frame("alarm.png", () => t.equal(run.png("alarm.png").width, 1280, "alarm.png captured"));
+  },
+});