create-aura3d 1.0.5

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

@@ -0,0 +1,417 @@
+import { camera, createAuraApp, effects, game, lights, scene, ui } from "@aura3d/engine";
+import { assets } from "./aura-assets";
+import {
+  animationLayer,
+  createFighterAnimationController,
+  createFighterNode,
+  isLoopingFighterClip,
+  publicAssetInstructions,
+  REQUIRED_FIGHTER_ASSETS,
+  resolveTypedFighterAssets,
+  type FighterClip
+} from "./game/fighters";
+import { heavyMove, lightMove, specialMove } from "./game/moves";
+import {
+  createFighterColliders,
+  createTouchLayout,
+  fightingControls,
+  fightingRouteReadiness,
+  fightingStage,
+  fightingStageBounds,
+  fightingStageIssues
+} from "./game/stage";
+import "./styles.css";
+
+type Aura3DGameWindow = Window & {
+  __AURA3D_GAME_DEBUG__?: unknown;
+  __AURA3D_GAME_EVIDENCE__?: unknown;
+  __AURA3D_GAME_REPLAY__?: unknown;
+  __AURA3D_GAME_SOURCE__?: unknown;
+};
+
+const gameWindow = window as Aura3DGameWindow;
+const { typedFighterAssets, missingFighterAssets, typedFighterAssetCount } = resolveTypedFighterAssets(assets);
+const mediaMatches = (query: string) => typeof window.matchMedia === "function" && window.matchMedia(query).matches;
+const reducedMotion = mediaMatches("(prefers-reduced-motion: reduce)");
+const highContrast = mediaMatches("(prefers-contrast: more)");
+const reducedFlash = reducedMotion;
+
+const playerStart = [-0.9, 0, 0] as const;
+const rivalStart = [0.9, 0, 0] as const;
+const stageWarnings = fightingStageIssues.map((issue) => issue.message);
+const touchLayout = createTouchLayout(window.innerWidth, window.innerHeight);
+
+ui.html(
+  "#hud",
+  `
+    <section class="hud__panel hud__panel--status" aria-label="Round status">
+      <p class="hud__eyebrow">Public Aura3D game runtime starter</p>
+      <h1>Aura3D Fighting Game Runtime</h1>
+      <div class="hud__bars" aria-label="Health and meter">
+        <span class="hud__bar"><b>Player</b><span id="hud-player-health">100 HP</span></span>
+        <span class="hud__bar"><b>Rival</b><span id="hud-rival-health">100 HP</span></span>
+        <span class="hud__bar hud__bar--meter"><b>Meter</b><span id="hud-player-meter">0%</span></span>
+      </div>
+    </section>
+    <section class="hud__panel hud__panel--meta" aria-label="Runtime evidence">
+      <span id="hud-round">Round 1 - 99</span>
+      <span id="hud-frame">Frame 0</span>
+      <span id="hud-camera">Camera zoom 1.00</span>
+      <span id="hud-assets">Typed assets ${typedFighterAssetCount}/2</span>
+      <span id="hud-stage">Stage ${fightingStage.id}</span>
+      <span id="hud-replay">Replay ready</span>
+    </section>
+    <section id="hud-controls" class="hud__panel hud__panel--controls" aria-label="Controls">
+      <button id="hud-replay-button" type="button">Run replay</button>
+      <button id="hud-pause-button" type="button" aria-pressed="false">Pause</button>
+      <span class="hud__help">Move A/D - Jump W/Space - Guard Q - Dash Shift - J/K/L attacks</span>
+    </section>
+  `
+);
+
+const hudPlayerHealth = ui.text("#hud-player-health");
+const hudRivalHealth = ui.text("#hud-rival-health");
+const hudPlayerMeter = ui.text("#hud-player-meter");
+const hudRound = ui.text("#hud-round");
+const hudFrame = ui.text("#hud-frame");
+const hudCamera = ui.text("#hud-camera");
+const hudAssets = ui.text("#hud-assets");
+const hudStage = ui.text("#hud-stage");
+const hudReplay = ui.text("#hud-replay");
+const replayButton = ui.button("#hud-replay-button");
+const pauseButton = ui.button("#hud-pause-button");
+
+const hudBindings = game.hud.bindings([
+  game.hud.health({ actorId: "player", label: "Player health", a11yLabel: "player health" }),
+  game.hud.health({ actorId: "rival", label: "Rival health", a11yLabel: "rival health" }),
+  game.hud.meter({ actorId: "player", label: "Player meter", a11yLabel: "player special meter" }),
+  game.hud.timer({ label: "Round timer", valuePath: "round.timeRemaining", a11yLabel: "round timer" }),
+  game.hud.combo({ actorId: "player", label: "Player combo", valuePath: "combat.player.combo", a11yLabel: "player combo" }),
+  game.hud.round({ label: "Round", valuePath: "round.index", a11yLabel: "round index" }),
+  game.hud.debugToggle({ label: "Runtime evidence", action: "debug", statePath: "debug.visible" })
+]);
+
+const accessibilitySources = [
+  game.accessibility.label({
+    targetId: "hud",
+    label: "Live fighting game HUD with health, timer, stage, assets, and replay status.",
+    live: true
+  }),
+  game.accessibility.focus({
+    scopeId: "hud-controls",
+    label: "HUD controls",
+    targets: ["#hud-replay-button", "#hud-pause-button"]
+  }),
+  game.accessibility.reducedMotion({ enabled: reducedMotion }),
+  game.accessibility.reducedFlash({ enabled: reducedFlash }),
+  game.accessibility.highContrast({ enabled: highContrast }),
+  game.accessibility.pauseControls({
+    actions: ["pause", "Escape"],
+    resumeActions: ["pause", "Enter"],
+    menuId: "hud-controls"
+  })
+];
+
+const arena = scene()
+  .background("#10071c")
+  .addMany(fightingStage.nodes)
+  .add(createFighterNode("player", "playerFighter", "Player fighter", playerStart, 1, "#45f5bb", typedFighterAssets))
+  .add(createFighterNode("rival", "rivalFighter", "Rival fighter", rivalStart, -1, "#ffca5f", typedFighterAssets))
+  .addMany([
+    effects.bloom({ intensity: 0.32 }),
+    lights.studio({ intensity: 1.15 }),
+    lights.directional({ name: "rim light", color: "#80ffd4", intensity: 0.7 }).position(0, 4, 3),
+    camera
+      .perspective({ position: [0, 1.75, 5.8], target: [0, 0.85, 0], fov: 42 })
+  ]);
+
+const app = createAuraApp("#app", {
+  diagnostics: { overlay: true, performancePanel: true },
+  scene: arena
+});
+
+const inputOptions = {
+  actions: {
+    ...fightingControls.actions,
+    guard: ["KeyQ", "GamepadLB"],
+    heavy: ["KeyK", "GamepadY"],
+    pause: ["Escape", "GamepadStart"]
+  },
+  axes: fightingControls.axes,
+  bufferMs: 150,
+  gamepad: true
+} as const;
+
+const input = app.input(inputOptions);
+const replayInput = game.input({ ...inputOptions, autoListen: false, gamepad: false });
+const openingReplay = game.inputReplay(
+  [
+    { frame: 2, time: 2 / 60, type: "press", binding: "KeyD" },
+    { frame: 16, time: 16 / 60, type: "press", binding: "KeyL" },
+    { frame: 20, time: 20 / 60, type: "release", binding: "KeyL" },
+    { frame: 32, time: 32 / 60, type: "release", binding: "KeyD" },
+    { frame: 44, time: 44 / 60, type: "press", binding: "KeyJ" },
+    { frame: 48, time: 48 / 60, type: "release", binding: "KeyJ" }
+  ],
+  { label: "starter approach-special replay", fps: 60, seed: 105 }
+);
+const replayDriver = game.inputReplayDriver(replayInput, openingReplay);
+
+const playerBody = game.kinematicBody({
+  id: "player",
+  position: playerStart,
+  bounds: fightingStageBounds,
+  groundY: 0,
+  coyoteMs: 100,
+  jumpBufferMs: 120
+});
+const rivalBody = game.kinematicBody({
+  id: "rival",
+  position: rivalStart,
+  bounds: fightingStageBounds,
+  groundY: 0
+});
+const playerJumpAssist = game.jumpAssist({ coyoteMs: 100, bufferMs: 120 });
+const combat = game.combatWorld();
+const runtimeEffects = game.effects({ poolSize: 64, reducedMotion, reducedFlash });
+const director = game.cameraDirector({
+  stageBounds: { minX: fightingStage.combatBounds.minX, maxX: fightingStage.combatBounds.maxX },
+  reducedMotion
+});
+const playerNode = app.nodes.require("player");
+const rivalNode = app.nodes.require("rival");
+const playerAnimation = createFighterAnimationController("player", typedFighterAssets.playerFighter);
+const rivalAnimation = createFighterAnimationController("rival", typedFighterAssets.rivalFighter);
+
+playerAnimation.bindRuntimeNode(playerNode, { defaultClipId: "idle", fallbackClipId: "idle" });
+rivalAnimation.bindRuntimeNode(rivalNode, { defaultClipId: "idle", fallbackClipId: "idle" });
+playerAnimation.play("idle", { restart: true, loop: "loop" });
+rivalAnimation.play("idle", { restart: true, loop: "loop" });
+
+combat.addActor({ id: "player", team: "player", position: playerBody.position, facing: 1 });
+combat.addActor({ id: "rival", team: "rival", position: rivalBody.position, facing: -1 });
+
+gameWindow.__AURA3D_GAME_SOURCE__ = {
+  route: window.location.pathname,
+  template: "fighting-game",
+  package: "create-aura3d",
+  publicEngineApi: true,
+  typedAssetPattern: "src/aura-assets.ts",
+  typedAssetKeys: REQUIRED_FIGHTER_ASSETS,
+  missingAssets: missingFighterAssets,
+  addAssets: publicAssetInstructions,
+  touchControls: touchLayout,
+  readiness: fightingRouteReadiness
+};
+
+let aiCooldown = 0;
+let roundTime = 99;
+let replayActive = false;
+let paused = false;
+let replayHitCount = 0;
+let totalHitCount = 0;
+let playerClip: FighterClip = "idle";
+let rivalClip: FighterClip = "idle";
+
+ui.onClick(replayButton, () => {
+  replayActive = true;
+  replayHitCount = 0;
+  replayDriver.reset();
+  replayInput.clearReplay();
+  ui.setText(hudReplay, `Replay ${openingReplay.checksum} running`);
+});
+
+ui.onClick(pauseButton, () => setPaused(!paused));
+
+app.onFrame(({ dt }) => {
+  const activeInput = replayActive ? replayInput : input;
+  if (replayActive) {
+    replayDriver.step(dt);
+    if (replayDriver.snapshot().complete) replayActive = false;
+  } else {
+    input.update(dt);
+  }
+
+  if (activeInput.pressed("pause")) setPaused(!paused);
+
+  roundTime = Math.max(0, roundTime - dt);
+  const moveX = activeInput.axis("moveX");
+  playerBody.move(moveX);
+
+  const jumpAssist = playerJumpAssist.update(dt, {
+    grounded: playerBody.grounded,
+    jumpPressed: activeInput.pressed("jump")
+  });
+  if (jumpAssist.canJump && jumpAssist.jumpBuffered && playerJumpAssist.consume()) playerBody.jump();
+
+  if (activeInput.pressed("dash")) {
+    playerBody.dash([playerBody.facing, 0, 0], 8);
+    runtimeEffects.dashTrail(playerBody.position, { ownerId: "player", intensity: 0.55 });
+  }
+
+  aiCooldown -= dt;
+  const distance = playerBody.position[0] - rivalBody.position[0];
+  const rivalFacing = directionToPlayer();
+  rivalBody.move(Math.abs(distance) > 1.45 ? rivalFacing * 0.65 : -rivalFacing * 0.18);
+  if (aiCooldown <= 0 && Math.abs(distance) < 1.3) {
+    aiCooldown = 0.72;
+    combat.beginAttack("rival", heavyMove("rival-heavy", rivalFacing));
+  }
+
+  const liveSpecialCombo = input.combo(["light", "heavy", "special"], 650);
+  const replaySpecialCombo = replayInput.combo(["light", "heavy", "special"], 650);
+  const playerAttack = activeInput.pressed("heavy")
+    ? heavyMove("player-heavy", playerBody.facing)
+    : activeInput.pressed("special") || liveSpecialCombo || replaySpecialCombo
+      ? specialMove("player-special", playerBody.facing)
+      : activeInput.pressed("light")
+        ? lightMove("player-light", playerBody.facing)
+        : undefined;
+  if (playerAttack) {
+    combat.beginAttack("player", playerAttack);
+    if (playerAttack.id.includes("special")) runtimeEffects.auraBurst(playerBody.position, { ownerId: "player", intensity: 0.7 });
+  }
+
+  playerBody.update(dt);
+  rivalBody.update(dt);
+  combat.setActor("player", { position: playerBody.position, facing: playerBody.facing, guarding: activeInput.held("guard") });
+  combat.setActor("rival", { position: rivalBody.position, facing: rivalFacing, guarding: aiCooldown > 0.5 });
+  combat.update(dt);
+
+  const combatEvents = combat.consumeEvents();
+  for (const event of combatEvents) {
+    if (event.type === "hit" || event.type === "blocked") {
+      const spark = event.type === "hit" ? runtimeEffects.hitSpark : runtimeEffects.blockSpark;
+      spark(event.position, { ownerId: event.attackerId, intensity: event.type === "hit" ? 1.1 : 0.65 });
+      director.impact(event.type === "hit" ? 0.42 : 0.18, 0.16);
+      if (event.type === "hit") {
+        totalHitCount += 1;
+        if (replayActive || replayDriver.snapshot().frame > 0) replayHitCount += 1;
+      }
+      if (event.targetId === "player") playerBody.applyKnockback([event.attackerId === "rival" ? -2.2 : 2.2, 1.5, 0]);
+      if (event.targetId === "rival") rivalBody.applyKnockback([event.attackerId === "player" ? 2.2 : -2.2, 1.5, 0]);
+    }
+  }
+
+  runtimeEffects.update(dt);
+  const cameraFrame = director.update(dt, [
+    { id: "player", position: playerBody.position },
+    { id: "rival", position: rivalBody.position }
+  ]);
+
+  playerClip = activeInput.held("guard")
+    ? "guard"
+    : playerAttack
+      ? playerAttack.id.includes("special")
+        ? "special"
+        : playerAttack.id.includes("heavy")
+          ? "heavy"
+          : "light"
+      : !playerBody.grounded
+        ? "jump"
+        : Math.abs(moveX) > 0.05
+          ? "walk"
+          : "idle";
+  rivalClip = aiCooldown > 0.5 ? "heavy" : !rivalBody.grounded ? "jump" : "idle";
+
+  syncFighterAnimation(playerAnimation, playerClip, dt);
+  syncFighterAnimation(rivalAnimation, rivalClip, dt);
+
+  playerNode
+    .setPosition(playerBody.position[0], playerBody.position[1], playerBody.position[2])
+    .setRotation(0, playerBody.facing < 0 ? Math.PI : 0, 0);
+  rivalNode
+    .setPosition(rivalBody.position[0], rivalBody.position[1], rivalBody.position[2])
+    .setRotation(0, rivalFacing < 0 ? Math.PI : 0, 0);
+
+  const snapshot = combat.snapshot();
+  const player = snapshot.actors.find((actor) => actor.id === "player");
+  const rival = snapshot.actors.find((actor) => actor.id === "rival");
+  if (player && rival) {
+    ui.setText(hudPlayerHealth, `${Math.round(player.health)} HP`);
+    ui.setText(hudRivalHealth, `${Math.round(rival.health)} HP`);
+    ui.setText(hudPlayerMeter, `${Math.round(player.meter)}%`);
+    ui.setText(hudRound, `Round 1 - ${Math.ceil(roundTime)}`);
+    ui.setText(hudFrame, `Frame ${app.runtime.frame}`);
+    ui.setText(hudCamera, `Camera zoom ${cameraFrame.zoom.toFixed(2)}`);
+    ui.setText(
+      hudAssets,
+      missingFighterAssets.length === 0
+        ? "Typed assets ready"
+        : `Source placeholders: add ${missingFighterAssets.join(", ")}`
+    );
+    ui.setText(hudStage, stageWarnings.length === 0 ? `Stage ${fightingStage.id} ready` : `Stage warnings ${stageWarnings.length}`);
+    ui.setText(
+      hudReplay,
+      replayActive
+        ? `Replay ${replayDriver.snapshot().frame}/${openingReplay.frameCount}`
+        : `Replay ${openingReplay.checksum} hits ${replayHitCount}`
+    );
+  }
+
+  const colliders = createFighterColliders(playerBody.position, rivalBody.position);
+  const animationSnapshots = [playerAnimation.snapshot(), rivalAnimation.snapshot()];
+  const activeClips = animationSnapshots.map((animation) => animation.activeClipId ?? "idle");
+
+  gameWindow.__AURA3D_GAME_REPLAY__ = {
+    plan: openingReplay,
+    driver: replayDriver.snapshot(),
+    hitCount: replayHitCount,
+    totalHitCount,
+    liveInputEvents: input.recorded()
+  };
+  gameWindow.__AURA3D_GAME_DEBUG__ = game.debug.overlay({
+    runtime: app.runtime,
+    input: activeInput,
+    bodies: [playerBody, rivalBody],
+    combat,
+    effects: runtimeEffects,
+    camera: director,
+    colliders,
+    warnings: stageWarnings
+  });
+  gameWindow.__AURA3D_GAME_EVIDENCE__ = app.evidence({
+    input: activeInput,
+    bodies: [playerBody, rivalBody],
+    combat,
+    effects: runtimeEffects,
+    camera: director,
+    animation: { controllers: animationSnapshots.length, activeClips, eventCount: runtimeEffects.snapshot().spawned },
+    assets: { typedAssets: typedFighterAssetCount, missingAssets: missingFighterAssets },
+    stage: { id: fightingStage.id, safeZones: true, bounds: fightingStage.combatBounds, warnings: stageWarnings },
+    hud: hudBindings,
+    accessibility: accessibilitySources,
+    source: {
+      mode: "mounted-runtime",
+      expectsGame: true,
+      label: "create-aura3d fighting-game scaffold"
+    }
+  });
+});
+
+function directionToPlayer(): 1 | -1 {
+  return playerBody.position[0] >= rivalBody.position[0] ? 1 : -1;
+}
+
+function setPaused(next: boolean): void {
+  paused = next;
+  ui.setPressed(pauseButton, paused);
+  ui.setText(pauseButton, paused ? "Resume" : "Pause");
+  if (paused) app.pause();
+  else app.resume();
+}
+
+function syncFighterAnimation(controller: ReturnType<typeof createFighterAnimationController>, clip: FighterClip, dt: number): void {
+  const current = controller.snapshot().activeClipId;
+  const loop = isLoopingFighterClip(clip) ? "loop" : false;
+  const layer = animationLayer(clip);
+  if (current !== clip) {
+    controller.crossFade(clip, 0.08, {
+      restart: !isLoopingFighterClip(clip),
+      loop,
+      layer,
+      attack: layer === "upper-body"
+    });
+  }
+  controller.update(dt);
+}

