@origingame/create-game 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,74 @@
+// Shared readers for Spark Orb's playtests. `get:Game:<file>` writes the
+// run's resource, the state the game's `facts` (src/main.ts) report to the
+// probe; `dump_ui` the screen's elements and their text; `dump_platform`
+// the calls to og.platform.
+import type { PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Game {
+  phase: number;
+  paused: boolean;
+  held: boolean;
+  confirmNova: boolean;
+  welcome: boolean;
+  sparks: number;
+  runEarned: number;
+  lifetime: number;
+  owned0: number;
+  owned1: number;
+  owned2: number;
+  owned3: number;
+  dust: number;
+  novas: number;
+  lastGain: number;
+  rate: number;
+  tapValue: number;
+  taps: number;
+  buys: number;
+  refused: number;
+  selected: number;
+  away: number;
+  offline: number;
+  saves: number;
+  saveConflicts: number;
+  loaded: boolean;
+  language: number;
+}
+
+/** Phase.* of src/components.ts. */
+export const TITLE = 0;
+export const PLAY = 1;
+export const NOVA = 2;
+
+/** 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 }
+
+/** The UI's elements from a `dump_ui:<file>` step. */
+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 whose parent is `parent` (any parent when omitted). */
+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 {
+  host: string;
+  calls: Array<{ method: string; args: Record<string, unknown>; tick: number; state: string; result?: { ok: boolean; data?: Record<string, unknown>; error?: { code: string } } }>;
+}
+
+/** 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 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`;
+
+/** A tap at a CSS pixel. */
+export const tapAt = (x: number, y: number, t: number) => `${t}:touch_move:${x},${y};${(t + 0.017).toFixed(3)}:touch_start;${(t + 0.05).toFixed(3)}:touch_end`;
+
+/** The orb's centre on the 1280×720 desktop surface (src/ui.ts: 10 m tall, the orb at y 0.35 m). */
+export const ORB = { x: 640, y: 360 - 0.35 * 72 } as const;

package/archetypes/idle/tests/milestone.og.ts

@@ -0,0 +1,32 @@
+// Milestones and big numbers: the tenth Storm doubles what storms make
+// (a burst from its card, a fanfare, "Storm ×2!"); the wallet shows 1.23M
+// as "1.23M" and the rate in the same words; a supernova's stardust makes
+// everything 10 % stronger each.
+import { playtest } from "@origingame/engine/playtest";
+import { game, press, text } from "./lib.ts";
+
+export default playtest({
+  name: "the tenth of a kind doubles it; big numbers read 1.23M",
+  commands: [
+    "0.3:play",
+    "0.9:own:1:9",
+    "1.0:get:Game:nine.json",
+    "1.1:sparks:1234567",
+    press("Digit2", 1.2),
+    "1.35:get:Game:ten.json",
+    "1.4:dump_ui:ui.json",
+    "1.45:screenshot:milestone.png",
+    "1.5:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const nine = game(run, "nine.json");
+    t.equal(nine.rate, 36, "nine storms make 36 a second (4 each)");
+    const ten = game(run, "ten.json");
+    t.equal(ten.owned1, 10, "2 bought the tenth");
+    t.equal(ten.rate, 80, "ten storms make twice 40: 80 a second");
+    t.equal(text(run, "ui.json", "Amount", "Sparks"), `${(ten.sparks / 1e6).toFixed(2)}M`, `the wallet reads ${text(run, "ui.json", "Amount", "Sparks")}`);
+    t.equal(text(run, "ui.json", "Rate"), "+80 a second", "the rate reads +80 a second");
+    t.equal(text(run, "ui.json", "Owned", "Head"), "×0", "the first card counts its embers");
+  },
+});

package/archetypes/idle/tests/nova.og.ts

@@ -0,0 +1,52 @@
+// The supernova and its card (the run's end): with 300,000 sparks made
+// this run, N asks; Not yet keeps everything; the HUD's Supernova and
+// Collapse burst the orb: sparks and generators gone, one stardust, the
+// card with the run's sparks, time and the stardust; Ignite again starts
+// the next run, every rate 10 % stronger.
+import { playtest } from "@origingame/engine/playtest";
+import { game, NOVA, PLAY, press, tap, text } from "./lib.ts";
+
+export default playtest({
+  name: "a supernova: asked, declined, collapsed, the run's card, the next run stronger",
+  commands: [
+    "0.3:play",
+    "0.9:own:0:5",
+    "1.0:sparks:300000",
+    press("KeyN", 1.1),
+    "1.4:get:Game:asked.json",
+    tap("Later", 1.5),
+    "1.8:get:Game:declined.json",
+    tap("Nova/Supernova", 1.9),
+    "2.3:dump_ui:confirm.json",
+    tap("Collapse", 2.4),
+    "2.55:get:Game:collapsed.json",
+    "3.3:dump_ui:card.json",
+    "3.35:screenshot:card.png",
+    tap("Again", 3.5),
+    "4.2:sparks:15",
+    press("Digit1", 4.3),
+    "4.5:get:Game:next.json",
+    "4.6:dump_platform:platform.json",
+    "4.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(game(run, "asked.json").confirmNova, true, "N asked");
+    const declined = game(run, "declined.json");
+    t.ok(!declined.confirmNova && declined.owned0 === 5 && declined.dust === 0, "Not yet kept everything");
+    t.ok(text(run, "confirm.json", "Body")?.includes("1 stardust") ?? false, "the question says what it gives");
+    const c = game(run, "collapsed.json");
+    t.equal(c.phase, NOVA, "Collapse ended the run");
+    t.equal(c.dust, 1, "one stardust (the square root of 3)");
+    t.ok(c.sparks === 0 && c.owned0 === 0 && c.runEarned === 0, "sparks and generators gone");
+    t.equal(text(run, "card.json", "Value", "Made"), "300K", "the card shows the run's sparks");
+    t.equal(text(run, "card.json", "Value", "Gain"), "+1", "and the stardust gained");
+    t.equal(text(run, "card.json", "Value", "Bonus"), "+10%", "and what it is worth");
+    const next = game(run, "next.json");
+    t.equal(next.phase, PLAY, "Ignite again started the next run");
+    t.ok(Math.abs(next.rate - 0.55) < 1e-6, `an ember now makes 0.55 a second (${next.rate})`);
+    const p = run.json<{ calls: Array<{ method: string; args: Record<string, unknown> }> }>("platform.json");
+    t.ok(p.calls.some((x) => x.method === "telemetry" && x.args["name"] === "orb.nova"), "the supernova was reported");
+    t.ok(p.calls.some((x) => x.method === "store.set" && (x.args["value"] as { dust?: number } | undefined)?.dust === 1), "and saved at once");
+  },
+});

package/archetypes/idle/tests/offline.og.ts

@@ -0,0 +1,60 @@
+// The save and the time away: Escape saves through og.platform's store;
+// the game closes and opens two hours later (`relaunch:7200`, the host's
+// time away); the title offers Continue; the welcome back says how long
+// and how much (half the rate for the time away) and Collect closes it
+// with the sparks added. Another device then writes a save with more
+// progress: this one's next write is refused as stale, read again, and
+// the other's progress kept and written back.
+import { playtest } from "@origingame/engine/playtest";
+import { game, type PlatformDump, press, tap, text, TITLE } from "./lib.ts";
+
+export default playtest({
+  name: "the save, two hours away credited at half the rate, a stale write merged",
+  commands: [
+    "0.3:play",
+    "0.9:own:0:10",
+    "0.9:own:1:2",
+    "1.0:sparks:500",
+    press("Escape", 1.2),
+    "1.5:get:Game:saved.json",
+    "1.6:relaunch:7200",
+    "1.8:get:Game:closed.json",
+    "2.2:dump_ui:title.json",
+    tap("play", 2.3),
+    "3.2:get:Game:welcome.json",
+    "3.2:dump_ui:welcome-ui.json",
+    "3.25:screenshot:welcome.png",
+    tap("Collect", 3.3),
+    "3.6:get:Game:collected.json",
+    "3.7:stale_save",
+    press("Escape", 3.8),
+    "4.3:get:Game:merged.json",
+    "4.3:dump_platform:platform.json",
+    "4.4:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const saved = game(run, "saved.json");
+    t.equal(saved.saves, 1, "Escape saved");
+    t.equal(saved.rate, 10 * 0.5 * 2 + 2 * 4, "ten embers (doubled) and two storms: 18 a second");
+    const closed = game(run, "closed.json");
+    t.equal(closed.phase, TITLE, "the relaunch opens on the title");
+    t.ok(text(run, "title.json", "play")?.startsWith("Continue") ?? false, "which offers Continue");
+    const w = game(run, "welcome.json");
+    t.equal(w.owned0, 10, "the save came back");
+    t.ok(Math.abs(w.offline - 18 * 0.5 * 7200) < 1e-6, `two hours away at half of 18 a second: 64,800 (${w.offline})`);
+    t.equal(w.welcome, true, "the welcome back is up");
+    t.equal(text(run, "welcome-ui.json", "Body"), "While you were away (2 h 0 min) the orb made 64.8K sparks.", "and says how long and how much");
+    const c = game(run, "collected.json");
+    t.equal(c.welcome, false, "Collect closed it");
+    t.ok(c.sparks >= saved.sparks + 64800, `the sparks were added (${c.sparks.toFixed(0)})`);
+    const m = game(run, "merged.json");
+    t.equal(m.saveConflicts, 1, "the write after the other device's was refused as stale");
+    t.ok(m.dust === 3 && m.owned0 === 20 && m.lifetime === 1e9, "the save with more progress (the other device's) was kept");
+    const p = run.json<PlatformDump>("platform.json");
+    const writes = p.calls.filter((x) => x.method === "store.set" && x.args["key"] === "orb");
+    const last = writes[writes.length - 1];
+    t.equal((last?.args["value"] as { lifetime?: number } | undefined)?.lifetime, 1e9, "and written back");
+    t.equal(last?.result?.ok, true, "at the revision read again");
+  },
+});

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

@@ -0,0 +1,55 @@
+// A gamepad alone: A on the title plays, A taps the orb, the d-pad's right
+// chooses the next generator, X buys the chosen one (refused when too
+// dear), Y asks for the supernova, Start pauses and B resumes.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY } from "./lib.ts";
+
+/** 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}:gamepad:${button};${(t + 0.05).toFixed(2)}:gamepad:off`;
+
+export default playtest({
+  name: "A, the d-pad, X, Y, Start and B play the orb",
+  commands: [
+    // 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.9:get:Game:started.json",
+    pad("a", 2.0),
+    pad("a", 2.1),
+    pad("a", 2.2),
+    "2.4:get:Game:tapped.json",
+    "2.5:sparks:200",
+    pad("right", 2.6),
+    pad("x", 2.7),
+    "2.9:get:Game:bought.json",
+    pad("right", 3.0),
+    pad("right", 3.1),
+    pad("x", 3.2),
+    "3.4:get:Game:refused.json",
+    "3.5:sparks:300000",
+    pad("y", 3.6),
+    "3.8:get:Game:asked.json",
+    pad("b", 3.9),
+    "4.1:get:Game:declined.json",
+    pad("start", 4.2),
+    "4.4:get:Game:paused.json",
+    pad("b", 4.5),
+    "4.8:get:Game:resumed.json",
+    "4.9:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(game(run, "started.json").phase, PLAY, "the pad played from the title");
+    t.equal(game(run, "tapped.json").taps, 3, "A tapped the orb three times");
+    const bought = game(run, "bought.json");
+    t.equal(bought.selected, 1, "right chose the Storm");
+    t.equal(bought.owned1, 1, "X bought it");
+    t.equal(bought.sparks < 200 - 109, true, "for 110");
+    const refused = game(run, "refused.json");
+    t.equal(refused.selected, 3, "right twice more chose the Star");
+    t.ok(refused.refused === 1 && refused.owned3 === 0, "X was refused: a Star costs 13,000");
+    t.equal(game(run, "asked.json").confirmNova, true, "Y asked for the supernova");
+    t.equal(game(run, "declined.json").confirmNova, false, "B declined it");
+    t.equal(game(run, "paused.json").paused, true, "Start paused");
+    t.equal(game(run, "resumed.json").paused, false, "B resumed");
+  },
+});

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

@@ -0,0 +1,68 @@
+// Pause and settings: Escape holds the orb (time scale 0, the embers make
+// nothing); Settings switch to 简体中文 and move the music; Done saves the
+// settings through og.platform; Resume lets the orb make sparks again; the
+// numbers now read in the Chinese units (万, 亿); Escape pauses again and
+// Quit goes back to the title, writing the save once more there.
+import { playtest } from "@origingame/engine/playtest";
+import { game, type PlatformDump, press, tap, text, TITLE } from "./lib.ts";
+
+export default playtest({
+  name: "Escape pauses, settings switch to 简体中文 and save, numbers read in 万 and 亿",
+  commands: [
+    "0.3:play",
+    "0.9:own:0:4",
+    "1.0:sparks:123456789",
+    press("Escape", 1.2),
+    "1.4:get:Game:paused.json",
+    "1.4:get:og.TimeScale.scale:scale.json",
+    "1.9:get:Game:held.json",
+    "2.0:screenshot:pause.png",
+    tap("settings", 2.1),
+    "2.7:move_to_text:简体中文",
+    "2.72:touch_start",
+    "2.75:touch_end",
+    "3.0:touch_move_to:Music/Slider",
+    "3.02:touch_start",
+    "3.05:touch_end",
+    "3.4:screenshot:settings-zh.png",
+    tap("Done", 3.6),
+    "4.0:get:Prefs:prefs.json",
+    "4.0:dump_platform:platform.json",
+    tap("resume", 4.1),
+    "4.8:dump_ui:play-zh.json",
+    "4.8:get:Game:resumed.json",
+    "4.85:screenshot:play-zh.png",
+    "5.4:get:Game:running.json",
+    press("Escape", 5.5),
+    "6.0:get:Game:repaused.json",
+    tap("quit", 6.2),
+    "6.8:get:Game:quit.json",
+    "6.9: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");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "the orb holds: time scale 0");
+    t.equal(game(run, "held.json").sparks, paused.sparks, "the embers made nothing while paused");
+    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.equal(text(run, "play-zh.json", "Amount", "Sparks"), "1.23亿", "123,456,789 reads 1.23亿");
+    t.equal(text(run, "play-zh.json", "Rate"), "每秒 +2", "the rate reads 每秒 +2");
+    t.equal(text(run, "play-zh.json", "Name", "Head"), "余烬", "the first card is 余烬");
+    t.equal(game(run, "resumed.json").paused, false, "Resume closed the pause menu");
+    t.ok(game(run, "running.json").sparks > game(run, "resumed.json").sparks, "and the embers make sparks again");
+    const repaused = game(run, "repaused.json");
+    const quit = game(run, "quit.json");
+    t.equal(quit.phase, TITLE, "Quit went back to the title");
+    t.equal(quit.saves, repaused.saves + 1, "and wrote the save there, after the pause's");
+    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/idle/tests/phone.og.ts

@@ -0,0 +1,50 @@
+// The phone layout (390×844 at 3×, a notch and a home bar): the title's
+// menu, then the wallet and Pause below the notch, the four generators
+// along the bottom above the home bar with touch-sized buttons, the orb
+// above them taking a finger's tap, and a card's button buying.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY, tap, tapAt, type UiElement, ui } from "./lib.ts";
+
+/** The orb's centre on the phone (src/ui.ts: 7.4 m across, the orb at y 1.4 m). */
+const ORB = { x: 195, y: 422 - 1.4 * (390 / 7.4) };
+
+export default playtest({
+  name: "the phone layout: a HUD inside the safe area, the orb tapped, a card bought",
+  size: "1170x2532",
+  commands: [
+    "0.1:viewport:phone",
+    "0.9:dump_ui:title.json",
+    tap("play", 1.0),
+    "1.1:touch_move:10,400",
+    "1.7:get:Game:started.json",
+    tapAt(ORB.x, ORB.y, 1.8),
+    tapAt(ORB.x + 20, ORB.y - 10, 1.9),
+    "2.1:get:Game:tapped.json",
+    "2.2:sparks:100",
+    tap("Shop/Gen#0/Buy", 2.3),
+    "2.4:touch_move:10,400",
+    "2.6:get:Game:bought.json",
+    "2.7:dump_ui:hud.json",
+    "2.75:screenshot:play.png",
+    "2.8:quit",
+  ].join(";"),
+  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");
+    t.equal(game(run, "started.json").phase, PLAY, "a tap on Play showed the orb");
+    t.equal(game(run, "tapped.json").taps, 2, "two taps on the orb");
+    t.equal(game(run, "bought.json").owned0, 1, "the Ember card's button bought one");
+    const hud = ui(run, "hud.json");
+    const el = (id: string, parent?: string): UiElement | undefined => hud.elements.find((e) => e.id === id && (parent === undefined || e.parent === parent));
+    t.equal(hud.surface.width, 390, "laid out for a 390 px wide phone");
+    for (const id of ["Wallet", "Corner"]) t.ok((el(id)?.y ?? 0) >= 47, `${id} sits below the notch`);
+    const shop = el("Shop");
+    t.ok(shop !== undefined && shop.y + shop.height <= 844 - 34 && shop.x >= 0 && shop.x + shop.width <= 390, "the generators sit above the home bar, inside the width");
+    const buys = hud.elements.filter((e) => e.id === "Buy");
+    t.equal(buys.length, 4, "four generator buttons");
+    t.ok(buys.every((e) => e.width >= 44 && e.height >= 44), "each at least 44 px square");
+    t.ok(shop !== undefined && ORB.y < shop.y - 80, "the orb sits well above them");
+    t.frame("play.png", () => t.equal(run.png("play.png").width, 1170, "play.png captured at the phone's device pixels"));
+  },
+});

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

@@ -0,0 +1,28 @@
+// Determinism: a run with taps, purchases, a milestone and the motes
+// circling, run twice in fresh processes, ends on the same world hash.
+import { playtest } from "@origingame/engine/playtest";
+import { game, ORB, press, tap, tapAt } from "./lib.ts";
+
+export default playtest({
+  name: "a run with taps, purchases and a milestone replays to the same hash",
+  runs: 2,
+  commands: [
+    tap("play", 0.3),
+    ...Array.from({ length: 8 }, (_, i) => tapAt(ORB.x, ORB.y, +(0.9 + i * 0.1).toFixed(2))),
+    "1.8:sparks:400",
+    press("Digit1", 1.9),
+    press("Digit1", 2.0),
+    press("Digit2", 2.1),
+    "2.2:own:0:9",
+    press("Digit1", 2.3),
+    "3.5:get:Game:end.json",
+    "3.6: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.taps === 8 && end.owned0 === 10, `the run had its taps (${end.taps}) and a milestone (${end.owned0} embers)`);
+  },
+});