@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/topdown/tests/door.og.ts

@@ -0,0 +1,62 @@
+// The door: without the key the doorway's wall cells block the hero; the
+// key is picked up by walking over it; with it the door opens on approach
+// (og.tilemap.setTile clears the wall terrain's cells, re-tiling their
+// neighbours and dropping their colliders), the key is spent, and the hero
+// walks through into the east room.
+import { playtest } from "@origingame/engine/playtest";
+import { hold, MAP, position, report } from "./lib.ts";
+
+interface Camera {
+  zoneActive: boolean;
+  zoneMin: number[];
+  zoneFromActive: boolean;
+  zoneFromMax: number[];
+  zoneScroll: number;
+}
+
+export default playtest({
+  name: "the doorway blocks until the key, then opens and leads into room 2",
+  commands: [
+    "0.1:slime:35:3",
+    "0.2:place:17.5:6",
+    hold("KeyD", 0.2, 1.0),
+    "1.1:dump_entity:hero:locked.json",
+    // The key at (16.5, 2.5).
+    "1.2:place:15.2:2.3",
+    hold("KeyD", 1.2, 1.6),
+    "1.7:dump_entity:hero:key.json",
+    "1.8:place:17.5:6",
+    hold("KeyD", 1.8, 3.2),
+    // The camera across the doorway: og.Camera's zone fields every 0.05 s.
+    Array.from({ length: 25 }, (_, i) => `${(2 + 0.05 * i).toFixed(2)}:get:og.Camera:cam-${String(i).padStart(2, "0")}.json`).join(";"),
+    "3.3:dump_entity:hero:through.json",
+    "3.3:screenshot:door.png",
+    "3.4:quit",
+  ]
+    .flatMap((s) => s.split(";"))
+    // Steps run in time order (a stable sort keeps the order within a time).
+    .sort((a, b) => parseFloat(a) - parseFloat(b))
+    .join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const locked = report(run, "locked.json");
+    t.equal(locked.doorOpen, false, "the door stays shut without the key");
+    t.ok(locked.doorWall >= 0, `the doorway's cell draws the wall terrain's auto-tiled tile (${locked.doorWall})`);
+    t.near(position(run, "locked.json").x, 19 - 0.3, 0.03, "the doorway's wall stops the hero");
+    t.equal(locked.room, 1, "still in room 1");
+    t.equal(report(run, "key.json").hasKey, true, "walking over the key picks it up");
+    const through = report(run, "through.json");
+    t.equal(through.doorOpen, true, "the key opened the door");
+    t.equal(through.hasKey, false, "the key was spent");
+    t.equal(through.doorWall, -1, "the doorway's wall terrain cell is cleared: no tile");
+    t.ok(position(run, "through.json").x > MAP.split + 1, `the hero walked through (x ${position(run, "through.json").x.toFixed(2)})`);
+    t.equal(through.room, 2, "the hero is in room 2");
+    // Crossing into room 2 scrolls the view across over the zone's scrollTime, then settles in room 2's zone.
+    const cams = Array.from({ length: 25 }, (_, i) => run.json<{ value: Camera }>(`cam-${String(i).padStart(2, "0")}.json`).value);
+    const mid = cams.filter((c) => c.zoneFromActive && c.zoneScroll > 0 && c.zoneScroll < 1);
+    t.ok(mid.length >= 3, `the view scrolls between the rooms for several samples (${mid.length})`);
+    t.ok(mid.every((c) => c.zoneFromMax[0] <= MAP.split + 0.01 && c.zoneMin[0] >= MAP.split - 0.01), "from room 1's zone into room 2's");
+    const last = cams[cams.length - 1]!;
+    t.ok(last.zoneActive && !last.zoneFromActive && last.zoneScroll === 1 && last.zoneMin[0] >= MAP.split - 0.01, "and settles in room 2's zone");
+  },
+});

package/archetypes/topdown/tests/flee.og.ts

@@ -0,0 +1,49 @@
+// The slime's senses and its fear (assets/ai/slime.ogt, og.Perception):
+// the pillar in the west room hides the hero 4.5 m away (sight rays stop at
+// the map's wall colliders), stepping out from behind it shows the hero,
+// and a slime under 30 hp keeps away instead of chasing.
+import { playtest } from "@origingame/engine/playtest";
+import { position } from "./lib.ts";
+
+interface AiDump {
+  path: string;
+  sees: boolean;
+}
+
+export default playtest({
+  name: "the pillar hides the hero from the slime, and a hurt slime flees",
+  commands: [
+    // Behind the pillar (cells 6–7, rows 7–8): the slime east of it, the hero west.
+    "0.1:slime:9.5:8",
+    "0.1:place:5:8",
+    "0.3:dump_ai:slime:hidden.json",
+    // The hero steps out below the pillar.
+    "0.4:slime:9.5:8",
+    "0.4:place:7:5",
+    "0.6:dump_ai:slime:visible.json",
+    // Hurt: the slime keeps away from a hero 2 m off.
+    "1.0:set:slime.Slime.hp=20",
+    "1.0:slime:13.5:5",
+    "1.0:place:11.5:5",
+    "1.3:dump_ai:slime:fear.json",
+    "2.2:dump_entity:slime:fled.json",
+    "2.2:dump_entity:hero:hero.json",
+    "2.3:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const hidden = run.json<AiDump>("hidden.json");
+    t.equal(hidden.sees, false, "behind the pillar the hero is hidden, 4.5 m away (inside the slime's 5 m sight)");
+    t.ok(hidden.path.includes("patrol"), `so the slime patrols on (${hidden.path})`);
+    const visible = run.json<AiDump>("visible.json");
+    t.equal(visible.sees, true, "below the pillar the slime sees the hero");
+    t.ok(visible.path.includes("chase"), `and chases (${visible.path})`);
+
+    const fear = run.json<AiDump>("fear.json");
+    t.ok(fear.path.includes("flee"), `under 30 hp it flees (${fear.path})`);
+    const s = position(run, "fled.json");
+    const h = position(run, "hero.json");
+    const d = Math.hypot(s.x - h.x, s.y - h.y);
+    t.ok(d > 3.5, `and keeps away from the hero (${d.toFixed(2)} m, from 2)`);
+  },
+});

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

