@auraindustry/aurajs 0.0.7 → 0.1.0

package/templates/create/3d-adventure/prefabs/player.prefab.js

@@ -0,0 +1,168 @@
+import {
+  createCharacterAvatar3D,
+  setAvatarVisual3D,
+} from '../src/starter-utils/index.js';
+import {
+  CAMERA_LOOK_OFFSET,
+  CAMERA_OFFSET,
+  JUMP_SPEED,
+  MOVE_SPEED,
+  PLAYER_HALF,
+} from '../content/gameplay/course.js';
+
+export const PLAYER_AVATAR_MODEL_PATH = 'assets/models/starter-avatar.gltf';
+
+const PLAYER_BODY_HEIGHT = PLAYER_HALF.y * 2;
+const PLAYER_RUN_SPEED = MOVE_SPEED * 1.35;
+const PLAYER_VISUAL_OFFSET = { x: 0, y: -PLAYER_HALF.y, z: 0 };
+const PLAYER_VISUAL_SCALE = { x: 1, y: 1, z: 1 };
+
+const playerPrefab = {
+  id: 'player',
+  kind: 'prefab',
+  role: 'player',
+  view: {
+    kind: 'avatar3d',
+    collider: { shape: 'capsule', size: { x: PLAYER_HALF.x * 2, y: PLAYER_BODY_HEIGHT, z: PLAYER_HALF.z * 2 } },
+    asset: { path: PLAYER_AVATAR_MODEL_PATH, clips: ['Idle', 'Walk', 'Run', 'Jump', 'Fall'] },
+  },
+  components: {
+    avatar: {
+      model: PLAYER_AVATAR_MODEL_PATH,
+      clips: ['Idle', 'Walk', 'Run', 'Jump', 'Fall'],
+    },
+  },
+  hooks: {
+    bindVisual: 'bindPlayerAvatarVisual',
+  },
+  notes: ['This starter keeps the player prefab avatar-first so the authored route starts from an imported character.'],
+};
+
+function normalizeImportedSceneRecord(entry) {
+  if (entry && entry.ok === true && Number.isInteger(entry.importId) && entry.importId > 0) {
+    return entry;
+  }
+  if (entry && Number.isInteger(entry.importId) && entry.importId > 0) {
+    return { ok: true, ...entry };
+  }
+  return null;
+}
+
+function resolveImportId(entry) {
+  if (Number.isInteger(entry) && entry > 0) return entry;
+  if (Number.isInteger(entry?.importId) && entry.importId > 0) return entry.importId;
+  return null;
+}
+
+function resolveRootSceneNodeId(record) {
+  if (!record || !Array.isArray(record.nodeHandles) || record.nodeHandles.length === 0) {
+    return null;
+  }
+
+  const rootSourceIndex = Array.isArray(record.rootSourceNodeIndices) && record.rootSourceNodeIndices.length > 0
+    ? Number(record.rootSourceNodeIndices[0])
+    : null;
+  if (Number.isInteger(rootSourceIndex) && rootSourceIndex >= 0) {
+    const match = record.nodeHandles.find((entry) => Number(entry?.sourceNodeIndex) === rootSourceIndex);
+    if (Number.isInteger(match?.nodeId) && match.nodeId > 0) {
+      return match.nodeId;
+    }
+  }
+
+  const first = record.nodeHandles.find((entry) => Number.isInteger(entry?.nodeId) && entry.nodeId > 0);
+  return Number.isInteger(first?.nodeId) ? first.nodeId : null;
+}
+
+function createPlayerClipMap(importId) {
+  return {
+    idle: { importId, animation: 'Idle', loop: true, transitionSeconds: 0.18 },
+    walk: { importId, animation: 'Walk', loop: true, transitionSeconds: 0.14 },
+    run: { importId, animation: 'Run', loop: true, transitionSeconds: 0.1 },
+    jump: { importId, animation: 'Jump', loop: false, transitionSeconds: 0.08 },
+    fall: { importId, animation: 'Fall', loop: true, transitionSeconds: 0.08 },
+  };
+}
+
+export function createPlayerAvatar(spawn) {
+  return createCharacterAvatar3D({
+    position: spawn,
+    radius: PLAYER_HALF.x,
+    height: PLAYER_BODY_HEIGHT,
+    moveSpeed: MOVE_SPEED,
+    runSpeed: PLAYER_RUN_SPEED,
+    jumpSpeed: JUMP_SPEED,
+    visual: {
+      offset: PLAYER_VISUAL_OFFSET,
+      scale: PLAYER_VISUAL_SCALE,
+    },
+    camera: {
+      offset: CAMERA_OFFSET,
+      lookOffset: CAMERA_LOOK_OFFSET,
+      rotateWithFacing: false,
+    },
+  });
+}
+
+export function resetPlayerAvatar(avatar, spawn) {
+  avatar.position = { x: spawn.x, y: spawn.y, z: spawn.z };
+  avatar.grounded = false;
+  avatar.onSlope = false;
+  avatar.velocityY = 0;
+  avatar.facingYaw = 0;
+  avatar.locomotion = 'idle';
+  avatar.motion = {
+    moveX: 0,
+    moveZ: 0,
+    magnitude: 0,
+    speed: 0,
+  };
+  avatar.input = {
+    moveX: 0,
+    moveZ: 0,
+    jump: false,
+    run: false,
+  };
+  avatar.visual.activeClipKey = null;
+  avatar.visual.activeClipId = null;
+  return avatar;
+}
+
+export function loadPlayerAvatarVisual() {
+  const loaded = aura.scene3d.loadGltfScene(PLAYER_AVATAR_MODEL_PATH, {
+    bindRenderNodes: true,
+    visible: true,
+    cull: false,
+  });
+  const importId = resolveImportId(loaded);
+  if (!importId) {
+    throw new Error(`[3d-adventure-template] failed to load starter avatar model: ${PLAYER_AVATAR_MODEL_PATH}`);
+  }
+
+  const record = normalizeImportedSceneRecord(loaded)
+    || normalizeImportedSceneRecord(aura.scene3d.getImportedScene(importId));
+  const sceneNodeId = resolveRootSceneNodeId(record);
+  if (!sceneNodeId) {
+    throw new Error('[3d-adventure-template] starter avatar model missing a bindable root scene node');
+  }
+
+  return {
+    importId,
+    path: PLAYER_AVATAR_MODEL_PATH,
+    sceneNodeId,
+  };
+}
+
+export function bindPlayerAvatarVisual(avatar, visual) {
+  return setAvatarVisual3D(avatar, {
+    sceneNodeId: visual.sceneNodeId,
+    offset: PLAYER_VISUAL_OFFSET,
+    scale: PLAYER_VISUAL_SCALE,
+    clipMap: createPlayerClipMap(visual.importId),
+  });
+}
+
+export function createPlayerPrefab() {
+  return playerPrefab;
+}
+
+export default playerPrefab;

