@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/tower-defense/tests/lib.ts

@@ -0,0 +1,81 @@
+// Shared readers for Path Guard's playtests. `get:Game:<file>` writes the
+// round's resource, the state the game's `facts` (src/main.ts) report to the
+// probe; `dump_entity:<name>:<file>` one row; `dump_platform` the calls to
+// og.platform.
+import type { PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Game {
+  phase: number;
+  paused: boolean;
+  settingsOpen: boolean;
+  won: boolean;
+  rounds: number;
+  lives: number;
+  gold: number;
+  wave: number;
+  inWave: boolean;
+  walking: number;
+  kills: number;
+  leaks: number;
+  placed: number;
+  refused: number;
+  refusal: number;
+  shots: number;
+  selected: number;
+  cursorX: number;
+  cursorY: number;
+  score: number;
+  best: number;
+  newBest: boolean;
+  bestRevision: number;
+}
+
+/** Phase.* and Refusal.* of src/components.ts. */
+export const TITLE = 0;
+export const PLAY = 1;
+export const OVER = 2;
+export const POOR = 1;
+export const BLOCKED = 2;
+export const TAKEN = 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;
+}
+
+/** One component of a dumped entity. */
+export function component<T>(run: PlaytestRun, file: string, name: string): T {
+  const c = run.json<{ components: Record<string, unknown> }>(file).components[name];
+  if (!c) throw new Error(`${file} has no ${name}`);
+  return c as T;
+}
+
+export interface PlatformDump {
+  host: string;
+  calls: Array<{ method: string; args: Record<string, unknown>; tick: number; state: string; result?: { ok: boolean; data: Record<string, unknown> } }>;
+}
+
+/** 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`;
+
+/** Play on the title: the round starts on the release. */
+export const play = (t: number) => tap("play", t);
+
+/**
+ * A cell's centre in CSS pixels on the 1280×720 desktop surface: src/ui.ts
+ * frames the 9 × 13 field in the room the HUD leaves (76 px above, 24
+ * below, 200 each side), 46.27 px a cell.
+ */
+export function cellPx(x: number, y: number): string {
+  const scale = Math.min(880 / 9.4, 620 / 13.4);
+  const camY = 6.5 + (386 - 360) / scale;
+  const sx = 640 + (x + 0.5 - 4.5) * scale;
+  const sy = 360 - (12.5 - y - camY) * scale;
+  return `${sx.toFixed(1)},${sy.toFixed(1)}`;
+}
+
+/** A tap on a lawn cell (desktop). */
+export const tapCell = (x: number, y: number, t: number) => `${t}:touch_move:${cellPx(x, y)};${(t + 0.017).toFixed(3)}:touch_start;${(t + 0.05).toFixed(3)}:touch_end`;

package/archetypes/tower-defense/tests/lose.og.ts

@@ -0,0 +1,40 @@
+// The failure path: no plants, the light set to two. The first visitors
+// walk the open lawn to the doorstep; each takes its light with a shake, a
+// hit stop and a red number; the light at 0 ends the round on the end card
+// ("The lantern went out"), and Play again starts a fresh round.
+import { playtest } from "@origingame/engine/playtest";
+import { game, OVER, PLAY, play, tap } from "./lib.ts";
+
+export default playtest({
+  name: "unguarded, visitors reach the doorstep, the lantern goes out, the end card offers another round",
+  commands: [
+    "0.1:set:Tuning.startLives=2",
+    play(0.3),
+    "1.0:get:Game:start.json",
+    "15.0:get:Game:over.json",
+    "15.0:get:og.TimeScale:time.json",
+    "16.6:screenshot:lost.png",
+    tap("Retry", 17.0),
+    "17.8:get:Game:again.json",
+    "17.9:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const start = game(run, "start.json");
+    t.equal(start.phase, PLAY, "the round started");
+    t.equal(start.lives, 2, "with the tuned light");
+    const over = game(run, "over.json");
+    t.equal(over.phase, OVER, "the light ran out: the round is over");
+    t.equal(over.won, false, "lost");
+    t.equal(over.lives, 0, "no light left");
+    t.ok(over.leaks >= 2, `${over.leaks} visitors reached the doorstep`);
+    t.equal(over.kills, 0, "nothing was turned away");
+    t.equal(run.json<{ value: { scale: number } }>("time.json").value.scale, 1, "the end card leaves the time scale at 1");
+    t.frame("lost.png", () => t.equal(run.png("lost.png").width, 1280, "the end card was captured"));
+    const again = game(run, "again.json");
+    t.equal(again.phase, PLAY, "Play again started another round");
+    t.equal(again.rounds, 2, "the second round");
+    t.equal(again.lives, 2, "with the light back");
+    t.equal(again.leaks, 0, "and the count cleared");
+  },
+});