@@ -0,0 +1,45 @@
+// Four frames at 1280×720 compared with references/<tier>/: the west room at
+// rest (tiles, torches over the wall face, shadows, HUD), the crit's freeze
+// frame (white squashed slime, the crit number, the shaken camera), a dash
+// (the hero's afterimages) and the east room through the opened doorway
+// (the re-tiled wall, the camera zone of room 2).
+// `OG_FX_CAPTURE=1 og test .` records this tier's references.
+import { playtest } from "@origingame/engine/playtest";
+import { checkFrames } from "./frames.ts";
+import { press } from "./lib.ts";
+
+const setup = (t: number) => `${t}:place:12.3:6.5;${t}:slime:13.4:6.5;${t}:face:right`;
+const FILES = ["start.png", "crit.png", "dash.png", "east.png"];
+
+export default playtest({
+  name: "the rooms, a crit's freeze frame and a dash match their reference frames",
+  size: "1280x720",
+  commands: [
+    "0.5:screenshot:start.png",
+    setup(0.6),
+    press("Space", 0.65),
+    setup(1.3),
+    press("Space", 1.35),
+    setup(2.0),
+    press("Space", 2.05),
+    // The third hit lands on tick 129 and holds seven ticks.
+    "2.185:screenshot:crit.png",
+    "2.6:place:5:3",
+    "2.6:key_down:KeyD",
+    press("ShiftLeft", 2.7),
+    "2.8:screenshot:dash.png",
+    "2.9:key_up:KeyD",
+    "3.0:give:door",
+    "3.0:place:23:6",
+    "3.6:screenshot:east.png",
+    "3.7:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    t.ok(run.quit, "the script reached quit");
+    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/topdown/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/topdown/tests/lib.ts

@@ -0,0 +1,71 @@
+// Shared readers for Tomb Room's playtests: `dump_entity:<name>:<file>`
+// writes an entity's components; the hero's Report carries the run's facts
+// (src/components.ts says why).
+import type { PlaytestRun } from "@origingame/engine/playtest";
+
+export interface Report {
+  room: number;
+  hp: number;
+  coins: number;
+  hasKey: boolean;
+  doorOpen: boolean;
+  enemyHp: number;
+  hits: number;
+  swings: number;
+  steps: number;
+  hurts: number;
+  facing: number;
+  doorWall: number;
+}
+
+interface EntityDump {
+  components: Record<string, Record<string, unknown>>;
+}
+
+/** One component of a dumped entity. */
+export function component<T>(run: PlaytestRun, file: string, name: string): T {
+  const dump = run.json<EntityDump>(file);
+  const c = dump.components[name];
+  if (!c) throw new Error(`${file} has no ${name}: ${Object.keys(dump.components).join(", ")}`);
+  return c as unknown as T;
+}
+
+/** The hero's Report from a `dump_entity:hero` file. */
+export function report(run: PlaytestRun, file: string): Report {
+  return component<Report>(run, file, "Report");
+}
+
+/** A dumped entity's position. */
+export function position(run: PlaytestRun, file: string): { x: number; y: number } {
+  const p = component<{ position: [number, number, number] }>(run, file, "og.Transform").position;
+  return { x: p[0], y: p[1] };
+}
+
+/** A dumped entity's scale. */
+export function scale(run: PlaytestRun, file: string): { x: number; y: number } {
+  const s = component<{ scale: [number, number, number] }>(run, file, "og.Transform").scale;
+  return { x: s[0], y: s[1] };
+}
+
+/** Facing.* of src/components.ts. */
+export const DOWN = 0;
+export const UP = 1;
+export const LEFT = 2;
+export const RIGHT = 3;
+
+/** A key held from t0 to t1 seconds. */
+export const hold = (key: string, t0: number, t1: number) => `${t0}:key_down:${key};${t1}:key_up:${key}`;
+
+/** A press (down, up two ticks later): Space swings, ShiftLeft dashes. */
+export const press = (key: string, t: number) => hold(key, t, Number((t + 0.034).toFixed(3)));
+
+/** Where the map puts things (world units: the map's bottom-left corner is the origin, y up). */
+export const MAP = {
+  spawn: { x: 4.5, y: 5.5 },
+  slime: { x: 13.5, y: 6.5 },
+  key: { x: 16.5, y: 2.5 },
+  /** The doorway: cells 19–20, rows 5–6, so x 19..21, y 5..7. */
+  door: { x: 20, y: 6 },
+  /** The east room starts here. */
+  split: 20,
+} as const;

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

@@ -0,0 +1,40 @@
+// Determinism: a whole visit (walking past the pillar, four swings of which
+// two land with their hit stops, a coin, the key, the door, the east room,
+// a dash) replayed in two fresh processes ends on the same world hash.
+import { playtest } from "@origingame/engine/playtest";
+import { hold, press, report } from "./lib.ts";
+
+export default playtest({
+  name: "a whole visit replays to the same hash",
+  runs: 2,
+  commands: [
+    "0.2:key_down:KeyD",
+    "0.9:key_down:KeyW",
+    "1.3:key_up:KeyW",
+    "1.6:key_up:KeyD",
+    press("Space", 1.7),
+    press("Space", 2.2),
+    press("Space", 2.7),
+    press("Space", 3.2),
+    "3.5:key_down:KeyS",
+    "4.0:key_down:KeyD",
+    "4.5:key_up:KeyS",
+    "5.0:key_up:KeyD",
+    "5.1:place:15.2:2.3",
+    hold("KeyD", 5.1, 5.5),
+    "5.6:place:17.5:6",
+    "5.6:key_down:KeyD",
+    press("ShiftLeft", 6.8),
+    "7.4:key_up:KeyD",
+    "7.5:dump_entity:hero:end.json",
+    "7.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 = report(run, "end.json");
+    t.equal(end.doorOpen, true, "the visit opened the door");
+    t.equal(end.room, 2, "and ended in room 2");
+  },
+});

package/archetypes/topdown/tests/walk.og.ts

@@ -0,0 +1,46 @@
+// Walking: the keys move the hero at Tuning.speed, the walk clip's "step"
+// events count footsteps, the facing follows the keys (left is the side row
+// flipped), and the wall terrain's colliders stop the body.
+//
+// The slime waits in the east room, out of sight, so nothing interrupts.
+import { playtest } from "@origingame/engine/playtest";
+import { LEFT, MAP, RIGHT, UP, component, hold, position, report } from "./lib.ts";
+
+export default playtest({
+  name: "the hero walks at its speed, steps on the walk frames and stops at walls",
+  commands: [
+    "0.1:slime:35:3",
+    // Right for one second from the spawn: 4.5 m at 4.5 m/s.
+    hold("KeyD", 0.2, 1.2),
+    "1.3:dump_entity:hero:right.json",
+    // Up into the top wall (row 0 covers y 11..12; the body's box reaches 0.35 above the feet).
+    hold("KeyW", 1.4, 3.0),
+    "3.1:dump_entity:hero:up.json",
+    // Left along the wall to the west wall (column 0 covers x 0..1; the box is 0.6 wide).
+    "3.2:key_down:ArrowLeft",
+    "3.6:dump_entity:hero:walking-left.json",
+    "3.6:screenshot:walk.png",
+    "5.4:key_up:ArrowLeft",
+    "5.5:dump_entity:hero:left.json",
+    "5.6:quit",
+  ].join(";"),
+  check(run, t) {
+    t.equal(run.warnings.join("; "), "", "the script ran without warnings");
+    const right = position(run, "right.json");
+    t.near(right.x, MAP.spawn.x + 4.5, 0.1, `one second of D walks 4.5 m (x ${right.x.toFixed(3)})`);
+    t.near(right.y, MAP.spawn.y, 0.001, "walking right keeps y");
+    const r = report(run, "right.json");
+    t.equal(r.facing, RIGHT, "the hero faces right");
+    t.ok(r.steps >= 3 && r.steps <= 5, `the walk clip's step events fired twice a cycle (${r.steps} steps in 1 s at 8 fps)`);
+    const up = position(run, "up.json");
+    t.near(up.y, 11 - 0.35, 0.03, `the top wall stops the body (feet at y ${up.y.toFixed(3)}, box top at 11)`);
+    t.near(up.x, right.x, 0.01, "walking up keeps x");
+    t.equal(report(run, "up.json").facing, UP, "the hero faces up");
+    t.equal(component<{ clip: number }>(run, "walking-left.json", "og.Flipbook").clip, 5, "walking left plays walk_side (clip 5)");
+    t.equal(component<{ flipX: boolean }>(run, "walking-left.json", "og.Sprite").flipX, true, "facing left flips the side row");
+    const left = position(run, "left.json");
+    t.near(left.x, 1 + 0.3, 0.03, `the west wall stops the body (x ${left.x.toFixed(3)})`);
+    t.equal(report(run, "left.json").facing, LEFT, "the hero faces left");
+    t.equal(component<{ clip: number }>(run, "left.json", "og.Flipbook").clip, 2, "standing still shows idle_side (clip 2)");
+  },
+});