package/templates/create/3d-adventure/prefabs/relic.prefab.js

@@ -0,0 +1,35 @@
+const relicPrefab = {
+  id: 'relic',
+  kind: 'prefab',
+  role: 'pickup',
+  view: {
+    kind: 'pickup3d',
+  },
+  hooks: {},
+  notes: ['Keep authored relic payloads in content/ and the starter draw surface here.'],
+};
+
+export function createRelicPrefab() {
+  return relicPrefab;
+}
+
+export function drawAdventureRelics({ mesh, material, relics, elapsed = 0 }) {
+  for (const relic of relics) {
+    if (relic.collected) continue;
+    aura.draw3d.drawMesh(mesh, material, {
+      position: {
+        x: relic.x,
+        y: relic.y + (Math.sin((elapsed * 2.4) + relic.x) * 0.18),
+        z: relic.z,
+      },
+      rotation: {
+        x: elapsed * 0.5,
+        y: elapsed * 1.7,
+        z: elapsed * 0.2,
+      },
+      scale: { x: relic.radius, y: relic.radius, z: relic.radius },
+    });
+  }
+}
+
+export default relicPrefab;

package/templates/create/3d-adventure/prefabs/world.prefab.js

@@ -0,0 +1,119 @@
+import { BEACON_SITES, FLOOR_SCALE, GOAL_ZONE, WORLD_PLATFORMS } from '../content/gameplay/course.js';
+
+const worldPrefab = {
+  id: 'world',
+  kind: 'prefab',
+  role: 'world',
+  view: {
+    kind: 'environment3d',
+  },
+  hooks: {},
+  notes: ['Treat this as the authored world descriptor before you move to richer scene data or imported set dressing.'],
+};
+
+function addObstacleBox(platform) {
+  const halfX = platform.sx * 0.5;
+  const halfY = platform.sy * 0.5;
+  const halfZ = platform.sz * 0.5;
+  aura.character3d.addObstacle(
+    { x: platform.x - halfX, y: platform.y - halfY, z: platform.z - halfZ },
+    { x: platform.x + halfX, y: platform.y + halfY, z: platform.z + halfZ },
+  );
+}
+
+export function createWorldPrefab() {
+  return {
+    ...worldPrefab,
+    platformCount: WORLD_PLATFORMS.length,
+    beaconCount: BEACON_SITES.length,
+  };
+}
+
+export function syncAdventureCharacterObstacles(movingPlatform) {
+  if (typeof aura?.character3d?.clearObstacles !== 'function' || typeof aura?.character3d?.addObstacle !== 'function') {
+    return;
+  }
+
+  aura.character3d.clearObstacles();
+  aura.character3d.addObstacle(
+    { x: -FLOOR_SCALE.x * 0.5, y: -1.0, z: -FLOOR_SCALE.z * 0.5 },
+    { x: FLOOR_SCALE.x * 0.5, y: 0.0, z: FLOOR_SCALE.z * 0.5 },
+  );
+
+  for (const platform of WORLD_PLATFORMS) {
+    addObstacleBox(platform);
+  }
+
+  addObstacleBox({
+    x: movingPlatform.position.x,
+    y: movingPlatform.position.y,
+    z: movingPlatform.position.z,
+    sx: movingPlatform.size.x,
+    sy: movingPlatform.size.y,
+    sz: movingPlatform.size.z,
+  });
+}
+
+export function drawAdventureCourse({
+  mesh,
+  floorMaterial,
+  platformMaterial,
+  beaconDormantMaterial,
+  beaconLitMaterial,
+  goalLockedMaterial,
+  goalReadyMaterial,
+  movingPlatform,
+  beacons,
+  goalReady = false,
+  elapsed = 0,
+}) {
+  aura.draw3d.drawMesh(mesh, floorMaterial, {
+    position: { x: 0, y: -0.5, z: 0 },
+    rotation: { x: 0, y: 0, z: 0 },
+    scale: FLOOR_SCALE,
+  });
+
+  for (const platform of WORLD_PLATFORMS) {
+    aura.draw3d.drawMesh(mesh, platformMaterial, {
+      position: { x: platform.x, y: platform.y, z: platform.z },
+      rotation: { x: 0, y: 0, z: 0 },
+      scale: { x: platform.sx, y: platform.sy, z: platform.sz },
+    });
+  }
+
+  aura.draw3d.drawMesh(mesh, platformMaterial, {
+    position: {
+      x: movingPlatform.position.x,
+      y: movingPlatform.position.y,
+      z: movingPlatform.position.z,
+    },
+    rotation: { x: 0, y: movingPlatform.t * 0.5, z: 0 },
+    scale: {
+      x: movingPlatform.size.x,
+      y: movingPlatform.size.y,
+      z: movingPlatform.size.z,
+    },
+  });
+
+  const beaconById = new Map((Array.isArray(beacons) ? beacons : []).map((beacon) => [beacon.id, beacon]));
+  for (const site of BEACON_SITES) {
+    const lit = beaconById.get(site.id)?.lit === true;
+    aura.draw3d.drawMesh(mesh, lit ? beaconLitMaterial : beaconDormantMaterial, {
+      position: { x: site.x, y: site.y, z: site.z },
+      rotation: { x: 0, y: elapsed * 0.8, z: 0 },
+      scale: { x: site.radius, y: site.radius * 1.8, z: site.radius },
+    });
+  }
+
+  aura.draw3d.drawMesh(mesh, goalReady ? goalReadyMaterial : goalLockedMaterial, {
+    position: { x: GOAL_ZONE.x, y: GOAL_ZONE.y, z: GOAL_ZONE.z },
+    rotation: { x: 0, y: elapsed * 0.6, z: 0 },
+    scale: {
+      x: GOAL_ZONE.radius * 1.25,
+      y: GOAL_ZONE.radius * 2.1,
+      z: GOAL_ZONE.radius * 1.25,
+    },
+  });
+}
+
+export default worldPrefab;