package/archetypes/tower-defense/tests/maze.og.ts

@@ -0,0 +1,53 @@
+// The maze and its refusals: a row of hedges across the lawn leaves one
+// gap, and the flow field takes the visitors through it; a hedge in the gap
+// would close the path, so it is refused and costs nothing; so are a plant
+// on a stone or on another plant, and one the purse cannot pay for.
+import { playtest } from "@origingame/engine/playtest";
+import { BLOCKED, game, POOR, TAKEN } from "./lib.ts";
+
+const ROW = [1, 2, 3, 4, 5, 6].map((x) => `0.5:plant:hedge:${x}:2`).join(";");
+// The first visitor's position, every tenth of a second while it crosses the hedge row.
+const SAMPLES = Array.from({ length: 40 }, (_, k) => +(4.0 + k * 0.1).toFixed(1));
+
+export default playtest({
+  name: "hedges route the visitors through the gap; a closed path, a stone, a taken cell and an empty purse are refused",
+  commands: [
+    "0.3:begin",
+    "0.4:gold:200",
+    ROW,
+    "0.6:get:Game:row.json",
+    "0.7:plant:hedge:7:2",
+    "0.8:get:Game:closed.json",
+    "0.9:plant:thorn:2:3",
+    "1.0:get:Game:stone.json",
+    "1.1:plant:thorn:3:2",
+    "1.2:get:Game:taken.json",
+    "1.3:gold:20",
+    "1.4:plant:frost:5:6",
+    "1.5:get:Game:poor.json",
+    "1.6:screenshot:maze.png",
+    ...SAMPLES.map((t, k) => `${t}:get:visitor-0.og.Transform.position:p${k}.json`),
+    "8.1:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const row = game(run, "row.json");
+    t.equal(row.placed, 6, "six hedges across row 2, the gap at column 7");
+    t.equal(row.gold, 200 - 60, "ten coins each");
+    const closed = game(run, "closed.json");
+    t.equal(closed.refusal, BLOCKED, "a hedge in the gap would close the path: refused");
+    t.equal(closed.placed, 6, "and not set");
+    t.equal(closed.gold, row.gold, "and not paid for");
+    t.equal(game(run, "stone.json").refusal, TAKEN, "a stone takes no plant");
+    t.equal(game(run, "taken.json").refusal, TAKEN, "a hedge's cell takes no other plant");
+    const poor = game(run, "poor.json");
+    t.equal(poor.refusal, POOR, "twenty coins do not buy a frost lily");
+    t.equal(poor.refused, 4, "four refusals in all");
+    // Row 2 spans y 9.5–10.5 in the world; the gap is column 7 (x 7–8).
+    const at = SAMPLES.map((_, k) => run.json<{ value: number[] }>(`p${k}.json`).value);
+    const crossing = at.filter((p) => p[1]! > 9.6 && p[1]! < 10.4);
+    t.ok(crossing.length > 0, `the first visitor crossed the hedge row (${crossing.length} samples on it)`);
+    t.ok(crossing.every((p) => p[0]! > 6.8), `through the gap only (x ${crossing.map((p) => p[0]!.toFixed(2)).join(", ")})`);
+    t.ok(at.at(-1)![1]! < 9.5, `and walked on below it (y ${at.at(-1)![1]!.toFixed(2)})`);
+  },
+});

