@origingame/create-game 0.0.0-stage → 0.1.1

package/archetypes/roguelike/tests/lib.ts

@@ -0,0 +1,83 @@
+// Shared readers for Lamp Dive's playtests. `get:Game:<file>` writes the
+// dive's resource, the state the game's `facts` (src/main.ts) report to the
+// probe; `get:Foes:<file>` where each foe stands; `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;
+  dives: number;
+  relics: number;
+  recordConflicts: number;
+  seed: number;
+  floor: number;
+  deepest: number;
+  hp: number;
+  hpMax: number;
+  attack: number;
+  armour: number;
+  lamp: number;
+  potions: number;
+  gold: number;
+  kills: number;
+  hits: number;
+  hurts: number;
+  finds: number;
+  turns: number;
+  heroX: number;
+  heroY: number;
+  stairsX: number;
+  stairsY: number;
+  won: boolean;
+  killedBy: number;
+  lit: number;
+  seen: number;
+  language: number;
+}
+
+/** Phase.* and FoeKind.* of src/components.ts. */
+export const TITLE = 0;
+export const PLAY = 1;
+export const OVER = 2;
+export const RAT = 0;
+export const SKELETON = 1;
+export const GUARDIAN = 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;
+}
+
+/** Foe slot i's cell from a `get:Foes:<file>` step ([-1, -1] when it is down). */
+export function foe(run: PlaytestRun, file: string, i: number): [number, number] {
+  const v = run.json<{ value: Record<string, number> }>(file).value;
+  return [v[`x${i}`]!, v[`y${i}`]!];
+}
+
+/** 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>; error?: { code: string } } }>;
+}
+
+/** The UI's labels from a `dump_ui:<file>` step. */
+export function texts(run: PlaytestRun, file: string): string[] {
+  return run.json<{ elements: Array<{ text: string; kind: string }> }>(file).elements.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}`;
+
+/** Keys pressed one after another, a turn (0.25 s) apart from t. */
+export const presses = (keys: string[], t: number) => keys.map((k, i) => press(k, +(t + i * 0.25).toFixed(3))).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/roguelike/tests/lose.og.ts

@@ -0,0 +1,44 @@
+// Permadeath: a lamp-bearer of three health and a blade found waits by a
+// rat until the lamp goes out; a beat later the summary says how and how
+// deep; Dive again starts from nothing (a new seed, floor 1, the blade
+// gone, no kills).
+import { playtest } from "@origingame/engine/playtest";
+import { game, OVER, PLAY, presses, RAT, tap, texts } from "./lib.ts";
+
+export default playtest({
+  name: "the lamp goes out: the summary, and the next dive starts from nothing",
+  commands: [
+    "0.2:set:Tuning.heroHp=3",
+    "0.3:dive:7",
+    "0.4:give:blade",
+    "0.5:warp:5:7",
+    "0.6:get:Game:armed.json",
+    presses(["Space", "Space", "Space"], 0.7),
+    "1.75:get:Game:out.json",
+    "3.0:get:Game:over.json",
+    "3.0:dump_ui:summary.json",
+    "3.05:screenshot:lost.png",
+    tap("Again", 3.2),
+    "3.6:get:Game:again.json",
+    "3.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.equal(game(run, "armed.json").attack, 4, "the blade raised the strike to 4");
+    const out = game(run, "out.json");
+    t.equal(out.hp, 0, "the rat put the lamp out");
+    t.equal(out.killedBy, RAT, "the summary will name the rat");
+    t.equal(out.phase, PLAY, "the summary waits a beat");
+    const over = game(run, "over.json");
+    t.equal(over.phase, OVER, "then the summary");
+    const words = texts(run, "summary.json");
+    t.ok(words.includes("The lamp went out on floor 1"), "it says where the lamp went out");
+    t.ok(words.includes("a tomb rat"), "and what put it out");
+    t.ok(words.includes("Dives 1 · relics 0"), "and the record");
+    const again = game(run, "again.json");
+    t.equal(again.phase, PLAY, "Dive again started a new dive");
+    t.ok(again.seed !== over.seed, `on a new seed (${over.seed} → ${again.seed})`);
+    t.ok(again.floor === 1 && again.hp === 3 && again.attack === 3 && again.kills === 0 && again.turns === 0, "from nothing: floor 1, full health, the blade gone, no kills, no turns");
+    t.equal(again.dives, 2, "the record counts the second dive");
+  },
+});

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

@@ -0,0 +1,54 @@
+// A gamepad alone: the d-pad and A start from the title, the d-pad walks
+// (a held direction repeats, into the rats of the corridor), A waits a
+// turn, X drinks and, the flask empty, is refused; 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: "the d-pad, A, X, Start and B play a dive",
+  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", 0.4),
+    "1.0:get:Game:started.json",
+    "1.1:dive:7",
+    pad("up", 1.3),
+    pad("up", 1.6),
+    "1.9:get:Game:stepped.json",
+    "2.0:gamepad:up",
+    "3.0:gamepad:off",
+    "3.3:get:Game:held.json",
+    pad("a", 3.4),
+    "3.7:get:Game:waited.json",
+    pad("x", 3.8),
+    "4.1:get:Game:drank.json",
+    pad("x", 4.2),
+    "4.4:get:Game:refused.json",
+    pad("start", 4.5),
+    "4.7:get:Game:paused.json",
+    pad("b", 4.8),
+    "5.1:get:Game:resumed.json",
+    "5.2:gamepad:off",
+    "5.3: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 dive from the title");
+    const stepped = game(run, "stepped.json");
+    t.equal(`${stepped.heroX},${stepped.heroY}`, "4,13", "two d-pad presses walked two cells up");
+    const held = game(run, "held.json");
+    t.ok(held.turns >= 4, `a d-pad held for a second kept walking (${held.turns} turns)`);
+    const waited = game(run, "waited.json");
+    t.equal(waited.turns, held.turns + 1, "A waited a turn");
+    t.equal(`${waited.heroX},${waited.heroY}`, `${held.heroX},${held.heroY}`, "in place");
+    const drank = game(run, "drank.json");
+    t.ok(drank.potions === 0 && drank.turns === waited.turns + 1, "X drank the draught, a turn");
+    const refused = game(run, "refused.json");
+    t.equal(refused.turns, drank.turns, "X with the flask empty was refused: no turn spent");
+    t.equal(game(run, "paused.json").paused, true, "Start paused");
+    t.equal(game(run, "resumed.json").paused, false, "B resumed");
+  },
+});

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

@@ -0,0 +1,59 @@
+// Pause and settings: Escape holds the dive (time scale 0, a step key does
+// nothing), the pause menu opens Settings, 简体中文 switches every string,
+// the music slider moves, Done saves the settings through og.platform, and
+// Resume gives the turn back, in the chosen language.
+import { playtest } from "@origingame/engine/playtest";
+import { game, type PlatformDump, press, tap, texts } from "./lib.ts";
+
+export default playtest({
+  name: "Escape pauses, settings switch the language and save, Resume gives the turn back",
+  commands: [
+    "0.3:dive:7",
+    press("ArrowUp", 0.6),
+    press("Escape", 1.0),
+    "1.2:get:Game:paused.json",
+    "1.2:get:og.TimeScale.scale:scale.json",
+    press("ArrowUp", 1.3),
+    "1.6:get:Game:held.json",
+    "1.7: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.6:dump_ui:play-zh.json",
+    press("ArrowUp", 4.7),
+    "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 dive");
+    t.equal(paused.turns, 1, "after one step");
+    t.equal(run.json<{ value: number }>("scale.json").value, 0, "the dive holds: time scale 0");
+    t.equal(game(run, "held.json").turns, 1, "a step key while paused takes no turn");
+    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("第 1/2 层"), "the HUD speaks 简体中文");
+    const resumed = game(run, "resumed.json");
+    t.equal(resumed.paused, false, "Resume closed the pause menu");
+    t.equal(resumed.turns, 2, "and the next step takes a turn");
+    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/roguelike/tests/phone.og.ts

@@ -0,0 +1,54 @@
+// The phone layout (390×844 at 3×, a notch and a home bar): the title's
+// menu inside the safe area; the HUD in it too, with health, the floor and
+// Pause along the top and the draught, Wait and a d-pad of touch-sized
+// buttons along the bottom; the d-pad steps and Wait waits.
+import { playtest } from "@origingame/engine/playtest";
+import { game, PLAY, tap } from "./lib.ts";
+
+interface Element { id: string; parent: string; kind: string; x: number; y: number; width: number; height: number }
+
+export default playtest({
+  name: "the phone layout: a HUD inside the safe area and a d-pad that steps",
+  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",
+    "1.8:dump_ui:hud.json",
+    tap("Pad/Up", 1.9),
+    "2.0:touch_move:10,400",
+    "2.3:get:Game:up.json",
+    tap("Wait", 2.4),
+    "2.5:touch_move:10,400",
+    "2.8:get:Game:waited.json",
+    "2.9:screenshot:play.png",
+    "3.0:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const started = game(run, "started.json");
+    t.equal(started.phase, PLAY, "a tap on Dive started a dive");
+    const ui = run.json<{ surface: { width: number; height: number }; elements: Element[] }>("hud.json");
+    const el = (id: string) => ui.elements.find((e) => e.id === id);
+    t.equal(ui.surface.width, 390, "laid out for a 390 px wide phone");
+    for (const id of ["Health", "Floor", "Pause"]) t.ok((el(id)?.y ?? 0) >= 47, `${id} sits below the notch`);
+    for (const id of ["Drink", "Wait", "Down"]) {
+      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", "Drink", "Wait", "Up", "Down", "Left", "Right"]) {
+      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(ui.elements.every((e) => e.x >= 0 && e.x + e.width <= 390), "nothing runs off the sides");
+    const up = game(run, "up.json");
+    t.equal(up.turns, started.turns + 1, "the d-pad's Up took a turn");
+    t.equal(up.heroY, started.heroY - 1, "a step up");
+    t.equal(game(run, "waited.json").turns, up.turns + 1, "Wait waited a turn");
+    const title = run.json<{ elements: Element[] }>("title.json").elements;
+    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.frame("play.png", () => t.equal(run.png("play.png").width, 1170, "play.png captured at the phone's device pixels"));
+  },
+});

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

@@ -0,0 +1,24 @@
+// Determinism: a dive on the seed Dive picks, walked, fought and drunk
+// through, run twice in fresh processes, ends on the same world hash, and
+// the floor it carved is the same both times.
+import { playtest } from "@origingame/engine/playtest";
+import { game, press, presses, tap } from "./lib.ts";
+
+export default playtest({
+  name: "a dive with steps, strikes and the foes' turns replays to the same hash",
+  runs: 2,
+  commands: [
+    tap("play", 0.3),
+    presses(["ArrowUp", "ArrowRight", "ArrowRight", "ArrowDown", "ArrowLeft", "ArrowUp", "ArrowUp", "Space", "ArrowRight", "ArrowRight"], 0.9),
+    press("KeyQ", 3.5),
+    "4.0:get:Game:end.json",
+    "4.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.turns >= 5, `the dive took turns (${end.turns})`);
+  },
+});

package/archetypes/roguelike/tests/win.og.ts

@@ -0,0 +1,60 @@
+// The whole dive's end: seed 7's stairs at (23, 11) take the lamp-bearer
+// to floor 2 (the foes left behind take no turn); the moss-faced guardian
+// stands before the relic at (24, 14), glows red and shows "!" the turn
+// before its charged strike; felled, the relic is taken, and the summary
+// shows the win. Meanwhile another device wrote the dive record, so the
+// end's write is refused as stale, read again and merged (this dive's
+// relic added to the other device's counts).
+import { playtest } from "@origingame/engine/playtest";
+import { foe, game, OVER, type PlatformDump, press, presses, tap, texts } from "./lib.ts";
+
+export default playtest({
+  name: "down the stairs, past the guardian, the relic, a merged record and the summary",
+  commands: [
+    "0.3:dive:7",
+    "0.5:warp:23:10",
+    "0.6:get:Game:above.json",
+    press("ArrowDown", 0.7),
+    "1.0:get:Game:below.json",
+    "1.0:get:Foes:below-foes.json",
+    "1.1:warp:22:14",
+    "1.15:stale_record",
+    presses(Array(8).fill("ArrowRight"), 1.3),
+    "3.9:get:Game:relic.json",
+    "5.0:get:Game:over.json",
+    "5.0:dump_ui:summary.json",
+    "5.0:dump_platform:platform.json",
+    "5.05:screenshot:won.png",
+    tap("Menu", 5.2),
+    "5.8:get:Game:menu.json",
+    "5.9:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const above = game(run, "above.json");
+    t.equal(`${above.stairsX},${above.stairsY}`, "23,11", "seed 7's stairs are at (23, 11)");
+    const below = game(run, "below.json");
+    t.equal(below.floor, 2, "the stairs took the lamp-bearer down");
+    t.equal(below.deepest, 2, "the deepest floor is 2");
+    t.equal(below.hurts, 0, "the foes left behind took no turn");
+    t.equal(foe(run, "below-foes.json", 9).join(","), "23,14", "floor 2's guardian stands before the relic");
+    const relic = game(run, "relic.json");
+    t.ok(relic.won, "the relic was taken");
+    t.ok(relic.kills >= 1 && relic.hits >= 5, `after the guardian fell (${relic.hits} strikes)`);
+    t.ok(relic.hurts >= 1, `it struck back (${relic.hurts} times)`);
+    t.ok(relic.hp > 0, `and the lamp still burns (${relic.hp})`);
+    const over = game(run, "over.json");
+    t.equal(over.phase, OVER, "the summary came");
+    t.equal(over.recordConflicts, 1, "the record write was refused once as stale");
+    t.ok(over.dives === 7 && over.relics === 3, `and merged: the other device's 7 dives and 2 relics, plus this relic (${over.dives}, ${over.relics})`);
+    const words = texts(run, "summary.json");
+    t.ok(words.includes("The relic is yours"), "the summary shows the win");
+    t.ok(words.includes("Dives 7 · relics 3"), "and the merged record");
+    const p = run.json<PlatformDump>("platform.json");
+    const writes = p.calls.filter((c) => c.method === "store.set" && c.args["key"] === "record");
+    const last = writes[writes.length - 1];
+    t.equal(JSON.stringify(last?.args["value"]), JSON.stringify({ dives: 7, relics: 3 }), "the merge was written");
+    t.equal(last?.result?.ok, true, "at the revision read again");
+    t.equal(game(run, "menu.json").phase, 0, "Title went back to the title");
+  },
+});