package/templates/create/3d-adventure/scenes/gameplay.scene.js

@@ -0,0 +1,358 @@
+import {
+  axisFromKeys,
+  collectAdventureObjectives3D,
+  countCompletedObjectives,
+  createInteractionPromptState,
+  createProximityTrigger3D,
+  createTriggerTracker,
+  createGoalZone,
+  objectivesComplete,
+  setAvatarInput3D,
+  spawnCharacterAvatar3D,
+  stepMovingPlatform3D,
+  stepVolumeTriggers3D,
+  tickCharacterAvatar3D,
+  updateCheckpointProgress,
+  updateInteractionPromptState,
+  respawnAtCheckpoint,
+} from '../src/starter-utils/index.js';
+import { ensureSessionState, ensureUiState } from '../src/runtime/app-state.js';
+import { ADVENTURE3D_CONFIG, ADVENTURE3D_TEXT } from '../config/gameplay/adventure.config.js';
+import { GOAL_ZONE, WORLD_LIMIT } from '../content/gameplay/course.js';
+import { bindPlayerAvatarVisual, loadPlayerAvatarVisual } from '../prefabs/player.prefab.js';
+import { drawAdventureRelics } from '../prefabs/relic.prefab.js';
+import { drawAdventureCourse, syncAdventureCharacterObstacles } from '../prefabs/world.prefab.js';
+import { createAdventureMaterials } from '../src/runtime/materials.js';
+import { createAdventureRunState } from '../src/runtime/state.js';
+
+const INTERACT_KEYS = ['e', 'enter'];
+const DEFAULT_PROFILE_NAME = 'Nova';
+const DEFAULT_SAVE_SLOTS = [
+  { id: 'slot-a', label: 'Forest Edge' },
+  { id: 'slot-b', label: 'Beacon Ridge' },
+  { id: 'slot-c', label: 'Signal Arch' },
+];
+
+function createAdventureSessionSeed() {
+  return {
+    runsStarted: 0,
+    bestRelicCount: 0,
+    bestBeaconCount: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+    profileName: DEFAULT_PROFILE_NAME,
+    lastSubmittedProfileName: DEFAULT_PROFILE_NAME,
+    activeSaveSlotId: DEFAULT_SAVE_SLOTS[0].id,
+    saveSlots: DEFAULT_SAVE_SLOTS.map((entry) => ({ ...entry })),
+  };
+}
+
+function createAdventureUiStateSeed() {
+  return {
+    showControlsHint: true,
+  };
+}
+
+function pressedInteract() {
+  return INTERACT_KEYS.some((key) => aura.input.isKeyPressed(key));
+}
+
+function normalizeProfileName(value) {
+  const trimmed = typeof value === 'string' ? value.trim() : '';
+  return trimmed.length > 0 ? trimmed.slice(0, 18) : DEFAULT_PROFILE_NAME;
+}
+
+function normalizeAdventureSaveSlots(value) {
+  const normalized = Array.isArray(value)
+    ? value
+      .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+      .map((entry, index) => {
+        const fallback = DEFAULT_SAVE_SLOTS[index] || DEFAULT_SAVE_SLOTS[0];
+        const id = typeof entry.id === 'string' && entry.id.trim().length > 0
+          ? entry.id.trim()
+          : fallback.id;
+        const label = typeof entry.label === 'string' && entry.label.trim().length > 0
+          ? entry.label.trim()
+          : fallback.label;
+        return { id, label };
+      })
+      .filter((entry) => entry.id.length > 0)
+    : [];
+  return normalized.length > 0
+    ? normalized
+    : DEFAULT_SAVE_SLOTS.map((entry) => ({ ...entry }));
+}
+
+function hydrateAdventureSession(session) {
+  session.profileName = normalizeProfileName(session.profileName);
+  session.lastSubmittedProfileName = normalizeProfileName(
+    typeof session.lastSubmittedProfileName === 'string' ? session.lastSubmittedProfileName : session.profileName,
+  );
+  session.saveSlots = normalizeAdventureSaveSlots(session.saveSlots);
+  const validSaveSlotIds = new Set(session.saveSlots.map((entry) => entry.id));
+  session.activeSaveSlotId = validSaveSlotIds.has(session.activeSaveSlotId)
+    ? session.activeSaveSlotId
+    : session.saveSlots[0].id;
+  return session;
+}
+
+export function createGameplayScene(context = {}) {
+  const appState = context.appState && typeof context.appState === 'object' ? context.appState : (context.appState = {});
+  const adventureSession = hydrateAdventureSession(
+    ensureSessionState(appState, 'adventure3d', createAdventureSessionSeed()),
+  );
+  const adventureUiState = ensureUiState(appState, 'adventureHud', createAdventureUiStateSeed());
+  const promptState = createInteractionPromptState({ prompt: 'Press E to interact' });
+  const triggerTracker = createTriggerTracker({ subjectId: 'player', dimension: '3d' });
+  const goalZone = createGoalZone(GOAL_ZONE);
+  let boxMesh = null;
+  let materials = null;
+  let playerVisual = null;
+  let sceneState = createAdventureRunState();
+
+  function relicCount() {
+    return countCompletedObjectives(sceneState.relics);
+  }
+
+  function beaconCount() {
+    return sceneState.beacons.reduce((total, beacon) => total + (beacon.lit === true ? 1 : 0), 0);
+  }
+
+  function routeReady() {
+    return objectivesComplete(sceneState.relics) && beaconCount() >= sceneState.beacons.length;
+  }
+
+  function syncSessionState() {
+    adventureSession.lastSceneId = 'gameplay';
+    adventureSession.bestRelicCount = Math.max(Number(adventureSession.bestRelicCount || 0), relicCount());
+    adventureSession.bestBeaconCount = Math.max(Number(adventureSession.bestBeaconCount || 0), beaconCount());
+    adventureSession.lastRelicCount = relicCount();
+    adventureSession.lastBeaconCount = beaconCount();
+    adventureSession.lastOutcome = sceneState.runComplete ? 'route-cleared' : 'surveying';
+  }
+
+  function isPauseOpen() {
+    const shellState = context.getScreenShellState?.();
+    return Array.isArray(shellState?.modals) && shellState.modals.some((entry) => entry.screenId === 'pause');
+  }
+
+  function syncHud() {
+    context.setHudScreen?.('hud', {
+      relicCount: relicCount(),
+      relicTarget: sceneState.relics.length,
+      beaconCount: beaconCount(),
+      beaconTarget: sceneState.beacons.length,
+      promptText: promptState.prompt || '',
+      paused: isPauseOpen(),
+      runComplete: sceneState.runComplete,
+      showControlsHint: adventureUiState.showControlsHint !== false,
+    });
+  }
+
+  function resetRun() {
+    sceneState = createAdventureRunState(sceneState?.player ?? null);
+    if (!playerVisual) return;
+    bindPlayerAvatarVisual(sceneState.player, playerVisual);
+    syncAdventureCharacterObstacles(sceneState.movingPlatform);
+    spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+    promptState.visible = false;
+    promptState.ready = false;
+    promptState.prompt = null;
+    promptState.triggerId = null;
+    promptState.accepted = false;
+    promptState.acceptedTriggerId = null;
+    adventureSession.runsStarted += 1;
+    syncSessionState();
+    syncHud();
+  }
+
+  function buildPromptTriggers() {
+    const collectedRelics = relicCount();
+    const triggers = [];
+
+    for (const beacon of sceneState.beacons) {
+      if (beacon.lit) continue;
+      const canLight = collectedRelics >= beacon.requiredRelics;
+      triggers.push(createProximityTrigger3D(
+        `beacon:${beacon.id}`,
+        beacon.x,
+        beacon.y,
+        beacon.z,
+        ADVENTURE3D_CONFIG.beaconPromptRadius,
+        {
+          role: 'beacon',
+          priority: canLight ? 5 : 2,
+          promptText: canLight
+            ? `Press E to light ${beacon.label}`
+            : `${beacon.label} unlocks at ${beacon.requiredRelics} relic${beacon.requiredRelics === 1 ? '' : 's'}`,
+          interactionKey: 'E',
+        },
+      ));
+    }
+
+    triggers.push(createProximityTrigger3D(
+      'goal-gate',
+      goalZone.x,
+      goalZone.y,
+      goalZone.z,
+      ADVENTURE3D_CONFIG.goalPromptRadius,
+      {
+        role: 'goal',
+        priority: routeReady() ? 8 : 1,
+        promptText: routeReady()
+          ? 'Press E to leave through the signal arch'
+          : 'Recover all relics and light both beacons to open the arch',
+        interactionKey: 'E',
+      },
+    ));
+
+    return triggers;
+  }
+
+  function handleAcceptedPrompt() {
+    const acceptedTriggerId = promptState.acceptedTriggerId;
+    if (!acceptedTriggerId) return;
+
+    if (acceptedTriggerId.startsWith('beacon:')) {
+      const beaconId = acceptedTriggerId.slice('beacon:'.length);
+      const beacon = sceneState.beacons.find((entry) => entry.id === beaconId) || null;
+      if (beacon && relicCount() >= beacon.requiredRelics) {
+        beacon.lit = true;
+      }
+    } else if (acceptedTriggerId === 'goal-gate' && routeReady()) {
+      sceneState.runComplete = true;
+    }
+  }
+
+  function syncPauseModal() {
+    if (!aura.input.isKeyPressed('escape')) return;
+
+    const shellState = context.getScreenShellState?.();
+    const topModal = shellState?.modals?.[shellState.modals.length - 1] || null;
+    if (topModal) {
+      context.popModalScreen?.({ action: 'resume' });
+      return;
+    }
+
+    context.pushModalScreen?.('pause', {
+      relicCount: relicCount(),
+      beaconCount: beaconCount(),
+    });
+  }
+
+  function updateMovement(dt) {
+    const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
+    const moveZ = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
+    const jumpedThisFrame = aura.input.isKeyPressed('space');
+    const runningThisFrame = aura.input.isKeyDown('shift') || aura.input.isKeyDown('shiftleft') || aura.input.isKeyDown('shiftright');
+    if (adventureUiState.showControlsHint && (moveX !== 0 || moveZ !== 0 || jumpedThisFrame || runningThisFrame || pressedInteract())) {
+      adventureUiState.showControlsHint = false;
+    }
+    setAvatarInput3D(sceneState.player, {
+      moveX,
+      moveZ,
+      jump: jumpedThisFrame,
+      run: runningThisFrame,
+    });
+    tickCharacterAvatar3D(aura, sceneState.player, dt);
+    sceneState.player.position.x = Math.max(-WORLD_LIMIT, Math.min(WORLD_LIMIT, sceneState.player.position.x));
+    sceneState.player.position.z = Math.max(-WORLD_LIMIT, Math.min(WORLD_LIMIT, sceneState.player.position.z));
+    spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+  }
+
+  function updateRouteProgress() {
+    if (sceneState.player.position.y < -10) {
+      if (!respawnAtCheckpoint(sceneState.checkpointSystem, sceneState.player)) {
+        resetRun();
+        return false;
+      }
+      spawnCharacterAvatar3D(aura, sceneState.player, { position: sceneState.player.position });
+    }
+
+    collectAdventureObjectives3D(sceneState.player, sceneState.relics);
+    updateCheckpointProgress(sceneState.checkpointSystem, sceneState.player);
+    return true;
+  }
+
+  return {
+    setup() {
+      boxMesh = aura.mesh.createBox();
+      materials = createAdventureMaterials();
+      playerVisual = loadPlayerAvatarVisual();
+
+      aura.light.ambient({ r: 1, g: 1, b: 1 }, 0.23);
+      aura.light.directional({ x: 0.55, y: -1.0, z: -0.35 }, { r: 1, g: 1, b: 1 }, 1.0);
+      aura.camera3d.perspective(62, 0.1, 160);
+
+      resetRun();
+      console.log(ADVENTURE3D_TEXT.started);
+    },
+
+    update(dt) {
+      syncPauseModal();
+      if (isPauseOpen()) {
+        syncHud();
+        return;
+      }
+
+      if (sceneState.runComplete) {
+        if (aura.input.isKeyPressed('enter')) {
+          resetRun();
+        }
+        syncHud();
+        return;
+      }
+
+      if (aura.input.isKeyPressed('h')) {
+        adventureUiState.showControlsHint = adventureUiState.showControlsHint !== true;
+      }
+
+      sceneState.elapsed += dt;
+      stepMovingPlatform3D(sceneState.movingPlatform, dt);
+      syncAdventureCharacterObstacles(sceneState.movingPlatform);
+
+      updateMovement(dt);
+      if (!updateRouteProgress()) return;
+
+      const triggerStep = stepVolumeTriggers3D(triggerTracker, sceneState.player.position, buildPromptTriggers());
+      updateInteractionPromptState(promptState, triggerStep, {
+        interactPressed: pressedInteract(),
+      });
+      handleAcceptedPrompt();
+      syncSessionState();
+      syncHud();
+    },
+
+    onResume() {
+      syncHud();
+    },
+
+    onExit() {
+      context.clearHudScreen?.();
+    },
+
+    draw() {
+      aura.draw3d.clear3d({ r: 0.05, g: 0.07, b: 0.11 });
+      drawAdventureCourse({
+        mesh: boxMesh,
+        floorMaterial: materials.floor,
+        platformMaterial: materials.platform,
+        beaconDormantMaterial: materials.beaconDormant,
+        beaconLitMaterial: materials.beaconLit,
+        goalLockedMaterial: materials.goalLocked,
+        goalReadyMaterial: materials.goalReady,
+        movingPlatform: sceneState.movingPlatform,
+        beacons: sceneState.beacons,
+        goalReady: routeReady(),
+        elapsed: sceneState.elapsed,
+      });
+      drawAdventureRelics({
+        mesh: boxMesh,
+        material: materials.relic,
+        relics: sceneState.relics,
+        elapsed: sceneState.elapsed,
+      });
+      aura.scene3d.submitRenderBindings();
+    },
+  };
+}