package/archetypes/tower-defense/tests/pad.og.ts

@@ -0,0 +1,41 @@
+// A gamepad alone: the d-pad and A start from the title, the d-pad walks
+// the cursor, A sets a plant, X picks the next plant, Y calls the wave,
+// Start pauses and B resumes.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY } from "./lib.ts";
+
+export default playtest({
+  name: "the d-pad, A, X, Y, Start and B play a round",
+  commands: [
+    // The title's first item holds the focus when the menu opens (og-ui §4): A plays at once.
+    "0.4:gamepad:a",
+    "1.2:get:Game:started.json",
+    "1.3:gamepad:up",
+    "1.4:gamepad:left",
+    "1.5:gamepad:a",
+    "1.6:gamepad:x",
+    "1.7:gamepad:right",
+    "1.8:gamepad:a",
+    "1.9:get:Game:planted.json",
+    "2.0:gamepad:y",
+    "2.2:get:Game:called.json",
+    "2.3:gamepad:start",
+    "2.5:get:Game:paused.json",
+    "2.6:gamepad:b",
+    "2.9:get:Game:resumed.json",
+    "3.0:gamepad:off",
+    "3.1: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 started a round from the title");
+    const planted = game(run, "planted.json");
+    t.equal(planted.placed, 2, "A set two plants");
+    t.equal(planted.selected, 1, "X picked the frost lily");
+    t.ok(planted.cursorX === 4 && planted.cursorY === 8, `the d-pad walked the cursor to (4, 8) (${planted.cursorX}, ${planted.cursorY})`);
+    t.equal(planted.gold, 150 - 50 - 70, "a thorn and a frost lily paid for");
+    t.equal(game(run, "called.json").wave, 1, "Y called the first wave");
+    t.equal(game(run, "paused.json").paused, true, "Start paused");
+    t.equal(game(run, "resumed.json").paused, false, "B resumed");
+  },
+});

package/archetypes/tower-defense/tests/pause.og.ts

@@ -0,0 +1,59 @@
+// Pause and settings: Escape holds the garden (time scale 0, the visitors
+// stop), the pause menu opens Settings, 简体中文 switches every string, the
+// music slider moves, Done saves the settings through og.platform, and
+// Resume lets the garden go again in the chosen language.
+import { playtest } from "@origingame/engine/playtest";
+import { component, game, type PlatformDump, play, press, tap } from "./lib.ts";
+
+export default playtest({
+  name: "Escape pauses, settings switch the language and save, Resume runs the garden again",
+  commands: [
+    play(0.3),
+    "4.4:dump_entity:visitor-0:moving.json",
+    press("Escape", 4.5),
+    "4.7:get:Game:paused.json",
+    "4.7:get:og.TimeScale.scale:scale.json",
+    "4.7:dump_entity:visitor-0:held-a.json",
+    "5.2:dump_entity:visitor-0:held-b.json",
+    "5.3:screenshot:pause.png",
+    tap("settings", 5.4),
+    "6.0:move_to_text:简体中文",
+    "6.02:touch_start",
+    "6.05:touch_end",
+    "6.3:touch_move_to:Music/Slider",
+    "6.32:touch_start",
+    "6.35:touch_end",
+    "6.8:screenshot:settings-zh.png",
+    tap("Done", 7.0),
+    "7.5:get:Prefs:prefs.json",
+    "7.5:dump_platform:platform.json",
+    "7.6:screenshot:pause-zh.png",
+    tap("resume", 7.8),
+    "8.4:get:Game:resumed.json",
+    "8.4:dump_entity:visitor-0:again-a.json",
+    "8.6:dump_entity:visitor-0:again-b.json",
+    "8.7:screenshot:play-zh.png",
+    "8.8:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const pos = (f: string) => component<{ position: number[] }>(run, f, "og.Transform").position;
+    t.equal(game(run, "paused.json").paused, true, "Escape paused the round");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "the garden holds: time scale 0");
+    t.equal(pos("held-b.json")[1], pos("held-a.json")[1], "the visitor stands still 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");
+    const resumed = game(run, "resumed.json");
+    t.equal(resumed.paused, false, "Resume closed the pause menu");
+    t.ok(pos("again-b.json")[1]! < pos("again-a.json")[1]!, "the visitor walks again");
+    t.frame(["pause.png", "settings-zh.png", "pause-zh.png", "play-zh.png"], () => {
+      for (const f of ["pause.png", "settings-zh.png", "pause-zh.png", "play-zh.png"]) t.equal(run.png(f).width, 1280, `${f} captured`);
+    });
+    t.ok(pos("moving.json")[1]! < 12.5, "a visitor was on the lawn before the pause");
+  },
+});

