incanto 0.11.0 → 0.13.0

package/templates-app/village-quest-3d/verify.ts

@@ -0,0 +1,254 @@
+/**
+ * Headless proof that Emberwood actually PLAYS — author → VERIFY → fix,
+ * no browser. Three passes:
+ *
+ *   AUDIT : auditScene finds nothing to warn about in either scene.
+ *   QUEST : the full loop — talk to the Elder (UiDialogue), accept via
+ *           choose(0), walk the north gate (goToScene → grove), wolves are
+ *           walking their A* patrol rings, three sword strikes clear them,
+ *           the portal returns home, reporting back completes the quest.
+ *   REPLAY: the same recorded inputs replayed into a fresh engine land the
+ *           player on the BIT-IDENTICAL position — the determinism contract
+ *           (seeded rng + fixed clock) that makes recordings regressions.
+ *
+ * Run with `bun verify.ts` (or `bun run verify`).
+ */
+import type { UiBanner, UiDialogue, UiText } from 'incanto';
+import { Engine, loadScene, registerBehavior, replay, startRecording } from 'incanto';
+import { enablePhysics3D } from 'incanto/3d';
+import { auditScene, registerAllNodes, runScript } from 'incanto/test';
+import { BEHAVIORS, cellToWorld } from './src/behaviors';
+import groveJson from './src/grove.scene.json';
+import { quest, resetQuest } from './src/quest';
+import villageJson from './src/village.scene.json';
+
+interface Vec {
+  position: number[];
+}
+
+const ok = (label: string, cond: boolean): void => {
+  if (!cond) {
+    console.error(`FAIL: ${label}`);
+    process.exitCode = 1;
+  } else {
+    console.log(`pass: ${label}`);
+  }
+};
+
+// ---- AUDIT ------------------------------------------------------------------------
+{
+  registerAllNodes();
+  for (const [name, ctor] of Object.entries(BEHAVIORS)) {
+    registerBehavior(name, ctor, { replace: true });
+  }
+  const w1 = auditScene(villageJson as unknown as Parameters<typeof auditScene>[0]);
+  const w2 = auditScene(groveJson as unknown as Parameters<typeof auditScene>[0]);
+  ok(`auditScene(village) is clean (${w1.length} warnings)`, w1.length === 0);
+  ok(`auditScene(grove) is clean (${w2.length} warnings)`, w2.length === 0);
+  for (const w of [...w1, ...w2]) console.error(`  warn: ${w}`);
+}
+
+// ---- QUEST — the whole loop through both scenes ------------------------------------
+{
+  resetQuest();
+  let sceneName = (): string => 'unset';
+  let wolvesWalked = false;
+
+  const result = await runScript(villageJson, {
+    durationMs: 60000,
+    seed: 7,
+    behaviors: BEHAVIORS,
+    steps: [
+      {
+        atMs: 100,
+        label: 'talk to the Elder and accept the quest',
+        do: (ctx) => {
+          sceneName = () => ctx.engine.scene?.source?.name as string;
+          const player = ctx.getNode('/root/Player') as unknown as Vec;
+          player.position = [3, 1.4, 0.2]; // step up to the Elder
+          for (let i = 0; i < 5; i++) ctx.engine.step();
+          ctx.engine.input.pressAction('interact');
+          ctx.engine.step();
+          ctx.engine.input.releaseAction('interact');
+          const talk = ctx.getNode('/root/HUD/Dialogue') as UiDialogue;
+          if (!talk.active) throw new Error('dialogue did not open');
+          // let line 1 type out, advance, let the choice line type out
+          for (let i = 0; i < 150; i++) ctx.engine.step();
+          talk.advance();
+          for (let i = 0; i < 150; i++) ctx.engine.step();
+          talk.choose(0); // "I will go"
+          ctx.engine.step();
+          if (!quest.accepted) throw new Error('choice did not accept the quest');
+        },
+      },
+      {
+        atMs: 6000,
+        label: 'north gate swaps to the grove (goToScene)',
+        do: (ctx) => {
+          const player = ctx.getNode('/root/Player') as unknown as Vec;
+          player.position = [0, 1.5, -26.4]; // into the gate trigger
+          for (let i = 0; i < 30 && sceneName() !== 'WolfGrove'; i++) ctx.engine.step();
+          if (sceneName() !== 'WolfGrove') throw new Error(`still in ${sceneName()}`);
+        },
+      },
+      {
+        atMs: 8000,
+        label: 'wolves walk their A* patrol rings',
+        do: (ctx) => {
+          const root = ctx.engine.scene?.tree.root;
+          if (!root) throw new Error('no scene');
+          const wolf = root.getNode('Wolves/Wolf1') as unknown as Vec;
+          const before = [...wolf.position];
+          for (let i = 0; i < 90; i++) ctx.engine.step();
+          const dx = (wolf.position[0] ?? 0) - (before[0] ?? 0);
+          const dz = (wolf.position[2] ?? 0) - (before[2] ?? 0);
+          wolvesWalked = Math.hypot(dx, dz) > 0.5;
+          if (!wolvesWalked) throw new Error('Wolf1 never moved');
+        },
+      },
+      {
+        atMs: 9000,
+        label: 'wolves HUNT: player inside aggro range pulls a wolf off patrol',
+        do: (ctx) => {
+          const engine = ctx.engine;
+          const root = engine.scene?.tree.root;
+          if (!root) throw new Error('no scene');
+          const wolf = root.getNode('Wolves/Wolf2') as unknown as Vec;
+          const player = root.getNode('Player') as unknown as Vec;
+          // stand on an OPEN cell on Wolf2's patrol row and wait for it to
+          // come into aggro range — it should re-path and close to bite range
+          const [ox, , oz] = cellToWorld(9, 1, 0);
+          const gap = () =>
+            Math.hypot((wolf.position[0] ?? 0) - (ox ?? 0), (wolf.position[2] ?? 0) - (oz ?? 0));
+          let reached = false;
+          for (let i = 0; i < 900 && !reached; i++) {
+            player.position = [ox ?? 0, 1.4, oz ?? 0];
+            engine.step();
+            reached = gap() < 1.2;
+          }
+          if (!reached) throw new Error(`wolf never closed in (gap ${gap().toFixed(2)})`);
+        },
+      },
+      {
+        atMs: 11000,
+        label: 'a bite drains HP; 0 HP → YOU FELL → fresh grove respawn',
+        do: (ctx) => {
+          const engine = ctx.engine;
+          const root = () => engine.scene?.tree.root;
+          const health = () =>
+            root()?.getNode('Player')?.behavior as unknown as { current: number };
+          const wolves = () => engine.scene?.tree.getNodesInGroup('wolf') ?? [];
+          // stand ON a wolf until dead (invulnerability windows between bites)
+          for (let i = 0; i < 3000 && (health()?.current ?? 0) > 0; i++) {
+            const w = wolves()[0] as unknown as Vec | undefined;
+            if (!w) throw new Error('no wolves left to bite');
+            const p = root()?.getNode('Player') as unknown as Vec;
+            p.position = [w.position[0] ?? 0, 1.4, w.position[2] ?? 0];
+            engine.step();
+          }
+          if ((health()?.current ?? 1) > 0) throw new Error('wolves never killed the player');
+          // respawn countdown (1.6s) → fresh grove with full wolves + full HP
+          for (let i = 0; i < 130; i++) engine.step();
+          if (wolves().length !== 3) throw new Error(`respawn left ${wolves().length} wolves`);
+          if ((health()?.current ?? 0) < 100) throw new Error('respawn did not reset HP');
+        },
+      },
+      {
+        atMs: 14000,
+        label: 'three strikes clear the grove',
+        do: (ctx) => {
+          const engine = ctx.engine;
+          const root = engine.scene?.tree.root;
+          if (!root) throw new Error('no scene');
+          const player = root.getNode('Player') as unknown as Vec;
+          // wolves take TWO strikes now (first = flinch knockback)
+          for (let round = 0; round < 6; round++) {
+            const wolves = engine.scene?.tree.getNodesInGroup('wolf') ?? [];
+            const target = wolves[0] as unknown as Vec | undefined;
+            if (!target) break;
+            player.position = [
+              (target.position[0] ?? 0) + 0.8,
+              1.4,
+              (target.position[2] ?? 0) + 0.8,
+            ];
+            engine.step();
+            engine.input.pressAction('attack');
+            engine.step();
+            engine.input.releaseAction('attack');
+            for (let i = 0; i < 40; i++) engine.step();
+          }
+          const left = engine.scene?.tree.getNodesInGroup('wolf').length ?? -1;
+          if (left !== 0) throw new Error(`${left} wolves survived`);
+          for (let i = 0; i < 5; i++) engine.step(); // director notices → cleared
+          if (!quest.cleared) throw new Error('quest.cleared never set');
+        },
+      },
+      {
+        atMs: 20000,
+        label: 'portal home + report back = QUEST COMPLETE',
+        do: (ctx) => {
+          const engine = ctx.engine;
+          const root = () => engine.scene?.tree.root;
+          const player = () => root()?.getNode('Player') as unknown as Vec;
+          player().position = [3.5, 1.4, 13.5]; // into the return portal
+          for (let i = 0; i < 30 && sceneName() !== 'EmberwoodVillage'; i++) engine.step();
+          if (sceneName() !== 'EmberwoodVillage') throw new Error(`still in ${sceneName()}`);
+          player().position = [3, 1.4, 0.2];
+          for (let i = 0; i < 5; i++) engine.step();
+          engine.input.pressAction('interact');
+          engine.step();
+          engine.input.releaseAction('interact');
+          const talk = root()?.getNode('HUD/Dialogue') as UiDialogue;
+          for (let i = 0; i < 400; i++) engine.step();
+          talk.advance();
+          for (let i = 0; i < 400; i++) engine.step();
+          talk.advance();
+          for (let i = 0; i < 10; i++) engine.step();
+          if (!quest.done) throw new Error('quest never completed');
+          const bannerText = (root()?.getNode('HUD/Banner') as UiBanner & { text?: string }) ?? {};
+          const questLine = (root()?.getNode('HUD/Quest') as UiText).text;
+          if (!questLine.includes('safe')) throw new Error(`quest line: ${questLine}`);
+          void bannerText;
+        },
+      },
+    ],
+  });
+
+  ok('QUEST: full loop (dialogue → grove → wolves → report back)', result.ok);
+  for (const f of result.failures) console.error(`  ${f.label}: ${f.message}`);
+}
+
+// ---- REPLAY — recorded inputs are a regression test ---------------------------------
+{
+  resetQuest();
+  const boot = async (): Promise<Engine> => {
+    const engine = new Engine({ seed: 42, scheduler: () => () => {} });
+    engine.setScene(loadScene(structuredClone(villageJson) as Parameters<typeof loadScene>[0]));
+    await enablePhysics3D(engine);
+    return engine;
+  };
+
+  const a = await boot();
+  const rec = startRecording(a);
+  for (let frame = 0; frame <= 300; frame++) {
+    if (frame === 20) a.input.handleKey('KeyW', true);
+    if (frame === 160) a.input.handleKey('KeyD', true);
+    if (frame === 240) a.input.handleKey('KeyW', false);
+    a.tick(frame * (1000 / 60));
+  }
+  const recording = rec.stop();
+  const posA = (a.scene?.tree.root?.getNode('Player') as unknown as Vec).position;
+
+  resetQuest();
+  const b = await boot();
+  replay(b, recording);
+  const posB = (b.scene?.tree.root?.getNode('Player') as unknown as Vec).position;
+
+  ok(
+    `REPLAY: bit-identical player position after 300 replayed frames (${posA.join(', ')})`,
+    posA.length === 3 && posA.every((v, i) => v === posB[i]),
+  );
+  ok('REPLAY: the player actually moved', Math.hypot(posA[0] ?? 0, (posA[2] ?? 0) - 10) > 1);
+}
+
+console.log(process.exitCode ? '\nVERIFY FAILED' : '\nVERIFY OK');

package/templates-app/village-quest-3d/vite.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  base: './',
+});