create-aura3d 3.0.0 → 4.0.0

package/templates/racing-starter/src/main.ts

@@ -1,14 +1,18 @@
 import {
   camera,
-  createAuraApp,
   game,
-  lights,
+  gameFeel,
+  looks,
   material,
   model,
   primitives,
   scene,
   type AuraNodeInput
 } from "@aura3d/engine";
+// PRD-09: mounted via the shared runtime — createGame owns mount/lifecycle,
+// the §7.7 HUD theme, the §6.11 steer-pedals touch preset, game-sfx-core
+// cues, and the juice event map (no route-local flash/hit-stop code).
+import { createGame, sfxUrl } from "@aura3d/engine/game";
 import { assets } from "./aura-assets";
 
 declare global {
@@ -28,48 +32,65 @@ interface RacingStarterEvidence {
   readonly heading: number;
   readonly position: { readonly x: number; readonly y: number };
   readonly events: readonly string[];
-  readonly lapProof: {
-    readonly status: string;
-    readonly events: readonly string[];
-    readonly bestTime?: number;
-    readonly checkpointCount: number;
-    readonly lapsToWin: number;
-    readonly minLapSeconds: number;
-    readonly routeAlignedToVisibleTrack: boolean;
+  readonly look: { readonly id: string; readonly category: string };
+  readonly geometry: {
+    readonly tool: string;
+    readonly report: string;
+    readonly carMetres: readonly number[];
+    readonly trackMetres: readonly number[];
+    readonly carScale: number;
+    readonly routeScale: number;
+  };
+  readonly camera: {
+    readonly rig: string;
+    readonly presented: boolean;
   };
   readonly evidence: unknown;
 }
 
-const raceContract = {
-  checkpointCount: 6,
-  lapsToWin: 3,
-  minLapSeconds: 30,
-  routeAlignedToVisibleTrack: true
-} as const;
-
-const routeRibbonSegments = [
-  ["route south straight", [2.8, 0.03, 0], [5.8, 0.08, 0.58]],
-  ["route east straight", [5.6, 0.03, 1.7], [0.58, 0.08, 3.6]],
-  ["route north straight", [2.8, 0.03, 3.4], [5.8, 0.08, 0.58]],
-  ["route west straight", [0, 0.03, 1.7], [0.58, 0.08, 3.6]]
-] as const;
+// The look sets sky + sun + fog + grade; the scene adds only the foreground.
+// Genre row (aura3d-browser-game): racing-starter → golden-hour, chase fov 60.
+const LOOK_ID = "golden-hour" as const;
 
+// Both showcase GLBs are authored at real scale: the car measures
+// 3.455 × 3.428 × 2.206 m and the kart circuit 24.651 × 24.647 × 2.073 m, so
+// the models mount at scale 1 (the former 0.18 shrink is removed). The logical
+// route is scaled by the same factor the track grew (24.651 / 6.65 ≈ 3.7 → 3.5)
+// so the driven line still traces inside the visible circuit footprint.
+const ROUTE_SCALE = 3.5;
 const route = {
   id: "starter-kart-loop",
-  width: 2.2,
+  width: 2.2 * ROUTE_SCALE,
   points: [
-    { x: -0.4, y: -0.25 },
-    { x: 2.4, y: -0.9 },
-    { x: 5.4, y: 0.15 },
-    { x: 5.9, y: 2.7 },
-    { x: 3.2, y: 3.9 },
-    { x: 0.3, y: 3.15 },
-    { x: -0.75, y: 1.15 }
+    { x: -0.4 * ROUTE_SCALE, y: -0.25 * ROUTE_SCALE },
+    { x: 2.4 * ROUTE_SCALE, y: -0.9 * ROUTE_SCALE },
+    { x: 5.4 * ROUTE_SCALE, y: 0.15 * ROUTE_SCALE },
+    { x: 5.9 * ROUTE_SCALE, y: 2.7 * ROUTE_SCALE },
+    { x: 3.2 * ROUTE_SCALE, y: 3.9 * ROUTE_SCALE },
+    { x: 0.3 * ROUTE_SCALE, y: 3.15 * ROUTE_SCALE },
+    { x: -0.75 * ROUTE_SCALE, y: 1.15 * ROUTE_SCALE }
   ],
   checkpoints: [0.14, 0.27, 0.4, 0.53, 0.66, 0.79]
 };
 
-const input = game.input({
+// The circuit GLB is origin-centred (±12.3 m on x/z). Placing it under the
+// scaled route's bounding-box centre keeps the visible ribbon over the route.
+const ROUTE_BOUNDS = {
+  centerX: ((-0.75 + 5.9) / 2) * ROUTE_SCALE,
+  centerZ: ((-0.9 + 3.9) / 2) * ROUTE_SCALE
+} as const;
+
+// GLB z-extent normalizes to world height: track top surface sits at y=0 when
+// the model is dropped by its 1.0 m max. The car's raw min-y is -1.206 m, so
+// the ride height lifts it until the wheels rest on that surface.
+const TRACK_Y = -1.0;
+const CAR_RIDE_Y = 1.206;
+
+// Chase framing: 8 m back and 3.4 m up at fov 60 — authored in the scene spec
+// below as the flag-off fallback; the mounted rig owns it under PRD 08.
+const CHASE = { back: 8, up: 3.4, ahead: 4, fov: 60 } as const;
+
+const inputOptions = {
   actions: {
     throttle: ["KeyW", "ArrowUp"],
     brake: ["KeyS", "ArrowDown"],
@@ -83,32 +104,78 @@ const input = game.input({
     steer: { negative: "left", positive: "right" }
   },
   bufferMs: 80
-});
+} as const;
 
 const racing = game.racing({
   route,
   startProgress: 0.04,
   checkpointRadius: 0.08,
-  lapsToWin: raceContract.lapsToWin,
-  maxSpeed: 11.5,
-  acceleration: 18,
+  lapsToWin: 3,
+  maxSpeed: 40,
+  acceleration: 60,
   drag: 1.4,
-  steerRate: 2.85
+  steerRate: 2.85,
+  // F-08-1: bicycle vehicle model + V-5 chassis presentation publish the
+  // vLong/lateralG telemetry the chase rig's perSpeed FOV and bank read.
+  model: "bicycle",
+  chassis: true,
+  // F-08-5: kit edges (boost/drift/collision/lap) emit on the app feel bus.
+  feelBus: { emit: (name, o) => app?.feel?.emit(name, { strength: o?.strength }) }
 });
 
 const routeEvents = game.eventLog({ label: "racing starter events", maxEvents: 16 });
-const hud = game.hud.bindings([
-  game.hud.objective({ valuePath: "appState.objective" }),
-  game.hud.timer({ valuePath: "appState.lapTime" }),
-  game.hud.checkpoint({ valuePath: "appState.checkpoint" }),
-  game.hud.eventLog({ valuePath: "appState.events" })
-]);
-const lapProof = createLapProof();
+// HUD bindings as descriptor literals (the deprecated game.hud.* helpers are
+// replaced by the createGame `hud` option + evidence channel sections).
+const hudBindings = [
+  { kind: "aura-game-hud-binding", owner: "app", binding: "objective", id: "hud:objective", label: "objective", source: "app-state", valuePath: "appState.objective", format: "text", a11yLabel: "current objective" },
+  { kind: "aura-game-hud-binding", owner: "app", binding: "timer", id: "hud:round:timer", label: "Round timer", source: "app-state", valuePath: "appState.lapTime", format: "clock", a11yLabel: "lap timer" },
+  { kind: "aura-game-hud-binding", owner: "app", binding: "checkpoint", id: "hud:checkpoint", label: "checkpoint", source: "app-state", valuePath: "appState.checkpoint", format: "text", a11yLabel: "current checkpoint" },
+  { kind: "aura-game-hud-binding", owner: "app", binding: "event-log", id: "hud:event-log", label: "event log", source: "app-state", valuePath: "appState.events", format: "text", a11yLabel: "game event log", debugOnly: true }
+] as const;
 
-const app = createAuraApp("#app", {
+const racingGame = createGame({
+  id: "racing-starter",
+  target: "#app",
   diagnostics: { overlay: true, performancePanel: true },
-  scene: buildScene()
+  scene: buildScene,
+  input: inputOptions,
+  hud: { theme: "motorsport", widgets: [] },
+  touch: {
+    preset: "steer-pedals",
+    bindings: {
+      "steer-left": "left",
+      "steer-right": "right",
+      throttle: "throttle",
+      brake: "brake",
+      boost: "boost",
+      reset: "reset"
+    }
+  },
+  sound: {
+    cues: {
+      checkpoint: { id: "checkpoint", asset: { url: sfxUrl("stinger.checkpoint.00") }, volume: 0.7 },
+      lap: { id: "lap", asset: { url: sfxUrl("ui.confirm.00") }, volume: 0.7 },
+      finish: { id: "finish", asset: { url: sfxUrl("stinger.win.00") }, volume: 0.8 },
+      "off-track": { id: "off-track", asset: { url: sfxUrl("impact.rubber-ball.light.00") }, volume: 0.5 },
+      boost: { id: "boost", asset: { url: sfxUrl("vehicle.boost") }, volume: 0.6 }
+    }
+  },
+  juice: {
+    checkpoint: { punch: { fovDeg: 1.4, ms: 160 }, flash: { color: "#7ff0c5", peak: 0.14, ms: 180 } },
+    lap: { shake: 0.2, punch: { fovDeg: 2, ms: 240 } },
+    finish: { hitStop: 0.05, punch: { fovDeg: 2.6, ms: 320 }, rumble: { strong: 0.6, ms: 300 } },
+    "off-track": { shake: 0.35, rumble: { weak: 0.5, ms: 160 } }
+  },
+  qualityRebuild: { flags: ["game"] },
+  evidence: {
+    schema: 1,
+    sections: { racingStarter: () => window.__AURA3D_RACING_STARTER__ ?? { status: "unbound" } }
+  }
 });
+const app = racingGame.app;
+racingGame.start();
+const input = racingGame.input;
+if (!input) throw new Error("create-aura3d racing-starter failed to create runtime-owned input.");
 
 const car = app.nodes.require("race-car");
 const checkpointMarker = app.nodes.require("checkpoint-marker");
@@ -117,8 +184,22 @@ const hudRoot = createHud();
 let objective = "Clear six gates across a 3-lap typed-asset route.";
 const raceEventLabels: string[] = [];
 
-app.onFrame(({ dt }: { readonly dt: number }) => {
-  input.update(dt);
+// F-08-1: the chase rig owns the presented camera — speed-scaled FOV,
+// velocity look-ahead and lateral bank come from the rig spec (flag-off
+// mounts the no-op stub controller; the scene camera spec is the fallback).
+// F-08-5: feel bus + GameFeel attach through app.time.
+app.camera?.use(
+  camera.rigs.chase({
+    target: "race-car",
+    fov: { base: 60, perSpeed: 0.4 },
+    lookAhead: { seconds: 0.35, max: 4 },
+    bank: { gain: 0.5, maxDeg: 6 }
+  })
+);
+const feel = gameFeel.create({ app, time: app.time });
+app.feel?.preset("racing");
+
+app.onFrame(({ dt }) => {
   if (input.pressed("reset")) {
     racing.reset(0);
     routeEvents.push({ type: "reset", label: "reset" });
@@ -148,15 +229,20 @@ app.onFrame(({ dt }: { readonly dt: number }) => {
     if (event.type === "lap") objective = `Lap ${state.lap}/${state.lapsToWin}. Keep the line.`;
     if (event.type === "finish") objective = "Finished. Press R to run it again.";
     if (event.type === "off-track") objective = "Back onto the racing line.";
+    if (event.type === "checkpoint" || event.type === "lap" || event.type === "finish" || event.type === "off-track") {
+      racingGame.juice.fire(event.type);
+      void racingGame.sound?.cue(event.type);
+    }
   }
+  if (input.pressed("boost")) void racingGame.sound?.cue("boost");
 
   car
-    .setPosition(state.position.x, 0.32, state.position.y)
-    .setRotation(0, -state.heading + Math.PI / 2, 0)
-    .setScale(state.drift > 0.15 ? [0.2, 0.2, 0.22] : [0.18, 0.18, 0.18]);
+    .setPosition(state.position.x, CAR_RIDE_Y, state.position.y)
+    .setRotation(0, -state.heading + Math.PI / 2, 0);
   checkpointMarker.setVisible(state.checkpoint === 0);
   finishMarker.setScale(state.status === "finished" ? [1.15, 0.08, 0.14] : [0.86, 0.08, 0.12]);
 
+  feel.update(dt * 1000);
   renderHud(state);
   publishEvidence(state);
 });
@@ -164,70 +250,32 @@ app.onFrame(({ dt }: { readonly dt: number }) => {
 publishEvidence(racing.snapshot());
 renderHud(racing.snapshot());
 
+
 function buildScene() {
   const nodes: AuraNodeInput[] = [
+    // Real-scale assets: kart circuit 24.651 m, sports car 3.455 m (aura-assets
+    // bounds). No 0.18 shrink — see CAR_RIDE_Y / ROUTE_SCALE comments above.
     model(assets.trackModel, { name: "typed kart circuit asset" })
-      .position(2.8, -0.08, 1.7)
-      .scale(0.18),
+      .position(ROUTE_BOUNDS.centerX, TRACK_Y, ROUTE_BOUNDS.centerZ)
+      .scale(1),
     model(assets.carModel, { name: "typed playable sports car", castShadow: true })
-      .position(0, 0.32, 0)
-      .scale(0.18)
+      .position(0, CAR_RIDE_Y, 0)
+      .scale(1)
       .runtime(game.runtimeNode("race-car", { tags: ["player", "vehicle", "typed-asset", "runtime"] })),
-    ...routeRibbonNodes(),
-    ...paintAndGlassGantryNodes(),
     primitives.box({ name: "checkpoint marker", material: material.neon({ color: "#7ff0c5", emissive: "#7ff0c5", emissiveIntensity: 0.7 }) })
-      .position(0.06, 0.18, 0.2)
-      .scale([0.16, 0.28, 0.95])
+      .position(0.06 * ROUTE_SCALE, CAR_RIDE_Y, 0.2 * ROUTE_SCALE)
+      .scale([0.7, 1.2, 4.2])
       .runtime(game.runtimeNode("checkpoint-marker", { tags: ["checkpoint", "runtime"] })),
     primitives.box({ name: "finish stripe", material: material.neon({ color: "#f9f1d0", emissive: "#f9f1d0", emissiveIntensity: 0.75 }) })
-      .position(0.1, 0.2, 0.05)
-      .scale([0.86, 0.08, 0.12])
+      .position(0.1 * ROUTE_SCALE, CAR_RIDE_Y - 0.1, 0.05 * ROUTE_SCALE)
+      .scale([3.8, 0.36, 0.5])
       .runtime(game.runtimeNode("finish-marker", { tags: ["finish", "runtime"] }))
   ];
 
   return scene()
-    .background("#060b10")
+    .add(looks.preset(LOOK_ID))
     .addMany(nodes)
-    .add(lights.ambient({ name: "race ambient", intensity: 0.38, color: "#e9f6ff" }))
-    .add(lights.directional({ name: "race key", position: [4, 7, 5], intensity: 1.1, color: "#ffffff" }))
-    .camera(camera.perspective({ position: [2.7, 7.8, 8.6], target: [2.7, 0, 1.55], fov: 43 }));
-}
-
-function routeRibbonNodes(): AuraNodeInput[] {
-  const asphalt = material.pbr({ color: "#5a6570", roughness: 0.78, metallic: 0.03 });
-  return routeRibbonSegments.map(([name, position, scale]) =>
-    primitives.box({ name, material: asphalt }).position(position[0], position[1], position[2]).scale(scale)
-  );
-}
-
-// PART C2 game-ready adoption: a static paint-and-glass gantry south of the
-// start straight wearing the @aura3d/materials "carPaint" preset (clearcoat
-// shell + flake normal) on the showcase shell and the "glassThin" preset
-// (thin-walled transmission) on the canopy panel.
-function paintAndGlassGantryNodes(): AuraNodeInput[] {
-  const carPaintShell = material.clearcoatPaint({
-    color: "#c1121f",
-    roughness: 0.32,
-    metallic: 0.65,
-    clearcoat: 1,
-    clearcoatRoughness: 0.06,
-    normalScale: 0.35,
-    envMapIntensity: 1.4
-  });
-  const glassThinCanopy = material.glass({
-    color: "#bfe6f2",
-    opacity: 0.35,
-    transmission: 0.9,
-    thickness: 0.02,
-    roughness: 0.05
-  });
-  const post = material.pbr({ color: "#1c2530", roughness: 0.6, metallic: 0.4 });
-  return [
-    primitives.box({ name: "carPaint showcase shell", material: carPaintShell }).position(2.7, 0.3, -1.7).scale([1.5, 0.55, 0.75]),
-    primitives.box({ name: "glassThin canopy", material: glassThinCanopy }).position(2.7, 1.5, -1.7).scale([1.7, 0.06, 0.95]),
-    primitives.box({ name: "gantry post west", material: post }).position(1.95, 0.75, -1.7).scale([0.08, 1.5, 0.08]),
-    primitives.box({ name: "gantry post east", material: post }).position(3.45, 0.75, -1.7).scale([0.08, 1.5, 0.08])
-  ];
+    .camera(camera.perspective({ position: [0, CAR_RIDE_Y + CHASE.up, -CHASE.back], target: [0, CAR_RIDE_Y, 0], fov: CHASE.fov }));
 }
 
 function createHud(): HTMLElement {
@@ -241,8 +289,8 @@ function createHud(): HTMLElement {
     "min-width:290px",
     "font:600 13px/1.35 Inter, system-ui, sans-serif",
     "color:#f5fbff",
-    "background:rgba(3,9,14,0.78)",
-    "border:1px solid rgba(125,220,235,0.34)",
+    "background:rgba(20,12,4,0.66)",
+    "border:1px solid rgba(235,190,125,0.34)",
     "border-radius:8px",
     "padding:12px",
     "pointer-events:none"
@@ -255,7 +303,7 @@ function renderHud(state: ReturnType<typeof racing.snapshot>): void {
   hudRoot.innerHTML = [
     `<strong>Aura3D Racing Starter</strong>`,
     `<div>Lap ${state.lap}/${state.lapsToWin} | Checkpoint ${state.checkpoint}/${state.checkpointCount}</div>`,
-    `<div>Speed ${Math.round(Math.abs(state.speed) * 8)} km/h | Time ${state.lapTime.toFixed(2)}s</div>`,
+    `<div>Speed ${Math.round(Math.abs(state.speed) * 4.2)} km/h | Time ${state.lapTime.toFixed(2)}s</div>`,
     `<div>${objective}</div>`,
     `<div>Throttle W/Up. Steer A/D. Drift Space. Reset R.</div>`
   ].join("");
@@ -265,7 +313,7 @@ function publishEvidence(state: ReturnType<typeof racing.snapshot>): void {
   const evidence = app.evidence({
     input,
     events: routeEvents,
-    hud,
+    hud: hudBindings,
     appState: {
       objective,
       lapTime: state.lapTime,
@@ -289,23 +337,21 @@ function publishEvidence(state: ReturnType<typeof racing.snapshot>): void {
     heading: state.heading,
     position: state.position,
     events: raceEventLabels,
-    lapProof,
+    look: { id: LOOK_ID, category: looks.describe(LOOK_ID).category },
+    geometry: {
+      // Geometry truth comes from the real certify-game-geometry screen output
+      // committed under tests/geometry-certification.json — not from constants.
+      tool: "aura3d assets certify-game-geometry --category racing",
+      report: "tests/geometry-certification.json",
+      carMetres: assets.carModel.bounds ?? [],
+      trackMetres: assets.trackModel.bounds ?? [],
+      carScale: 1,
+      routeScale: ROUTE_SCALE
+    },
+    camera: {
+      rig: app.camera?.rig.id ?? "chase",
+      presented: app.camera !== undefined
+    },
     evidence
   };
 }
-
-function createLapProof(): RacingStarterEvidence["lapProof"] {
-  return {
-    status: "contract-ready",
-    events: [
-      ...route.checkpoints.map((_checkpoint, index) => `checkpoint:checkpoint-${index + 1}`),
-      "lap:multi-lap-contract",
-      "reset:available"
-    ],
-    bestTime: raceContract.minLapSeconds * raceContract.lapsToWin,
-    checkpointCount: raceContract.checkpointCount,
-    lapsToWin: raceContract.lapsToWin,
-    minLapSeconds: raceContract.minLapSeconds,
-    routeAlignedToVisibleTrack: raceContract.routeAlignedToVisibleTrack
-  };
-}

package/templates/racing-starter/tests/geometry-certification.json

@@ -0,0 +1,34 @@
+{
+  "schema": "aura3d.game-geometry-certification/1",
+  "generatedBy": "aura3d assets certify-game-geometry --category racing --assets carModel,trackModel",
+  "result": {
+    "ok": false,
+    "mode": "screen",
+    "wroteManifest": false,
+    "manifestPath": "/home/ubuntu/repos/aura3d/packages/create-aura3d/templates/racing-starter/aura.assets.json",
+    "rows": [
+      {
+        "assetId": "carModel",
+        "category": "racing",
+        "pass": false,
+        "reasons": [
+          "No mesh primitive in carModel has a road/track/asphalt/kerb material or node name."
+        ],
+        "blockers": [
+          "asset-extraction:racing-road-mesh-not-found:carModel"
+        ]
+      },
+      {
+        "assetId": "trackModel",
+        "category": "racing",
+        "pass": false,
+        "reasons": [
+          "No mesh primitive in trackModel has a road/track/asphalt/kerb material or node name."
+        ],
+        "blockers": [
+          "asset-extraction:racing-road-mesh-not-found:trackModel"
+        ]
+      }
+    ]
+  }
+}