package/archetypes/tower-defense/tests/phone.og.ts

@@ -0,0 +1,49 @@
+// A phone in portrait (390 × 844 CSS px at 3×, a notch and a home
+// indicator): the title and the HUD lay out for it, the tray runs along
+// the bottom inside the safe area with touch-sized buttons, and a tap on
+// a tray button picks its plant.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY, play, tap } from "./lib.ts";
+
+interface Ui {
+  surface: { width: number; height: number; dpr: number } | null;
+  elements: Array<{ id: string; parent: string; kind?: string; text: string; x: number; y: number; width: number; height: number }>;
+}
+
+export default playtest({
+  name: "the phone layout: title, HUD and a bottom tray of touch-sized buttons inside the safe area",
+  size: "1170x2532",
+  commands: [
+    "0.05:viewport:phone",
+    "0.4:screenshot:title.png",
+    play(0.5),
+    "1.3:plant:thorn:3:5",
+    tap("Plant#2/Pick", 1.4),
+    // A finger lifts away: nothing hovers on a touch screen.
+    "1.5:touch_move:195,400",
+    "1.7:get:Game:picked.json",
+    "1.8:screenshot:play.png",
+    "1.8:dump_ui:ui.json",
+    "1.9:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const picked = game(run, "picked.json");
+    t.equal(picked.phase, PLAY, "a tap on Play started the round");
+    t.equal(picked.selected, 2, "a tap on the tray picked the hedge");
+    const ui = run.json<Ui>("ui.json");
+    t.equal(ui.surface?.width, 390, "the UI lays out at 390 CSS px");
+    const picks = ui.elements.filter((e) => e.id === "Pick");
+    t.equal(picks.length, 3, "three tray buttons");
+    for (const p of picks) {
+      t.ok(p.height >= 44, `${p.text}: ${p.height} px tall, a touch target`);
+      t.ok(p.y + p.height <= 844 - 34, `${p.text} sits above the home indicator`);
+      t.ok(p.y > 844 / 2, `${p.text} is in the bottom half, the thumb's`);
+    }
+    const pause = ui.elements.find((e) => e.id === "Pause");
+    t.ok(pause !== undefined && pause.y >= 47, "the pause button sits below the notch");
+    t.frame(["title.png", "play.png"], () => {
+      for (const f of ["title.png", "play.png"]) t.equal(run.png(f).height, 2532, `${f} is a phone frame`);
+    });
+  },
+});

package/archetypes/tower-defense/tests/replay.og.ts

