incanto 0.68.0 → 0.70.0

package/templates-app/beacon-isle-3d/generate-world.ts

@@ -6,6 +6,7 @@
  * (quest, enemies, HUD) — regenerate the world without touching the game.
  */
 
+import { newUid } from 'incanto';
 import { buildTerrainNav, Terrain3D } from 'incanto/3d';
 import { generateTerrain } from 'incanto/env';
 
@@ -145,6 +146,8 @@ dressing.push({
   name: 'ShoreRocks',
   type: 'InstancedMesh3D',
   props: {
+    // Sunk into the slope on purpose — see the note by the player's Catch.
+    snapToGround: false,
     mesh: 'gem',
     size: [0.6, 0.45, 0.6],
     material: { color: '#7e8590', roughness: 0.95, flatShading: true },
@@ -166,7 +169,7 @@ const ward = (i: number, [x, y, z]: [number, number, number]): unknown => ({
   name: `Ward${i}`,
   type: 'Node3D',
   groups: ['ward'],
-  props: { position: [round2(x), round2(y), round2(z)] },
+  props: { position: [round2(x), round2(y), round2(z)], snapToGround: false },
   children: [
     {
       name: 'Plinth',
@@ -228,7 +231,7 @@ const shade = (wardIdx: number, n: number, [x, y, z]: [number, number, number]):
   name: `Shade${wardIdx}_${n}`,
   type: 'Node3D',
   groups: ['shade', `shade-ward${wardIdx}`],
-  props: { position: [round2(x), round2(y + 0.9), round2(z)] },
+  props: { position: [round2(x), round2(y + 0.9), round2(z)], snapToGround: false },
   script: { name: 'PathFollow', props: { speed: 2.6, loop: true } },
   children: [
     {
@@ -411,6 +414,9 @@ const scene = {
             round2(heightAt(keeperSite[0] - 5, keeperSite[2] - 4)),
             round2(keeperSite[2] - 4),
           ],
+          // The lamp sits at the top of the tower: the ASSEMBLY owns its
+          // children's height, so `findFloatingProps` is not asked about them.
+          snapToGround: false,
           static: true,
         },
         children: [
@@ -462,7 +468,7 @@ const scene = {
       {
         name: 'Keeper',
         type: 'Node3D',
-        props: { position: keeperSite.map(round2) },
+        props: { position: keeperSite.map(round2), snapToGround: false },
         script: { name: 'Interactable', props: { action: 'interact', range: 3 } },
         children: [
           {
@@ -511,6 +517,9 @@ const scene = {
         name: 'Player',
         type: 'RigidBody3D',
         groups: ['player'],
+        // Its Health is saveable, and a save is keyed by uid — minted, pasted,
+        // and stable across regenerations for the same reason the HUD's are.
+        uid: 'n_3cqocoi9v0cvoxdv',
         script: { name: 'Health', props: { max: 100, invulnerableFor: 0.8 } },
         props: {
           position: [round2(playerSpawn[0]), round2(playerSpawn[1] + 1.2), round2(playerSpawn[2])],
@@ -519,11 +528,24 @@ const scene = {
           collider: { shape: 'capsule', radius: 0.34, height: 1 },
         },
         children: [
+          {
+            /*
+             * An open terrain has an EDGE. With no catch, walking off it falls
+             * forever — `incanto-playtest` calls that `fell` and treats it as a
+             * failure whatever the game set out to be.
+             */
+            name: 'Catch',
+            type: 'Respawn',
+          },
           {
             name: 'Controller',
             type: 'CharacterController3D',
             props: {
               view: 'free',
+              // The two `incanto-feel` prints a note about on every run, and the
+              // 3D character skill calls coyote time the single biggest one.
+              coyoteSeconds: 0.12,
+              jumpBufferSeconds: 0.15,
               camDistance: 5.2,
               eyeHeight: 1.1,
               maxSpeed: 4.4,
@@ -623,6 +645,7 @@ const scene = {
         // ROOT child (a positioned parent would double the offset on screen)
         props: {
           visible: false,
+          snapToGround: false,
           position: [
             round2(keeperSite[0] + 16),
             round2(heightAt(keeperSite[0] + 16, keeperSite[2] - 14)),
@@ -768,7 +791,10 @@ const scene = {
           {
             name: 'Quest',
             type: 'UiText',
-            uid: 'n_bi_quest',
+            // MINTED by newUid() and pasted, not invented: a save is keyed by
+            // uid and this file is regenerated, so they have to be both
+            // crypto-shaped and stable across `bun run world`.
+            uid: 'n_3txwnq8m201xbwoz',
             props: {
               text: 'Find the lighthouse keeper [E]',
               size: 16,
@@ -779,20 +805,25 @@ const scene = {
           {
             name: 'HP',
             type: 'UiBar',
-            uid: 'n_bi_hp',
+            uid: 'n_vp09cmk3syxo2lcz',
             props: { anchor: 'topRight', value: 100, max: 100, width: 170 },
           },
-          { name: 'Banner', type: 'UiBanner', uid: 'n_bi_banner', props: { anchor: 'center' } },
+          {
+            name: 'Banner',
+            type: 'UiBanner',
+            uid: 'n_xwkphpoa7ac9w451',
+            props: { anchor: 'center' },
+          },
           {
             name: 'Dialogue',
             type: 'UiDialogue',
-            uid: 'n_bi_dialogue',
+            uid: 'n_7wosfkulqmue3jpv',
             props: { anchor: 'bottom', charsPerSecond: 45 },
           },
           {
             name: 'Hint',
             type: 'UiText',
-            uid: 'n_bi_hint',
+            uid: 'n_x3funbse7a8nkfnu',
             props: {
               text: 'WASD move · Shift sprint · E interact · click/F strike',
               size: 12,
@@ -811,7 +842,44 @@ const scene = {
   ],
 };
 
-await Bun.write(`${import.meta.dir}/src/game.scene.json`, `${JSON.stringify(scene, null, 2)}\n`);
+/*
+ * A REGENERATED file keeps the identities the old one had.
+ *
+ * A uid is the key a save is written against, and this script overwrites the
+ * whole scene — so minting fresh ones every run would break every save on the
+ * next `bun run world`, and emitting none at all (which is what it used to do)
+ * left eighteen scripted nodes unkeyed, so a save could not record what the run
+ * consumed. `verify:uids` said so; nothing said it to whoever ran the command.
+ *
+ * Reused by PATH: the same seed builds the same island, so the same node is at
+ * the same place. Anything new gets a real `newUid()`.
+ */
+const scenePath = `${import.meta.dir}/src/game.scene.json`;
+const previous = new Map<string, string>();
+try {
+  const old = JSON.parse(await Bun.file(scenePath).text()) as { root?: unknown };
+  const remember = (node: Record<string, unknown>, path: string): void => {
+    const here = `${path}/${String(node.name ?? '?')}`;
+    if (typeof node.uid === 'string') previous.set(here, node.uid);
+    for (const child of (node.children ?? []) as Record<string, unknown>[]) remember(child, here);
+  };
+  if (old.root) remember(old.root as Record<string, unknown>, '');
+} catch {
+  // No previous file: every uid below is minted fresh, which is the first run.
+}
+
+const keyIdentities = (node: Record<string, unknown>, path: string): void => {
+  const here = `${path}/${String(node.name ?? '?')}`;
+  // Only what a save would write down: a node carrying a behavior.
+  if (node.script && typeof node.uid !== 'string') node.uid = previous.get(here) ?? newUid();
+  else if (typeof node.uid === 'string' && previous.has(here))
+    node.uid = previous.get(here) as string;
+  for (const child of (node.children ?? []) as Record<string, unknown>[])
+    keyIdentities(child, here);
+};
+keyIdentities(scene.root as unknown as Record<string, unknown>, '');
+
+await Bun.write(scenePath, `${JSON.stringify(scene, null, 2)}\n`);
 console.log(
   `beacon isle generated: keeper ${keeperSite.map(round2)}, wards ${wardSites.map((w) => w.map(round2)).join(' | ')}, ${placed} groves, ${grassPlaced} grass, ${flowersPlaced} flowers`,
 );

package/templates-app/beacon-isle-3d/package.json

@@ -6,7 +6,7 @@
     "dev": "vite",
     "build": "vite build",
     "typecheck": "tsc --noEmit",
-    "check": "incanto-check src",
+    "check": "incanto-check src --behaviors src/behaviors.ts",
     "verify": "bun verify.ts",
     "world": "bun generate-world.ts"
   },
@@ -14,7 +14,7 @@
     "@dimforge/rapier2d-compat": "0.19.3",
     "@dimforge/rapier3d-compat": "0.19.3",
     "@pixiv/three-vrm": "^3.5.3",
-    "incanto": "^0.68.0",
+    "incanto": "^0.70.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/beacon-isle-3d/src/behaviors.ts

@@ -88,6 +88,27 @@ function spawnFootDust(root: Node, at: [number, number, number], scale = 1): voi
 }
 
 export class IsleDirector extends Behavior {
+  /**
+   * The isle HAS an ending, and never said so.
+   *
+   * Three wards lit, the Shadeheart down, fireworks over the lighthouse and
+   * `BEACON ISLE SHINES` on the banner — and no `won` anywhere, so every
+   * instrument that asks the scene whether it is finishable answered no. On
+   * the template `bunx incanto-new my-game` scaffolds by DEFAULT:
+   *
+   * ```
+   * ? plays — nothing declares a win — 8 runs played without a defect,
+   *           and there was no end to reach
+   * next: if it is meant to be finishable, emit `won`
+   * ```
+   *
+   * Both sentences were true about the WIRING and wrong about the game. A
+   * signal is the cheapest of the three routes the skill offers (`GameFlow`,
+   * `ScoreKeeper`, your own behaviour) and the only one that does not also
+   * freeze the world — the isle keeps playing after you win it.
+   */
+  static readonly signals: readonly string[] = ['won'];
+
   private wind: Voice | null = null;
   private nav: TerrainNav | null = null;
   private repathClock = 0;
@@ -445,6 +466,7 @@ export class IsleDirector extends Behavior {
         (this.node.getNode('WinSfx') as AudioPlayer).play();
         this.fireworksIn = 0.4;
         this.syncQuestLine();
+        this.node.emit('won');
       });
       return;
     }