incanto 0.72.0 → 0.74.0

package/templates-app/platformer-2d/src/game.scene.json

@@ -1350,6 +1350,132 @@
           }
         ],
         "uid": "n_i3xs3gnb3cyrar1u"
+      },
+      {
+        "name": "CourseFloor",
+        "type": "StaticBody2D",
+        "uid": "n_9p55c0wu33vbe194",
+        "props": { "position": [3300, 520], "collider": { "shape": "rect", "size": [900, 120] } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_56chxbokw5okl2ar",
+            "props": { "size": [900, 120], "color": "#6b5638", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Trampoline",
+        "type": "StaticBody2D",
+        "uid": "n_vqjbknb54e0zq787",
+        "props": {
+          "position": [3000, 455],
+          "collider": { "shape": "rect", "size": [120, 10] },
+          "restitution": 1
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_bed7i5blyg8p63ij",
+            "props": { "size": [120, 10], "color": "#3b82f6", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Bouncer",
+        "type": "RigidBody2D",
+        "uid": "n_8vd73zp82idtm5gx",
+        "props": { "position": [3000, 150], "collider": { "shape": "circle", "radius": 14 } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_n18pdy731ltnmb3l",
+            "props": { "size": [28, 28], "color": "#f4f1de", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Ice",
+        "type": "StaticBody2D",
+        "uid": "n_zlp89ikkls0xkbwn",
+        "props": {
+          "position": [3400, 455],
+          "collider": { "shape": "rect", "size": [400, 10] },
+          "friction": 0
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_opic7894wramqynx",
+            "props": { "size": [400, 10], "color": "#bfe9ff", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Sled",
+        "type": "RigidBody2D",
+        "uid": "n_nhcrprd8no2pzb9i",
+        "props": {
+          "position": [3215, 435],
+          "collider": { "shape": "circle", "radius": 14 },
+          "linearVelocity": [260, 0]
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_y2owjzo7khqchken",
+            "props": { "size": [28, 28], "color": "#8c6a3f", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Hound",
+        "type": "CharacterBody2D",
+        "uid": "n_kmnt12lx070t311c",
+        "props": { "position": [3650, 440], "collider": { "shape": "rect", "size": [30, 40] } },
+        "children": [
+          {
+            "name": "AI",
+            "type": "Node2D",
+            "uid": "n_juz8aw6j311cstbs",
+            "script": {
+              "name": "Chase",
+              "props": {
+                "target": "/root/Player",
+                "speed": 160,
+                "stopRange": 24,
+                "loseRange": 500,
+                "moveParent": true,
+                "ground": true
+              }
+            }
+          },
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_k5h72ttrivo8vy0m",
+            "props": { "size": [30, 40], "color": "#6b4d8a", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Perch",
+        "type": "StaticBody2D",
+        "uid": "n_t6vi97e88isgglef",
+        "props": { "position": [3650, 300], "collider": { "shape": "rect", "size": [160, 20] } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_m7qcxz6z1sc6rfbv",
+            "props": { "size": [160, 20], "color": "#9aa3bd", "anchor": [0.5, 0.5] }
+          }
+        ]
       }
     ],
     "uid": "n_d9t51gs0vhpnp2jj"

package/templates-app/platformer-2d/verify.ts

@@ -273,3 +273,57 @@ interface Player {
 }
 
 console.log(process.exitCode ? '\nVERIFY FAILED' : '\nVERIFY OK — Castle Run plays end to end');
+
+// ---- TWIN: this round's 3D surfaces, in two dimensions ----------------------------
+// StaticBody2D.restitution/friction (#1295) and Chase.ground (#1297) were built
+// with the 3D case in hand and 2D tests beside it; a course past the last
+// ground slab composes them in the 2D flagship and measures each. y is DOWN.
+{
+  type Body = { position: number[] };
+  const bouncerY: number[] = [];
+  let sledX = 0;
+  let houndY = 0;
+  let houndX = 0;
+  const result = await runScript(sceneJson, {
+    behaviors,
+    durationMs: 4200,
+    steps: [
+      ...Array.from({ length: 30 }, (_, i) => ({
+        atMs: 100 + i * 100,
+        do: (ctx: { getNode(p: string): unknown }) => {
+          bouncerY.push((ctx.getNode('Bouncer') as Body).position[1] ?? 0);
+        },
+      })),
+      {
+        atMs: 3100,
+        do: (ctx) => {
+          sledX = (ctx.getNode('Sled') as unknown as Body).position[0] ?? 0;
+          // the player on the perch above the hound: a ground chaser closes in below, never up
+          const player = ctx.getNode('Player') as unknown as Body;
+          player.position = [3650, 260];
+          for (let i = 0; i < 120; i++) ctx.engine.step();
+          const hound = ctx.getNode('Hound') as unknown as Body;
+          houndX = hound.position[0] ?? 0;
+          houndY = hound.position[1] ?? 0;
+        },
+      },
+    ],
+  });
+  ok('runScript reported no failures (TWIN path)', result.ok);
+  let touch = bouncerY.findIndex((y, i) => i > 0 && y < (bouncerY[i - 1] ?? 0));
+  if (touch < 1) touch = 1;
+  const low = bouncerY[touch - 1] ?? 0;
+  const rebound = low - Math.min(...bouncerY.slice(touch));
+  ok(
+    `StaticBody2D restitution 1: a dead ball climbs back ${rebound.toFixed(0)} px of its 300 px drop`,
+    rebound > 180,
+  );
+  ok(
+    `StaticBody2D friction 0: the sled slides to x ${sledX.toFixed(0)} across the ice (from 3215)`,
+    sledX > 3450,
+  );
+  ok(
+    `Chase.ground: the hound stays on the floor (y ${houndY.toFixed(0)}, floor 440) under a player on the perch, ${Math.abs(houndX - 3650).toFixed(0)} px off its x`,
+    houndY > 400 && Math.abs(houndX - 3650) < 60,
+  );
+}

package/templates-app/star-survivor/package.json

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@dimforge/rapier2d-compat": "0.19.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.74.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/tps-3d/PROJECT/Context.md

@@ -5,7 +5,7 @@
 "Vanguard" — a 3D THIRD-PERSON shooter. The camera rides over your soldier's
 shoulder (you SEE your character); the crosshair is where the hitscan rifle
 fires. Move with WASD, look with the mouse (click locks the pointer), Shift to
-sprint, Space to jump, click / F to fire, R to reload, Enter to restart. Survive and clear three
+sprint, Space to jump (tap for a short hop, hold for the full jump, press again in the air for a second), click / F to fire, R to reload, Enter to restart. Survive and clear three
 escalating waves of chasing enemies to **SECURE THE AREA**; let them drain your
 HP to 0 and the **MISSION FAILS**.
 

package/templates-app/tps-3d/PROJECT/Status.md

@@ -7,7 +7,13 @@
   sun + fill light.
   - **Player** (RigidBody3D, group `player`, `Health` max 100 / 0.6s i-frames):
     `Controller` (CharacterController3D `view: 'free'`, camDistance 4.2, eyeHeight
-    1.1, maxSpeed 4.2, `Shoot` script); a real GLB `Skin` (ModelInstance3D
+    1.1, maxSpeed 4.2, `Shoot` script — and the whole game-feel table: coyote
+    0.12 s, jump buffer 0.15 s, `jumpCutMultiplier` 0.45 for a variable-height
+    jump, `maxJumps` 2, `airControl` 0.5, `fallGravity` 3; `bun run verify`
+    measures each one rather than reading it); a real GLB `Skin` whose UPPER
+    BODY plays `$anims/shoot` on every shot (`animationUpper`) while the legs
+    keep the controller's run/idle clip — the two-layer animation the 3D
+    character skill documents and no example had composed; a real GLB `Skin` (ModelInstance3D
     `base-model.glb` + mixamo idle/walk/run/jump clips); a `Muzzle` Node3D
     (shot/kill/empty SFX + flash light).
   - **Spawner** (WaveSpawner, 3 waves of 4/6/8) cloning a hidden `EnemyTemplate`
@@ -39,3 +45,36 @@
   (the CDN set is idle/walk/run/jump).
 - No cover/peek mechanic, no projectile-drop weapons (hitscan only). Co-op
   multiplayer lives in the sibling `examples/tps-3d-multiplay`.
+
+## stepHeight and jumpVelocity (2026-09-04)
+
+The controller declares `stepHeight: 0.4` and `jumpVelocity: 5`; a 0.3 m `Curb` and a
+0.9 m `Ledge` sit at z −12 (away from the fight) and `verify.ts` walks the player into
+both — over the one (y 0.84 → 1.14), stopped by the other — and compares the jump apex
+against the same scene at `jumpVelocity 4` (1.26 u vs 0.81 u).
+
+## slopeLimitDeg, and the chaser that flew (2026-09-04)
+
+The enemy prefab declares `slopeLimitDeg: 50` and `stepHeight: 0.7`; a 40° `Hill` and a
+70° `Cliff` (each 4 m of slab onto a plateau) sit at the far corner (x 7–22, z −20).
+`verify.ts` puts one enemy at the foot of each with the player on top: it climbs the
+hill and reaches (rose 2.64 m), and is stopped by the cliff (rose 0.32 m, 3.2 m short).
+Composing this found `Chase` flying its body straight at an elevated target; a
+`CharacterBody3D` chaser now walks (`Chase.ground`), and the contact run went from
+3 hits to 11 once enemies climbed the 0.6 m Ramp by `stepHeight` rather than by the
+pile behind them.
+
+## cameraCollision and platformCarry (2026-09-04)
+
+Both declared on the controller; the arena gained a `Lift` (StaticBody3D walked by
+`Patrol`, pingpong x −18 → −10). `verify.ts` asserts: a wall behind the player closes the
+camera to 0.45 m (4.2 in the open); standing still on the lift for two seconds, it travels
+4 m and the rider drifts under 0.25 m. `floatHeight` was tried and taken back out — the spring sags
+~0.13 m, so 0.05 rests exactly where 0.01 does (0.84); the number is in the skill.
+
+## Catch (2026-09-04)
+
+`Player/Catch` (a `Respawn`, auto line) puts back a player who leaves the arena: the Hill
+and Cliff plateaus, the Lift and a double jump reach over the 3 m walls (24 playtests fell
+3 times before it, none after). `verify.ts` drops the player over Wall1 and asserts the catch.
+

package/templates-app/tps-3d/PROJECT/Structure.md

@@ -42,3 +42,22 @@ Headless proof (`bun run verify`) that the loop plays end to end — move, waves
 Chase closing in, the autopilot aiming + firing the hitscan to clear all waves
 (WIN), and an enemy hitbox draining the player to 0 (LOSE) — via `incanto/test`'s
 `runScript` at a seeded fixed timestep.
+
+## Prefabs
+
+`src/cover.scene.json` and `src/pillar.scene.json` are the two cover blocks and
+two pillars of the arena, placed from `game.scene.json` with `instance:` and a
+`position` override each — the first 3D prefabs in the repo. `main.ts` hands
+the loader every `*.scene.json` beside it through vite's `import.meta.glob`;
+`verify.ts` imports the two by name (bun has no glob). Every CLI resolves a
+prefab relative to the scene on its own; the harness and the game are the two
+places that say so themselves.
+
+- `Arena/Curb`, `Arena/Ledge` — a 0.3 m step the player climbs and a 0.9 m face that stops it,
+  the harness's fixtures for `stepHeight`.
+- `Arena/Hill`, `Arena/HillTop`, `Arena/Cliff`, `Arena/CliffTop` — a 40° slope an enemy climbs and a
+  70° face it cannot, the harness's fixtures for `slopeLimitDeg`.
+- `Arena/Lift` — a moving platform (`Patrol` on a `StaticBody3D`), the harness's fixture for
+  `platformCarry`.
+- `Player/Catch` — a `Respawn` that returns a player who got over the walls to the spawn.
+

package/templates-app/tps-3d/package.json

@@ -13,7 +13,7 @@
     "@dimforge/rapier2d-compat": "0.19.3",
     "@dimforge/rapier3d-compat": "0.19.3",
     "@pixiv/three-vrm": "^3.5.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.74.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/tps-3d/src/behaviors.ts

@@ -140,12 +140,16 @@ export class Shoot extends Behavior {
   override onReady(): void {
     const skin = this.player.getNodeOrNull('Skin') as ModelInstance3D | null;
     if (!skin) return;
+    this.skin = skin;
     this.controller.on('movementStateChanged', (state) => {
       const clip = STATE_CLIPS[state as string];
       if (clip) skin.animation = clip;
     });
   }
 
+  /** The visible soldier — the upper-body layer plays the shot on it. */
+  private skin: ModelInstance3D | null = null;
+
   override update(dt: number): void {
     this.clock += dt * 1000;
 
@@ -192,6 +196,11 @@ export class Shoot extends Behavior {
     this.ammo--;
     this.muzzle('ShotSfx')?.play();
     this.flashUntil = this.clock + FLASH_MS;
+    // The shot plays on the UPPER BODY only — `animation` (idle/run, driven by
+    // the controller) keeps the legs going, so the soldier fires while running
+    // instead of freezing mid-stride. A one-shot: the layer clears itself when
+    // the clip ends, and a shot fired before that restarts it.
+    if (this.skin) this.skin.animationUpper = '$anims/shoot';
 
     const eye = this.eye();
     const fwd = this.forward();

package/templates-app/tps-3d/src/cover.scene.json

@@ -0,0 +1,26 @@
+{
+  "format": 1,
+  "type": "scene",
+  "dimension": "3d",
+  "name": "Cover",
+  "root": {
+    "name": "Cover",
+    "type": "StaticBody3D",
+    "props": { "collider": { "shape": "box", "size": [2, 1.2, 2] } },
+    "children": [
+      {
+        "name": "Skin",
+        "type": "MeshInstance3D",
+        "props": {
+          "mesh": "box",
+          "size": [2, 1.2, 2],
+          "material": { "color": "#5b6678", "roughness": 0.85, "metalness": 0.1 },
+          "castShadow": true,
+          "receiveShadow": true
+        },
+        "uid": "n_wgm7e7zg55s8ugcn"
+      }
+    ],
+    "uid": "n_z4ycq2ses8kh87zd"
+  }
+}