@@ -0,0 +1,28 @@
+// Determinism: a round with plants by tap and keys, two waves called early,
+// shots, frost, pops and a leak, run twice in fresh processes, ends on the
+// same world hash.
+import { playtest } from "@origingame/engine/playtest";
+import { game, play, press, tapCell } from "./lib.ts";
+
+export default playtest({
+  name: "a round with plants, shots, pops and frost replays to the same hash",
+  runs: 2,
+  commands: [
+    play(0.3),
+    tapCell(3, 4, 1.2),
+    press("Digit2", 1.4),
+    press("ArrowRight", 1.5),
+    press("ArrowRight", 1.6),
+    press("Space", 1.7),
+    press("KeyN", 1.9),
+    "9.0:get:Game:end.json",
+    "9.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.shots > 0 && end.kills > 0, `the round had shots (${end.shots}) and pops (${end.kills})`);
+  },
+});

package/archetypes/tower-defense/tests/win.og.ts

@@ -0,0 +1,58 @@
+// The round held to the end: a stand of thorns and frost lilies at the
+// gate, the last wave called early with N (its bonus paid), every visitor
+// turned away; the end card lands with its stars and score, the score is
+// saved as the best (a store write at the revision read on tick 0,
+// whose answer moves the revision on for the next one),
+// submitted to the board and filed as telemetry; Title goes back.
+import { playtest } from "@origingame/engine/playtest";
+import { game, OVER, type PlatformDump, press, tap, TITLE } from "./lib.ts";
+
+const STAND = ["thorn:3:2", "thorn:5:2", "frost:4:3", "thorn:2:4", "thorn:6:4", "frost:3:5", "frost:5:5", "thorn:4:7", "thorn:2:7", "thorn:6:7"].map((p) => `0.5:plant:${p}`).join(";");
+
+export default playtest({
+  name: "a strong stand holds the last wave, the end card shows the win, the best is saved and submitted",
+  commands: [
+    "0.1:set:Tuning.spawnGap=0.5",
+    "0.3:begin",
+    "0.4:gold:2000",
+    STAND,
+    "0.6:wave:5",
+    "0.7:get:Game:before.json",
+    press("KeyN", 1.0),
+    "1.2:get:Game:called.json",
+    "22.0:get:Game:won.json",
+    "23.0:screenshot:won.png",
+    "23.1:dump_platform:platform.json",
+    tap("Menu", 23.5),
+    "24.4:get:Game:title.json",
+    "24.5:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const before = game(run, "before.json");
+    t.equal(before.placed, 10, "ten plants in the stand");
+    const called = game(run, "called.json");
+    t.equal(called.wave, 5, "N called the last wave at once");
+    t.ok(called.inWave, "and it is under way");
+    const won = game(run, "won.json");
+    t.equal(won.phase, OVER, "the round is over");
+    t.equal(won.won, true, "won");
+    t.equal(won.leaks, 0, "nobody reached the doorstep");
+    t.equal(won.kills, 18, "all eighteen visitors of the last wave turned away");
+    t.equal(won.score, won.kills * 10 + won.lives * 50 + won.gold, "the score: kills × 10 + light × 50 + coins");
+    t.ok(won.newBest && won.best === won.score, "a new best");
+    const p = run.json<PlatformDump>("platform.json");
+    const of = (m: string) => p.calls.filter((c) => c.method === m);
+    const read = of("store.get").find((c) => c.args["key"] === "best");
+    t.ok(read?.tick === 0 && read.result?.data["value"] === null, "tick 0 read `best` from the store (never written)");
+    const set = of("store.set")[0];
+    t.equal(set?.args["value"], won.score, "the best was written");
+    t.equal(set?.args["revision"], 0, "at the revision read (never written before)");
+    t.equal(set?.result?.data["revision"], 1, "its first revision");
+    t.equal(of("leaderboard.submit")[0]?.args["score"], won.score, "the score went to the board");
+    t.equal(of("telemetry")[0]?.args["name"], "round.over", "a round.over event was filed");
+    const title = game(run, "title.json");
+    t.equal(title.phase, TITLE, "Title went back to the title");
+    t.equal(title.bestRevision, 1, "the write's answer moved the revision on, so the next best is written at 1 and not refused as stale");
+  },
+});