create-aura3d 3.0.1 → 4.0.0

package/templates/mini-game/src/main.ts

@@ -1,14 +1,20 @@
 import {
   camera,
-  createAuraApp,
   game,
+  gameFeel,
+  looks,
   material,
   model,
-  primitives,
   scene,
-  type AuraLeanNodeBuilder,
-  type LeanPlatformerEvent
-} from "@aura3d/lean/game";
+  type AuraNodeBuilder,
+  type AuraSceneNode,
+  type GamePlatformerEvent,
+  type GamePlatformerSnapshot
+} from "@aura3d/engine";
+// PRD-09: mounted via the shared runtime — createGame owns mount/lifecycle,
+// the §7.7 tabletop HUD theme, the §6.11 dpad-2btn touch preset, game-sfx-core
+// cues, and the juice event map.
+import { createGame, sfxUrl } from "@aura3d/engine/game";
 import { assets } from "./aura-assets";
 
 declare global {
@@ -25,13 +31,23 @@ interface MiniGameEvidence {
   readonly hero: { readonly assetId: string; readonly url: string };
   readonly player: { readonly x: number; readonly y: number; readonly grounded: boolean };
   readonly events: readonly string[];
-  readonly cameraRig: { readonly kind: string; readonly position: readonly [number, number, number] };
-  readonly gameFeel: { readonly trauma: number; readonly frozen: boolean };
-  readonly debugDraw: boolean;
-  readonly governor: { readonly resolutionScale: number; readonly particleScale: number };
-  readonly evidence: { readonly entry: string; readonly physics: string; readonly typedAssets: number };
+  readonly look: { readonly id: string; readonly category: string };
+  readonly animation: {
+    readonly clip: string;
+    readonly clips: readonly string[];
+    readonly tracksApplied: number;
+  };
+  readonly camera: {
+    readonly rig: string;
+    readonly presented: boolean;
+  };
+  readonly evidence: { readonly entry: string; readonly typedAssets: number };
 }
 
+// The look sets palette + sky + sun + fog + grade; the scene adds only the
+// foreground. Genre row (aura3d-browser-game): mini-game → outdoor-day.
+const LOOK_ID = "outdoor-day" as const;
+
 const level = {
   start: { x: 0, y: 0.35 },
   finish: { x: 12.4, y: 0.35 },
@@ -56,46 +72,101 @@ const level = {
   dashSpeed: 9.5
 };
 
-const input = game.input({
+// Side-follow framing: the camera sits 10.4 m off the play plane and tracks
+// the hero on x only (side-scroller). The C-22 rig is the live camera
+// surface; the mounted rig owns the presented pose.
+const CAMERA_OFFSET = { y: 3.45, z: 10.4, targetY: 0.47 } as const;
+
+const inputOptions = {
   actions: {
     left: ["KeyA", "ArrowLeft"],
     right: ["KeyD", "ArrowRight"],
     jump: ["Space", "KeyW", "ArrowUp"],
     dash: ["ShiftLeft", "ShiftRight"],
     down: ["KeyS", "ArrowDown"],
-    reset: ["KeyR"],
-    debug: ["KeyT"]
+    reset: ["KeyR"]
   },
   axes: { moveX: { negative: "left", positive: "right" } },
   bufferMs: 140
-});
+} as const;
 const platformer = game.platformer(level);
-// J3 scaffold surface: camera rig frames the opening shot, game feel adds
-// trauma/shake on impacts, the debug toggle gates overlays, and the lean perf
-// governor degrades resolution/particle scale when frames run long.
-const cameraRig = game.cameraRig({ kind: "side-view-follow", offset: [0, 2.98, 10.4] });
-const gameFeel = game.gameFeel();
-const debugDraw = game.debugDraw();
-const governor = game.performanceGovernor("conservative");
 const routeEvents: string[] = [];
-const app = createAuraApp("#app", { scene: buildScene() });
+
+const miniGame = createGame({
+  id: "mini-game",
+  target: "#app",
+  autoStart: true,
+  scene: buildScene,
+  input: inputOptions,
+  hud: { theme: "tabletop", widgets: [] },
+  touch: {
+    preset: "dpad-2btn",
+    bindings: { left: "left", right: "right", dash: "dash", jump: "jump", attack: "down" }
+  },
+  sound: {
+    cues: {
+      collect: { id: "collect", asset: { url: sfxUrl("pickup.coin.00") }, volume: 0.7 },
+      checkpoint: { id: "checkpoint", asset: { url: sfxUrl("stinger.checkpoint.00") }, volume: 0.7 },
+      complete: { id: "complete", asset: { url: sfxUrl("stinger.win.00") }, volume: 0.8 },
+      hazard: { id: "hazard", asset: { url: sfxUrl("impact.rubber-ball.heavy.00") }, volume: 0.7 },
+      land: { id: "land", asset: { url: sfxUrl("impact.rubber-ball.light.00") }, volume: 0.35 },
+      jump: { id: "jump", asset: { url: sfxUrl("ui.toggle.00") }, volume: 0.4 }
+    }
+  },
+  juice: {
+    collect: { punch: { fovDeg: 1.2, ms: 140 }, flash: { color: "#f7d76b", peak: 0.12, ms: 160 } },
+    checkpoint: { punch: { fovDeg: 1.6, ms: 200 }, flash: { color: "#9df59e", peak: 0.16, ms: 220 } },
+    complete: { hitStop: 0.06, punch: { fovDeg: 2.4, ms: 360 }, rumble: { strong: 0.7, ms: 320 } },
+    hazard: { shake: 0.45, hitStop: 0.04, flash: { color: "#f06b7a", peak: 0.28, ms: 240 }, rumble: { strong: 0.5, ms: 200 } },
+    land: { shake: 0.12 },
+    jump: {}
+  },
+  qualityRebuild: { flags: ["game"] },
+  evidence: {
+    schema: 1,
+    sections: { miniGame: () => window.__AURA3D_MINI_GAME__ ?? { status: "unbound" } }
+  }
+});
+const app = miniGame.app;
+miniGame.start();
+const input = miniGame.input;
+if (!input) throw new Error("create-aura3d mini-game failed to create runtime-owned input.");
+
 const player = app.nodes.require("mini-player");
 const lift = app.nodes.require("platform-lift");
 const coins = level.collectibles.map((coin) => [coin.id, app.nodes.require(`coin-${coin.id}`)] as const);
 const checkpoint = app.nodes.require("checkpoint-mid");
 const goal = app.nodes.require("goal");
 const hudRoot = createHud();
-let objective = "Collect coins, avoid spikes, reach the goal";
+let objective = "Collect stars, avoid the hazard, reach the gate";
+// Locomotion states map onto the KayKit barbarian's clip names (the
+// catalog hero's literal clip ids are replaced by the library rig's).
+const LOCOMOTION_CLIPS = {
+  idle: "Idle",
+  walk: "Walking_A",
+  sprint: "Running_A",
+  jump: "Jump_Start",
+  fall: "Jump_Idle"
+} as const;
+type LocomotionState = keyof typeof LOCOMOTION_CLIPS;
+let activeClip: LocomotionState = "idle";
+player.play(LOCOMOTION_CLIPS.idle);
+
+// Mount the C-22 camera surface (stub controller flag-off, real under PRD 08).
+// F-08-1: the follow2d rig owns the presented camera (flag-off mounts the
+// no-op stub controller, so the scene's camera.follow spec stays the
+// fallback). F-08-5: feel bus + GameFeel attach through app.time.
+app.camera?.use(
+  camera.rigs.follow2d({ target: "mini-player", framing: { subjectHeightFraction: 0.28 } })
+);
+const feel = gameFeel.create({ app, time: app.time });
+app.feel?.preset("platformer");
 
-app.onFrame((dt) => {
-  input.update(dt);
-  governor.step(Math.max(0, dt) * 1000);
-  gameFeel.update(Math.max(0, dt));
-  if (input.pressed("debug")) debugDraw.toggle();
+app.onFrame(({ dt }) => {
   if (input.pressed("reset")) {
     platformer.reset();
     routeEvents.push("reset:Route reset");
-    objective = "Collect coins, avoid spikes, reach the goal";
+    objective = "Collect stars, avoid the hazard, reach the gate";
   }
   const moveX = input.axis("moveX");
   const jumpPressed = input.buffered("jump");
@@ -114,34 +185,36 @@ app.onFrame((dt) => {
     });
     for (const event of state.events) {
       updateObjective(event);
-      if (event.type === "collect") gameFeel.addTrauma(0.25);
-      if (event.type === "hazard" || event.type === "fall") {
-        gameFeel.addTrauma(0.7);
-        gameFeel.hitStop();
+      if (event.type === "collect" || event.type === "checkpoint" || event.type === "complete" || event.type === "hazard" || event.type === "land") {
+        miniGame.juice.fire(event.type);
+        void miniGame.sound?.cue(event.type);
       }
-      if (event.type === "land") gameFeel.addTrauma(0.12);
+      if (event.type === "jump") void miniGame.sound?.cue("jump");
     }
     remaining -= substep;
     firstSubstep = false;
   } while (remaining > 0.000_001);
 
-  // The certified Oobi hero is feet-origin (GLB min y = 0), so the visual
-  // rides at the physics point instead of the old fixture's +0.5 lift.
+  // The KayKit barbarian hero is feet-origin (GLB min y = 0), so the visual
+  // rides at the physics point instead of a +0.5 lift.
   player.setPosition(state.player.x + 0.38, state.player.y + 0.01, 0);
+  player.setRotation(0, state.player.facing === 1 ? Math.PI / 2 : -Math.PI / 2, 0);
+  playLocomotionClip(state);
   lift.setPosition(level.movingPlatforms[0].x + level.movingPlatforms[0].width / 2, movingLiftY(state.time), 0);
   for (const [id, node] of coins) node.setVisible(!state.collected.includes(id));
   checkpoint.setVisible(!state.activatedCheckpoints.includes("mid"));
-  goal.setScale(state.status === "completed" ? [0.28, 1.08, 0.18] : [0.22, 0.92, 0.16]);
+  goal.setScale(state.status === "completed" ? [1.35, 1.35, 1.35] : 1);
+  feel.update(dt * 1000);
   renderHud(state);
   publishEvidence(state);
 });
 
 publishEvidence(platformer.snapshot());
 renderHud(platformer.snapshot());
-void app.ready().then(() => {
+void miniGame.ready().then(() => {
   const diagnostics = app.diagnostics();
   document.body.dataset.aura3dReady = "true";
-  document.body.dataset.aura3dRuntimeBackend = diagnostics.runtimeBackend;
+  document.body.dataset.aura3dRuntimeBackend = diagnostics.backend;
   document.body.dataset.aura3dDrawCalls = String(diagnostics.drawCalls);
   (window as unknown as { __AURA3D_ROUTE_READY__?: unknown }).__AURA3D_ROUTE_READY__ = { ready: true, diagnostics };
 }).catch((error: unknown) => {
@@ -149,33 +222,85 @@ void app.ready().then(() => {
 });
 
 function buildScene() {
-  const nodes: AuraLeanNodeBuilder[] = [
-    ...level.platforms.map((platform) => primitives.box({ name: `${platform.id} platform`, material: material.pbr({ color: "#62d8ef", roughness: 0.28 }) })
-      .position(platform.x + platform.width / 2, platform.y + platform.height / 2, -0.05).scale([platform.width, platform.height, 0.22])),
-    primitives.box({ name: "moving lift platform", material: material.pbr({ color: "#b5f77d", roughness: 0.24 }) })
-      .position(level.movingPlatforms[0].x + level.movingPlatforms[0].width / 2, movingLiftY(0), 0)
-      .scale([level.movingPlatforms[0].width, level.movingPlatforms[0].height, 0.22]).runtime("platform-lift"),
-    ...level.collectibles.map((coin) => primitives.sphere({ name: `${coin.id} collectible`, material: material.pbr({ color: "#f7d76b", metallic: 0.35, roughness: 0.22 }) })
-      .position(coin.x, coin.y, 0.02).scale(0.18).runtime(`coin-${coin.id}`)),
-    primitives.box({ name: "hazard spikes", material: material.pbr({ color: "#f06b7a", roughness: 0.2 }) })
-      .position(level.hazards[0].x + level.hazards[0].width / 2, level.hazards[0].y + level.hazards[0].height / 2, 0.05)
-      .scale([level.hazards[0].width, level.hazards[0].height, 0.2]),
-    primitives.box({ name: "checkpoint marker", material: material.pbr({ color: "#9df59e", roughness: 0.2 }) })
-      .position(level.checkpoints[0].x, level.checkpoints[0].y + 0.42, 0.08).scale([0.14, 0.85, 0.14]).runtime("checkpoint-mid"),
-    primitives.box({ name: "finish portal", material: material.pbr({ color: "#ffad57", metallic: 0.2, roughness: 0.18 }) })
-      .position(level.finish.x, level.finish.y + 0.7, 0.08).scale([0.22, 0.92, 0.16]).runtime("goal")
+  // Platform geometry comes from the library crate (PRD 05 template-starters
+  // swap, #481 mapping); the 0.824 m cube scales to each collision rect.
+  const block = assets.quaterniusCrate;
+  const BLOCK_SIZE = assets.quaterniusCrate.bounds;
+  const blockScale = (width: number, height: number, depth: number) =>
+    [width / BLOCK_SIZE[0], height / BLOCK_SIZE[1], depth / BLOCK_SIZE[2]] as const;
+  const nodes: AuraNodeBuilder<AuraSceneNode>[] = [
+    ...level.platforms.map((platform) =>
+      model(block, { name: `${platform.id} platform` })
+        .position(platform.x + platform.width / 2, platform.y, -0.05)
+        .scale(blockScale(platform.width, platform.height, 1.24))),
+    ...level.movingPlatforms.map((platform) =>
+      model(assets.quaterniusCubeCrate, { name: `${platform.id} moving platform` })
+        .position(platform.x + platform.width / 2, movingLiftY(0) - platform.height / 2, 0)
+        .scale([platform.width / assets.quaterniusCubeCrate.bounds[0], platform.height / assets.quaterniusCubeCrate.bounds[1], 0.7])
+        .runtime(game.runtimeNode("platform-lift", { tags: ["platform", "moving"] }))),
+    // Stars are models, not primitives: emissive 3–5 reads as coin sparkle
+    // under the daylight-outdoor grade.
+    ...level.collectibles.map((coin) =>
+      model(assets.kenneyPlatformerKitStar, {
+        name: `${coin.id} collectible`,
+        material: material.emissive({ color: "#ffd54d", emissive: "#ffd54d", emissiveIntensity: 4, roughness: 0.3 })
+      })
+        .position(coin.x, coin.y, 0.02)
+        .scale(1.15)
+        .runtime(game.runtimeNode(`coin-${coin.id}`, { tags: ["collectible"] }))),
+    model(assets.quaterniusCubeCrate, {
+      name: "spikes hazard",
+      material: material.emissive({ color: "#e5484d", emissive: "#e5484d", emissiveIntensity: 0.9, roughness: 0.4 })
+    })
+      .position(level.hazards[0].x + level.hazards[0].width / 2, level.hazards[0].y, 0.05)
+      .scale([level.hazards[0].width / assets.quaterniusCubeCrate.bounds[0], level.hazards[0].height / assets.quaterniusCubeCrate.bounds[1], 0.5]),
+    model(assets.kenneyPlatformerKitKey, { name: "checkpoint key" })
+      .position(level.checkpoints[0].x, level.checkpoints[0].y + 0.2, 0.08)
+      .scale(2)
+      .runtime(game.runtimeNode("checkpoint-mid", { tags: ["checkpoint"] })),
+    model(assets.kenneyPlatformerKitStar, {
+      name: "finish gate",
+      material: material.emissive({ color: "#ffd54d", emissive: "#ffd54d", emissiveIntensity: 3, roughness: 0.3 })
+    })
+      .position(level.finish.x, level.finish.y + 0.5, 0.08)
+      .scale(3.4)
+      .runtime(game.runtimeNode("goal", { tags: ["finish"] }))
   ];
-  // Opening shot is framed by the side-view camera rig. The offset reproduces
-  // the certified framing exactly (position [6.1, 3.8, 10.4], target
-  // [6.1, 0.82, 0]) so screenshot baselines do not shift.
-  const opening = cameraRig.snap([6.1, 0.82, 0]);
-  return scene().background("#071015")
-    .add(model(assets.showcaseKenneyOobiPlatformerHero, { name: "certified hero vehicle-driver" }).position(level.start.x + 0.38, level.start.y + 0.01, 0).scale(1).runtime("mini-player"))
+  // The scene-level follow spec frames the hero today; the C-22 rig (mounted
+  // above build) owns presented camera state once PRD 08 lands.
+  return scene()
+    .add(looks.preset(LOOK_ID))
+    .add(
+      model(assets.kaykitBarbarian, { name: "certified hero" })
+        .position(level.start.x + 0.38, level.start.y + 0.01, 0)
+        // Barbarian is 2.4 m tall vs the 0.9 m hero the level was tuned for.
+        .scale(0.91 / assets.kaykitBarbarian.bounds[1])
+        .runtime(game.runtimeNode("mini-player", { tags: ["player"] }))
+    )
     .addMany(nodes)
-    .camera(camera.perspective({ position: [opening[0], opening[1], opening[2]], target: [6.1, 0.82, 0], fov: 46 }));
+    .camera(
+      camera.follow({
+        targetNode: "mini-player",
+        position: [level.start.x, level.start.y + CAMERA_OFFSET.y, CAMERA_OFFSET.z],
+        target: [level.start.x, level.start.y + CAMERA_OFFSET.targetY, 0],
+        fov: 50
+      })
+    );
+}
+
+function playLocomotionClip(state: GamePlatformerSnapshot): void {
+  // C-19 stub surface: `play` switches clips immediately (`crossFadeTo` is the
+  // PRD 06 blend path on the same handle when it lands).
+  const next: LocomotionState = !state.player.grounded
+    ? state.player.vy > 0 ? "jump" : "fall"
+    : Math.abs(state.player.vx) > level.dashSpeed * 0.7 ? "sprint"
+      : Math.abs(state.player.vx) > 0.4 ? "walk" : "idle";
+  if (next === activeClip) return;
+  activeClip = next;
+  player.play(LOCOMOTION_CLIPS[next]);
 }
 
-function updateObjective(event: LeanPlatformerEvent): void {
+function updateObjective(event: GamePlatformerEvent): void {
   routeEvents.push(event.id ? `${event.type}:${event.id}` : event.type);
   if (routeEvents.length > 16) routeEvents.shift();
   if (event.type === "checkpoint") objective = "Checkpoint reached. Finish the route.";
@@ -191,16 +316,17 @@ function movingLiftY(time: number): number {
 function createHud(): HTMLElement {
   const root = document.createElement("aside");
   root.id = "mini-game-hud";
-  root.style.cssText = "position:absolute;left:16px;top:16px;z-index:5;min-width:260px;font:600 13px/1.35 Inter,system-ui,sans-serif;color:#f5fbff;background:rgba(3,9,14,.78);border:1px solid rgba(125,220,235,.34);border-radius:8px;padding:12px;pointer-events:none";
+  root.style.cssText = "position:absolute;left:16px;top:16px;z-index:5;min-width:260px;font:600 13px/1.35 Inter,system-ui,sans-serif;color:#f5fbff;background:rgba(6,18,26,.66);border:1px solid rgba(160,210,240,.34);border-radius:8px;padding:12px;pointer-events:none";
   document.body.append(root);
   return root;
 }
 
-function renderHud(state: ReturnType<typeof platformer.snapshot>): void {
+function renderHud(state: GamePlatformerSnapshot): void {
   hudRoot.innerHTML = `<strong>Aura3D Mini Game</strong><div>Score ${state.score} | Lives ${state.lives} | Deaths ${state.deaths}</div><div>Checkpoint ${state.checkpointId}</div><div>${objective}</div><div>Move A/D or arrows. Jump Space. Dash Shift. Reset R.</div>`;
 }
 
-function publishEvidence(state: ReturnType<typeof platformer.snapshot>): void {
+function publishEvidence(state: GamePlatformerSnapshot): void {
+  const animation = player.importedAssetEvidence();
   window.__AURA3D_MINI_GAME__ = {
     status: state.status,
     frame: state.frame,
@@ -208,13 +334,20 @@ function publishEvidence(state: ReturnType<typeof platformer.snapshot>): void {
     deaths: state.deaths,
     checkpointId: state.checkpointId,
     collected: state.collected,
-    hero: { assetId: assets.showcaseKenneyOobiPlatformerHero.id, url: assets.showcaseKenneyOobiPlatformerHero.url },
+    hero: { assetId: assets.kaykitBarbarian.id, url: assets.kaykitBarbarian.url },
     player: { x: state.player.x, y: state.player.y, grounded: state.player.grounded },
     events: [...routeEvents],
-    cameraRig: { kind: cameraRig.kind, position: cameraRig.follow([state.player.x, state.player.y, 0], 1 / 60) },
-    gameFeel: gameFeel.snapshot(),
-    debugDraw: debugDraw.enabled,
-    governor: { ...governor.settings },
-    evidence: { entry: "@aura3d/lean/game", physics: "solver-free deterministic arcade", typedAssets: Object.keys(assets).length }
+    look: { id: LOOK_ID, category: looks.describe(LOOK_ID).category },
+    animation: {
+      clip: activeClip,
+      clips: animation?.clips ?? [],
+      // Report-only while the C-19 handle is a stub (T3.1 test reads it).
+      tracksApplied: animation?.lastMaterialTracksApplied ?? 0
+    },
+    camera: {
+      rig: app.camera?.rig.id ?? "scene-follow",
+      presented: app.camera !== undefined
+    },
+    evidence: { entry: "@aura3d/engine/game createGame", typedAssets: Object.keys(assets).length }
   };
 }

package/templates/mini-game/tests/certified-rig.spec.ts

@@ -3,7 +3,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { expect, test } from "@playwright/test";
 
-test.setTimeout(60_000);
+test.setTimeout(240_000);
 
 /**
  * E1 certified-rig mount proof for the mini-game template.
@@ -31,7 +31,7 @@ const CERTIFIED_HERO = certifiedHeroFromTypedAssets();
 
 test("mini-game hero mounts the certified vehicle-driver rig", async ({ page }) => {
   await page.goto("/");
-  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 45_000 }).toBe("true");
+  await expect.poll(() => page.locator("body").getAttribute("data-aura3d-ready"), { timeout: 150_000 }).toBe("true");
   const hero = await page.evaluate(
     () => (window as unknown as { readonly __AURA3D_MINI_GAME__?: { readonly hero?: { readonly assetId?: string; readonly url?: string } } }).__AURA3D_MINI_GAME__?.hero
   );