package/templates/fighting-game/src/styles.css

@@ -0,0 +1,124 @@
+@font-face {
+  font-family: "AuraFight";
+  src: local("Impact");
+}
+
+html,
+body,
+#app {
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  overflow: hidden;
+  background:
+    radial-gradient(circle at 50% 8%, rgba(0, 255, 191, 0.2), transparent 36%),
+    linear-gradient(135deg, #020705, #071d14 55%, #020504);
+  color: #eafff5;
+  font-family: AuraFight, "Arial Narrow", sans-serif;
+}
+
+canvas {
+  display: block;
+}
+
+.hud {
+  position: fixed;
+  inset: auto 18px 18px 18px;
+  display: grid;
+  grid-template-columns: minmax(260px, 1.1fr) minmax(210px, 0.8fr) minmax(260px, 1fr);
+  gap: 10px;
+  pointer-events: none;
+  letter-spacing: 0.02em;
+}
+
+.hud__panel {
+  border: 1px solid rgba(71, 255, 190, 0.36);
+  border-radius: 18px;
+  background: linear-gradient(145deg, rgba(2, 9, 6, 0.82), rgba(9, 31, 23, 0.68));
+  box-shadow: 0 0 36px rgba(0, 255, 191, 0.14), inset 0 0 24px rgba(85, 255, 197, 0.05);
+  backdrop-filter: blur(14px);
+  pointer-events: auto;
+  padding: 12px 14px;
+}
+
+.hud__eyebrow {
+  margin: 0 0 4px;
+  color: #98ffdb;
+  font-size: 0.72rem;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+.hud h1 {
+  margin: 0 0 10px;
+  color: #eafff5;
+  font-size: clamp(1.2rem, 2.6vw, 2rem);
+  line-height: 0.95;
+  text-transform: uppercase;
+}
+
+.hud__bars,
+.hud__panel--meta,
+.hud__panel--controls {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+
+.hud__bar,
+.hud__panel--meta span,
+.hud__help {
+  display: inline-flex;
+  gap: 8px;
+  align-items: center;
+  min-height: 28px;
+  padding: 5px 9px;
+  border-radius: 999px;
+  background: rgba(6, 24, 17, 0.72);
+  color: #d8fff0;
+  font-size: 0.85rem;
+}
+
+.hud__bar b {
+  color: #55ffc5;
+}
+
+.hud__bar--meter b {
+  color: #ffd166;
+}
+
+.hud button {
+  min-height: 34px;
+  padding: 0 12px;
+  border: 1px solid rgba(85, 255, 197, 0.42);
+  border-radius: 999px;
+  background: #103726;
+  color: #eafff5;
+  cursor: pointer;
+  font: inherit;
+  text-transform: uppercase;
+}
+
+.hud button:hover,
+.hud button:focus-visible {
+  outline: 2px solid #55ffc5;
+  outline-offset: 2px;
+  background: #155039;
+}
+
+.hud button[aria-pressed="true"] {
+  border-color: #ffd166;
+  background: #4c3410;
+}
+
+@media (max-width: 720px) {
+  .hud {
+    grid-template-columns: 1fr;
+    inset: auto 12px 12px 12px;
+  }
+
+  .hud__panel {
+    border-radius: 14px;
+  }
+}

package/templates/fighting-game/tests/gameplay-smoke.spec.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "@playwright/test";
+
+test("input replay produces runtime evidence and a hit declaration", async ({ page }) => {
+  await page.goto("/");
+  await page.click("#hud-replay-button");
+  await page.waitForFunction(() => Boolean((window as any).__AURA3D_GAME_EVIDENCE__?.systems?.inputPlan));
+  await page.waitForFunction(() => ((window as any).__AURA3D_GAME_REPLAY__?.hitCount ?? 0) > 0);
+  const evidence = await page.evaluate(() => (window as any).__AURA3D_GAME_EVIDENCE__);
+  const replay = await page.evaluate(() => (window as any).__AURA3D_GAME_REPLAY__);
+  const source = await page.evaluate(() => (window as any).__AURA3D_GAME_SOURCE__);
+
+  expect(evidence.systems.mutableNodes).toBeTruthy();
+  expect(evidence.systems.inputPlan).toBeTruthy();
+  expect(evidence.systems.physicsPlan).toBeTruthy();
+  expect(evidence.systems.collisionPlan).toBeTruthy();
+  expect(evidence.systems.animationPlan).toBeTruthy();
+  expect(evidence.systems.effectsPlan).toBeTruthy();
+  expect(evidence.systems.cameraPlan).toBeTruthy();
+  expect(evidence.systems.stagePlan).toBeTruthy();
+  expect(replay.hitCount).toBeGreaterThan(0);
+  expect(source.readiness.sourceOnly).toBe(true);
+  expect(source.readiness.publicEngineApis).toContain("games.fighting.stagePreset");
+});

package/templates/fighting-game/tests/route-health.spec.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "@playwright/test";
+
+test("fighting-game route loads", async ({ page }) => {
+  await page.goto("/");
+  await expect(page.locator("#app")).toBeVisible();
+  await expect(page.locator("#hud")).toContainText("Aura3D Fighting Game Runtime");
+  await page.waitForFunction(() => Boolean((window as any).__AURA3D_GAME_SOURCE__?.readiness));
+  const source = await page.evaluate(() => (window as any).__AURA3D_GAME_SOURCE__);
+  expect(source.readiness.route).toBe("/");
+  expect(source.readiness.buildDeclarations.routeHealthSpec).toBe("tests/route-health.spec.ts");
+});

package/templates/fighting-game/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["src", "tests"]
+}

package/templates/mini-game/README.md

@@ -0,0 +1,10 @@
+# Aura3D Mini Game
+
+Small interactive scene starter for agent-authored controls, movement, and route
+health checks.
+
+```bash
+npm install
+npm run dev
+npm run test
+```

package/templates/mini-game/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aura3D Mini Game</title>
+    <style>html, body, #app { margin: 0; width: 100%; height: 100%; background: #071015; }</style>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/templates/mini-game/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "aura3d-mini-game",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host 127.0.0.1",
+    "typecheck": "tsc --noEmit",
+    "build": "npm run typecheck && vite build",
+    "preview": "vite preview --host 127.0.0.1",
+    "test": "playwright test tests/route-health.spec.ts tests/screenshot.spec.ts --workers=1"
+  },
+  "dependencies": {
+    "@aura3d/engine": "1.0.5"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.52.0",
+    "typescript": "^5.8.3",
+    "vite": "^7.3.2"
+  }
+}

package/templates/mini-game/playwright.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./tests",
+  use: {
+    baseURL: "http://127.0.0.1:4173"
+  },
+  webServer: {
+    command: "npm exec vite -- --host 127.0.0.1 --port 4173 --strictPort",
+    url: "http://127.0.0.1:4173",
+    reuseExistingServer: !process.env.CI,
+    timeout: 120_000
+  }
+});

package/templates/mini-game/public/aura-assets/player.thumb.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 120">
+  <rect width="160" height="120" rx="16" fill="#07111d"/>
+  <circle cx="74" cy="62" r="29" fill="#ffd84a"/>
+  <circle cx="97" cy="50" r="19" fill="#ffe680"/>
+  <path d="M112 55h22l-20 12z" fill="#ff8a4c"/>
+  <circle cx="101" cy="45" r="3" fill="#111827"/>
+  <path d="M40 91c27 12 62 12 91 0" fill="none" stroke="#55e7ff" stroke-width="6" stroke-linecap="round"/>
+</svg>