@auraindustry/aurajs 0.1.1 → 0.1.5

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

@@ -1,31 +1,75 @@
 import {
   axisFromKeys,
   centeredRect,
-  collectAdventureObjectives2D,
-  countCompletedObjectives,
-  createAdventureObjectives,
-  createInteractionPromptState,
-  createRectTrigger2D,
-  createTriggerTracker,
-  objectivesComplete,
-  resetAdventureObjectives,
-  stepRectTriggers2D,
-  updateInteractionPromptState,
+  addInventoryItem2D,
+  advanceDialogueConversation2D,
+  chooseDialogueChoice2D,
+  createAdventureInteractablesFromTilemapObjects2D,
+  createAdventureInteractionState2D,
+  createDialogueState2D,
+  createInventory2D,
+  createJournal2D,
+  getDialogueView2D,
+  getInventoryView2D,
+  getJournalView2D,
+  hasInventoryItem2D,
+  listInventoryItems2D,
+  listJournalEntries2D,
+  selectInventoryCategory2D,
+  selectInventoryItem2D,
+  selectJournalCategory2D,
+  selectJournalEntry2D,
+  setJournalEntryStatus2D,
+  startDialogueConversation2D,
+  stepAdventureInteractables2D,
+  upsertJournalEntry2D,
 } from '../src/starter-utils/index.js';
 import { ensureSessionState, ensureUiState } from '../src/runtime/app-state.js';
 import { ADVENTURE_CONFIG, ADVENTURE_TEXT } from '../config/gameplay/adventure.config.js';
 import { drawAdventurePlayer, createPlayerState, resetPlayerPosition } from '../prefabs/player.prefab.js';
 import { drawAdventureRelics } from '../prefabs/relic.prefab.js';
-import { drawAdventureWorld, moveActorThroughAdventureWorld } from '../prefabs/world.prefab.js';
-import { BEACON_SITES, EXIT_GATE, PLAYER_SPAWN, RELIC_SPAWNS } from '../content/gameplay/world.js';
+import {
+  createAdventureWorldState,
+  drawAdventureWorld,
+  ensureAdventureWorldLoaded,
+  listAdventureWorldObjects,
+  moveActorThroughAdventureWorld,
+  resolveAdventurePlayerSpawn,
+} from '../prefabs/world.prefab.js';
+import {
+  INVENTORY_CATEGORIES,
+  STARTING_INVENTORY_ITEMS,
+  WORLD_OBJECT_LAYERS,
+  WORLD_TEXT,
+} from '../content/gameplay/world.js';
+import {
+  ARCHIVE_CONSOLE_DIALOGUE_ID,
+  ADVENTURE_DIALOGUES,
+  JOURNAL_CATEGORIES,
+  JOURNAL_ENTRY_IDS,
+  STARTING_JOURNAL_ENTRIES,
+} from '../content/gameplay/dialogue.js';
 
 const INTERACT_KEYS = ['e', 'enter'];
+const DIALOGUE_ADVANCE_KEYS = ['space'];
+const DIALOGUE_CHOICE_PREV_KEYS = ['w', 'arrowup'];
+const DIALOGUE_CHOICE_NEXT_KEYS = ['s', 'arrowdown'];
+const INVENTORY_TOGGLE_KEYS = ['i', 'tab'];
+const INVENTORY_CATEGORY_PREV_KEYS = ['a', 'arrowleft'];
+const INVENTORY_CATEGORY_NEXT_KEYS = ['d', 'arrowright'];
+const INVENTORY_ITEM_PREV_KEYS = ['w', 'arrowup'];
+const INVENTORY_ITEM_NEXT_KEYS = ['s', 'arrowdown'];
+const JOURNAL_TOGGLE_KEYS = ['j'];
+const JOURNAL_CATEGORY_PREV_KEYS = ['a', 'arrowleft'];
+const JOURNAL_CATEGORY_NEXT_KEYS = ['d', 'arrowright'];
+const JOURNAL_ENTRY_PREV_KEYS = ['w', 'arrowup'];
+const JOURNAL_ENTRY_NEXT_KEYS = ['s', 'arrowdown'];
 
 function createAdventureSessionSeed() {
   return {
     runsStarted: 0,
     bestRelicCount: 0,
-    bestBeaconCount: 0,
+    bestCheckpointCount: 0,
     bestTimeSeconds: 0,
     lastOutcome: 'idle',
     lastSceneId: 'gameplay',
@@ -35,150 +79,537 @@ function createAdventureSessionSeed() {
 function createAdventureUiStateSeed() {
   return {
     showControlsHint: true,
+    showInventory: false,
+    showJournal: false,
+    inventorySelectedCategoryId: null,
+    inventorySelectedItemId: null,
+    journalSelectedCategoryId: null,
+    journalSelectedEntryId: null,
+    dialogueSelectedChoiceId: null,
   };
 }
 
-function createBeaconState() {
-  return BEACON_SITES.map((site) => ({
-    id: site.id,
-    label: site.label,
-    x: site.x,
-    y: site.y,
-    size: site.size,
-    radius: site.radius,
-    requiredRelics: site.requiredRelics,
-    lit: false,
-  }));
+function pressedAny(keys = []) {
+  return keys.some((key) => aura.input.isKeyPressed(key));
 }
 
 function pressedInteract() {
-  return INTERACT_KEYS.some((key) => aura.input.isKeyPressed(key));
+  return pressedAny(INTERACT_KEYS);
+}
+
+function objectProperty(object, name, fallback = null) {
+  if (!object || typeof object !== 'object') return fallback;
+  const properties = object.properties;
+  if (Array.isArray(properties)) {
+    const entry = properties.find((candidate) => candidate && candidate.name === name) || null;
+    return entry && Object.prototype.hasOwnProperty.call(entry, 'value') ? entry.value : fallback;
+  }
+  if (properties && typeof properties === 'object' && Object.prototype.hasOwnProperty.call(properties, name)) {
+    return properties[name];
+  }
+  return fallback;
+}
+
+function normalizeInteractables(world, layer) {
+  const objects = listAdventureWorldObjects(world, { layer, includeHidden: true });
+  const base = createAdventureInteractablesFromTilemapObjects2D(objects) || [];
+  const sourceById = new Map(objects.map((entry) => [String(entry.id), entry]));
+
+  return base.map((entry) => {
+    const source = sourceById.get(String(entry.id)) || null;
+    if (entry.kind === 'pickup') {
+      return {
+        ...entry,
+        priority: 6,
+        grantItem: {
+          id: String(objectProperty(source, 'grantItemId', entry.id)),
+          label: String(entry.label || source?.name || entry.id),
+          categoryId: String(objectProperty(source, 'grantCategoryId', 'relics')),
+          categoryLabel: String(objectProperty(source, 'grantCategoryLabel', 'Relics')),
+          description: String(objectProperty(source, 'grantDescription', `${entry.label} recovered from the archive.`)),
+          detail: String(objectProperty(source, 'grantDetail', 'Recovered during the route.')),
+          badge: String(objectProperty(source, 'grantBadge', 'ITEM')),
+          quantity: 1,
+        },
+      };
+    }
+    if (entry.kind === 'lock') {
+      return {
+        ...entry,
+        priority: 8,
+        openedPromptText: String(objectProperty(source, 'openedPromptText', `${entry.label} is open`)),
+        consumeRequiredItem: objectProperty(source, 'consumeRequiredItem', false) === true,
+      };
+    }
+    if (entry.kind === 'checkpoint') {
+      return {
+        ...entry,
+        priority: 7,
+      };
+    }
+    return {
+      ...entry,
+      priority: 3,
+    };
+  });
+}
+
+function createRunInventory() {
+  return createInventory2D({
+    categories: INVENTORY_CATEGORIES,
+    items: STARTING_INVENTORY_ITEMS,
+  });
+}
+
+function createRunJournal() {
+  return createJournal2D({
+    categories: JOURNAL_CATEGORIES,
+    entries: STARTING_JOURNAL_ENTRIES,
+  });
+}
+
+function createRunDialogue() {
+  return createDialogueState2D({
+    conversations: ADVENTURE_DIALOGUES,
+  });
+}
+
+function cycleValue(values, current, direction) {
+  if (!Array.isArray(values) || values.length <= 0) return current;
+  const index = values.indexOf(current);
+  const start = index >= 0 ? index : 0;
+  const nextIndex = (start + direction + values.length) % values.length;
+  return values[nextIndex];
+}
+
+function syncInventoryUiState(inventory, uiState) {
+  const view = getInventoryView2D(inventory);
+  uiState.inventorySelectedCategoryId = view.selectedCategoryId;
+  uiState.inventorySelectedItemId = view.selectedItemId;
+}
+
+function applyInventoryUiSelection(inventory, uiState) {
+  if (uiState.inventorySelectedCategoryId) {
+    selectInventoryCategory2D(inventory, uiState.inventorySelectedCategoryId);
+  }
+  const visibleItems = getInventoryView2D(inventory).items;
+  if (uiState.inventorySelectedItemId && visibleItems.some((entry) => entry.id === uiState.inventorySelectedItemId)) {
+    selectInventoryItem2D(inventory, uiState.inventorySelectedItemId);
+  }
+  syncInventoryUiState(inventory, uiState);
+}
+
+function handleInventoryNavigation(inventory, uiState) {
+  const categoryIds = getInventoryView2D(inventory).categories.map((entry) => entry.id);
+  if (pressedAny(INVENTORY_CATEGORY_PREV_KEYS)) {
+    selectInventoryCategory2D(
+      inventory,
+      cycleValue(categoryIds, getInventoryView2D(inventory).selectedCategoryId, -1),
+    );
+  } else if (pressedAny(INVENTORY_CATEGORY_NEXT_KEYS)) {
+    selectInventoryCategory2D(
+      inventory,
+      cycleValue(categoryIds, getInventoryView2D(inventory).selectedCategoryId, 1),
+    );
+  }
+
+  const visibleItems = getInventoryView2D(inventory).items.map((entry) => entry.id);
+  if (pressedAny(INVENTORY_ITEM_PREV_KEYS)) {
+    selectInventoryItem2D(
+      inventory,
+      cycleValue(visibleItems, getInventoryView2D(inventory).selectedItemId, -1),
+    );
+  } else if (pressedAny(INVENTORY_ITEM_NEXT_KEYS)) {
+    selectInventoryItem2D(
+      inventory,
+      cycleValue(visibleItems, getInventoryView2D(inventory).selectedItemId, 1),
+    );
+  }
+
+  syncInventoryUiState(inventory, uiState);
+}
+
+function syncJournalUiState(journal, uiState) {
+  const view = getJournalView2D(journal);
+  uiState.journalSelectedCategoryId = view.selectedCategoryId;
+  uiState.journalSelectedEntryId = view.selectedEntryId;
+}
+
+function applyJournalUiSelection(journal, uiState) {
+  if (uiState.journalSelectedCategoryId) {
+    selectJournalCategory2D(journal, uiState.journalSelectedCategoryId);
+  }
+  const visibleEntries = getJournalView2D(journal).entries;
+  if (uiState.journalSelectedEntryId && visibleEntries.some((entry) => entry.id === uiState.journalSelectedEntryId)) {
+    selectJournalEntry2D(journal, uiState.journalSelectedEntryId);
+  }
+  syncJournalUiState(journal, uiState);
+}
+
+function handleJournalNavigation(journal, uiState) {
+  const categoryIds = getJournalView2D(journal).categories.map((entry) => entry.id);
+  if (pressedAny(JOURNAL_CATEGORY_PREV_KEYS)) {
+    selectJournalCategory2D(
+      journal,
+      cycleValue(categoryIds, getJournalView2D(journal).selectedCategoryId, -1),
+    );
+  } else if (pressedAny(JOURNAL_CATEGORY_NEXT_KEYS)) {
+    selectJournalCategory2D(
+      journal,
+      cycleValue(categoryIds, getJournalView2D(journal).selectedCategoryId, 1),
+    );
+  }
+
+  const entryIds = getJournalView2D(journal).entries.map((entry) => entry.id);
+  if (pressedAny(JOURNAL_ENTRY_PREV_KEYS)) {
+    selectJournalEntry2D(
+      journal,
+      cycleValue(entryIds, getJournalView2D(journal).selectedEntryId, -1),
+    );
+  } else if (pressedAny(JOURNAL_ENTRY_NEXT_KEYS)) {
+    selectJournalEntry2D(
+      journal,
+      cycleValue(entryIds, getJournalView2D(journal).selectedEntryId, 1),
+    );
+  }
+
+  syncJournalUiState(journal, uiState);
+}
+
+function syncDialogueUiState(dialogue, uiState) {
+  const view = getDialogueView2D(dialogue);
+  if (!view.awaitingChoice) {
+    uiState.dialogueSelectedChoiceId = null;
+    return;
+  }
+  const choiceIds = view.choices
+    .filter((entry) => entry.disabled !== true)
+    .map((entry) => entry.id);
+  if (choiceIds.length <= 0) {
+    uiState.dialogueSelectedChoiceId = null;
+    return;
+  }
+  if (!choiceIds.includes(uiState.dialogueSelectedChoiceId)) {
+    uiState.dialogueSelectedChoiceId = choiceIds[0];
+  }
+}
+
+function applyInteractionResult(interactables, result) {
+  for (const entry of interactables) {
+    if (!entry) continue;
+    if (result.collectedIds.includes(entry.id)) entry.collected = true;
+    if (result.openedIds.includes(entry.id)) entry.opened = true;
+    if (result.activatedIds.includes(entry.id)) entry.activated = true;
+  }
 }
 
 export function createGameplayScene(context = {}) {
   const appState = context.appState && typeof context.appState === 'object' ? context.appState : (context.appState = {});
   const adventureSession = ensureSessionState(appState, 'adventure2d', createAdventureSessionSeed());
   const adventureUiState = ensureUiState(appState, 'adventureHud', createAdventureUiStateSeed());
-  const promptState = createInteractionPromptState({ prompt: 'Press E to interact' });
-  const triggerTracker = createTriggerTracker({ subjectId: 'player', dimension: '2d' });
+  const world = createAdventureWorldState();
   const sceneState = {
-    player: createPlayerState(PLAYER_SPAWN),
-    relics: createAdventureObjectives(RELIC_SPAWNS, {
-      dimension: '2d',
-      defaultRadius: ADVENTURE_CONFIG.relicRadius,
+    world,
+    player: createPlayerState(),
+    inventory: createRunInventory(),
+    journal: createRunJournal(),
+    dialogue: createRunDialogue(),
+    interaction: createAdventureInteractionState2D({
+      subjectId: 'player',
+      prompt: 'Press E to interact',
     }),
-    beacons: createBeaconState(),
+    interactables: [],
+    activeCheckpointId: null,
     elapsed: 0,
     runComplete: false,
+    lastDialogueCompletionRevision: 0,
   };
 
   function relicCount() {
-    return countCompletedObjectives(sceneState.relics);
+    return listInventoryItems2D(sceneState.inventory, 'relics')
+      .reduce((total, entry) => total + Number(entry.quantity || 0), 0);
+  }
+
+  function checkpointCount() {
+    return sceneState.interactables
+      .filter((entry) => entry.kind === 'checkpoint' && entry.activated === true)
+      .length;
+  }
+
+  function inventoryView() {
+    return getInventoryView2D(sceneState.inventory);
+  }
+
+  function journalView() {
+    return getJournalView2D(sceneState.journal);
+  }
+
+  function dialogueView() {
+    return getDialogueView2D(sceneState.dialogue);
+  }
+
+  function objectiveText() {
+    if (sceneState.runComplete) {
+      return 'Route secured. Restart when ready.';
+    }
+    if (!hasInventoryItem2D(sceneState.inventory, 'route-console-log')) {
+      return 'Inspect the archive console to recover the route note.';
+    }
+    if (!hasInventoryItem2D(sceneState.inventory, 'dawn-key')) {
+      return 'Recover the Dawn Key from the south gallery.';
+    }
+    return 'Use the Dawn Key on the Moon Gate to clear the route.';
+  }
+
+  function activeCheckpointLabel() {
+    const checkpoint = sceneState.interactables.find((entry) => entry.kind === 'checkpoint' && entry.checkpointId === sceneState.activeCheckpointId) || null;
+    return checkpoint?.label || 'Route Entry';
+  }
+
+  function rebuildInteractables() {
+    sceneState.interactables = [
+      ...normalizeInteractables(sceneState.world, WORLD_OBJECT_LAYERS.pickups),
+      ...normalizeInteractables(sceneState.world, WORLD_OBJECT_LAYERS.checkpoints),
+      ...normalizeInteractables(sceneState.world, WORLD_OBJECT_LAYERS.props),
+      ...normalizeInteractables(sceneState.world, WORLD_OBJECT_LAYERS.locks),
+    ];
   }
 
-  function beaconCount() {
-    return sceneState.beacons.reduce((total, beacon) => total + (beacon.lit === true ? 1 : 0), 0);
+  function focusJournalEntry(categoryId, entryId) {
+    if (categoryId) {
+      selectJournalCategory2D(sceneState.journal, categoryId);
+    }
+    if (entryId) {
+      selectJournalEntry2D(sceneState.journal, entryId);
+    }
+    syncJournalUiState(sceneState.journal, adventureUiState);
   }
 
-  function gateReady() {
-    return objectivesComplete(sceneState.relics) && beaconCount() >= sceneState.beacons.length;
+  function registerConsoleRouteUnlock() {
+    if (!hasInventoryItem2D(sceneState.inventory, 'route-console-log')) {
+      addInventoryItem2D(sceneState.inventory, {
+        id: 'route-console-log',
+        label: WORLD_TEXT.consoleNoteTitle,
+        categoryId: 'field',
+        categoryLabel: 'Field Notes',
+        quantity: 1,
+        badge: 'NOTE',
+        description: 'Recovered from the archive console.',
+        detail: WORLD_TEXT.consoleNoteDetail,
+      });
+    }
+
+    setJournalEntryStatus2D(sceneState.journal, JOURNAL_ENTRY_IDS.routeBrief, 'completed', {
+      badge: 'Completed',
+      meta: 'Archive console route restored',
+    });
+
+    upsertJournalEntry2D(sceneState.journal, {
+      id: JOURNAL_ENTRY_IDS.consoleLog,
+      label: WORLD_TEXT.consoleNoteTitle,
+      categoryId: 'intel',
+      categoryLabel: 'Archive Intel',
+      description: 'Recovered from the archive console.',
+      detail: WORLD_TEXT.consoleNoteDetail,
+      status: 'completed',
+      badge: 'Recovered',
+      updatedAt: 'Recovered at the archive console',
+    });
+
+    upsertJournalEntry2D(sceneState.journal, {
+      id: JOURNAL_ENTRY_IDS.moonGate,
+      label: 'Moon Gate Route',
+      categoryId: 'route',
+      categoryLabel: 'Route',
+      description: 'Carry the Dawn Key to the Moon Gate and restore the exit route.',
+      detail: hasInventoryItem2D(sceneState.inventory, 'dawn-key')
+        ? 'The Dawn Key is secured. Return to the lower gallery and open the gate.'
+        : 'Recover the Dawn Key from the south gallery, then return to the gate.',
+      status: 'active',
+      badge: hasInventoryItem2D(sceneState.inventory, 'dawn-key') ? 'Key Ready' : 'Active',
+      meta: 'Route goal updated',
+    });
+
+    adventureUiState.showJournal = true;
+    focusJournalEntry('route', JOURNAL_ENTRY_IDS.moonGate);
+  }
+
+  function handleDialogueCompletion() {
+    const completion = dialogueView().lastCompletion;
+    if (!completion || completion.revision === sceneState.lastDialogueCompletionRevision) {
+      return;
+    }
+    sceneState.lastDialogueCompletionRevision = completion.revision;
+    if (completion.conversationId === ARCHIVE_CONSOLE_DIALOGUE_ID && completion.outcomeId === 'route-briefed') {
+      registerConsoleRouteUnlock();
+    }
   }
 
   function syncSessionState() {
     adventureSession.lastSceneId = 'gameplay';
     adventureSession.bestRelicCount = Math.max(Number(adventureSession.bestRelicCount || 0), relicCount());
-    adventureSession.bestBeaconCount = Math.max(Number(adventureSession.bestBeaconCount || 0), beaconCount());
+    adventureSession.bestCheckpointCount = Math.max(Number(adventureSession.bestCheckpointCount || 0), checkpointCount());
     adventureSession.bestTimeSeconds = Math.max(Number(adventureSession.bestTimeSeconds || 0), sceneState.elapsed);
     adventureSession.lastElapsedSeconds = Number(sceneState.elapsed.toFixed(2));
-    adventureSession.lastOutcome = sceneState.runComplete ? 'route-cleared' : 'surveying';
+    adventureSession.lastOutcome = sceneState.runComplete
+      ? 'route-cleared'
+      : dialogueView().active === true
+        ? 'dialogue-open'
+        : adventureUiState.showJournal === true
+          ? 'journal-open'
+          : adventureUiState.showInventory === true
+            ? 'inventory-open'
+            : 'surveying';
   }
 
   function syncHud() {
     context.setHudScreen?.('hud', {
       relicCount: relicCount(),
-      relicTarget: sceneState.relics.length,
-      beaconCount: beaconCount(),
-      beaconTarget: sceneState.beacons.length,
-      promptText: promptState.prompt || '',
+      relicTarget: 3,
+      checkpointCount: checkpointCount(),
+      checkpointLabel: activeCheckpointLabel(),
+      promptText: sceneState.interaction.prompt.prompt || '',
+      objectiveText: objectiveText(),
+      zoneLabel: WORLD_TEXT.zoneLabel,
       runComplete: sceneState.runComplete,
       showControlsHint: adventureUiState.showControlsHint !== false,
+      showInventory: adventureUiState.showInventory === true,
+      showJournal: adventureUiState.showJournal === true,
+      inventory: inventoryView(),
+      journal: journalView(),
+      inventoryHint: WORLD_TEXT.inventoryHint,
+      journalHint: WORLD_TEXT.journalHint,
+      dialogueActive: dialogueView().active === true,
       fps: Number(aura.window.getFPS?.() || 0).toFixed(0),
     });
   }
 
+  function syncOverlay() {
+    const activeDialogue = dialogueView();
+    if (activeDialogue.active === true) {
+      syncDialogueUiState(sceneState.dialogue, adventureUiState);
+      context.showOverlayScreen?.('journal', {
+        mode: 'dialogue',
+        dialogue: {
+          ...activeDialogue,
+          selectedChoiceId: adventureUiState.dialogueSelectedChoiceId,
+        },
+        journal: journalView(),
+        zoneLabel: WORLD_TEXT.zoneLabel,
+        title: 'Archive Console Link',
+        controlsText: ADVENTURE_TEXT.dialogueControls,
+      });
+      return;
+    }
+    if (adventureUiState.showJournal === true) {
+      const activeJournal = journalView();
+      context.showOverlayScreen?.('journal', {
+        mode: 'journal',
+        journal: {
+          ...activeJournal,
+          activeEntries: listJournalEntries2D(sceneState.journal, activeJournal.selectedCategoryId),
+        },
+        objectiveText: objectiveText(),
+        zoneLabel: WORLD_TEXT.zoneLabel,
+        controlsText: ADVENTURE_TEXT.journalControls,
+      });
+      return;
+    }
+    context.clearOverlayScreen?.();
+  }
+
   function resetRun() {
-    resetPlayerPosition(sceneState.player, PLAYER_SPAWN);
-    resetAdventureObjectives(sceneState.relics);
-    sceneState.beacons = createBeaconState();
+    ensureAdventureWorldLoaded(sceneState.world);
+    sceneState.inventory = createRunInventory();
+    sceneState.journal = createRunJournal();
+    sceneState.dialogue = createRunDialogue();
+    sceneState.lastDialogueCompletionRevision = 0;
+    rebuildInteractables();
+    sceneState.activeCheckpointId = null;
+    resetPlayerPosition(sceneState.player, resolveAdventurePlayerSpawn(sceneState.world));
+    sceneState.interaction = createAdventureInteractionState2D({
+      subjectId: 'player',
+      prompt: 'Press E to interact',
+    });
     sceneState.elapsed = 0;
     sceneState.runComplete = false;
-    promptState.visible = false;
-    promptState.ready = false;
-    promptState.prompt = null;
-    promptState.triggerId = null;
-    promptState.accepted = false;
-    promptState.acceptedTriggerId = null;
+    adventureUiState.showInventory = false;
+    adventureUiState.showJournal = false;
+    adventureUiState.dialogueSelectedChoiceId = null;
     adventureSession.runsStarted += 1;
+    syncInventoryUiState(sceneState.inventory, adventureUiState);
+    syncJournalUiState(sceneState.journal, adventureUiState);
+    syncDialogueUiState(sceneState.dialogue, adventureUiState);
     syncSessionState();
     syncHud();
+    syncOverlay();
   }
 
-  function buildInteractionTriggers() {
-    const collectedRelics = relicCount();
-    const triggers = [];
-
-    for (const beacon of sceneState.beacons) {
-      if (beacon.lit) continue;
-      const canLight = collectedRelics >= beacon.requiredRelics;
-      triggers.push(createRectTrigger2D(
-        `beacon:${beacon.id}`,
-        beacon.x - beacon.radius,
-        beacon.y - beacon.radius,
-        beacon.radius * 2,
-        beacon.radius * 2,
-        {
-          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',
-        },
-      ));
+  function handleInteractionSideEffects(result) {
+    if (result.checkpointId) {
+      sceneState.activeCheckpointId = result.checkpointId;
+    }
+
+    if (result.activatedIds.includes('301') && !hasInventoryItem2D(sceneState.inventory, 'route-console-log')) {
+      startDialogueConversation2D(sceneState.dialogue, ARCHIVE_CONSOLE_DIALOGUE_ID);
+      adventureUiState.showInventory = false;
+      adventureUiState.showJournal = false;
+      syncDialogueUiState(sceneState.dialogue, adventureUiState);
+    }
+
+    if (result.collectedIds.includes('104')) {
+      upsertJournalEntry2D(sceneState.journal, {
+        id: JOURNAL_ENTRY_IDS.moonGate,
+        label: 'Moon Gate Route',
+        categoryId: 'route',
+        categoryLabel: 'Route',
+        description: 'Carry the Dawn Key to the Moon Gate and restore the exit route.',
+        detail: 'The Dawn Key is secured. Return to the lower gallery and open the gate.',
+        status: 'active',
+        badge: 'Key Ready',
+        meta: 'Dawn Key secured',
+      });
     }
 
-    triggers.push(createRectTrigger2D(
-      'exit-gate',
-      EXIT_GATE.x - ADVENTURE_CONFIG.exitPadding,
-      EXIT_GATE.y - ADVENTURE_CONFIG.exitPadding,
-      EXIT_GATE.w + (ADVENTURE_CONFIG.exitPadding * 2),
-      EXIT_GATE.h + (ADVENTURE_CONFIG.exitPadding * 2),
-      {
-        role: 'goal',
-        priority: gateReady() ? 8 : 1,
-        promptText: gateReady()
-          ? 'Press E to leave through the Moon Gate'
-          : 'Collect every relic and light both beacons to open the gate',
-        interactionKey: 'E',
-      },
-    ));
-
-    return triggers;
+    if (result.openedIds.includes('401')) {
+      sceneState.runComplete = true;
+      setJournalEntryStatus2D(sceneState.journal, JOURNAL_ENTRY_IDS.moonGate, 'completed', {
+        badge: 'Completed',
+        meta: 'Moon Gate opened',
+      });
+    }
   }
 
-  function handleAcceptedPrompt() {
-    const acceptedTriggerId = promptState.acceptedTriggerId;
-    if (!acceptedTriggerId) return;
+  function handleDialogueInput() {
+    const view = dialogueView();
+    if (view.active !== true) {
+      return false;
+    }
 
-    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;
+    syncDialogueUiState(sceneState.dialogue, adventureUiState);
+    if (view.awaitingChoice === true) {
+      const choiceIds = view.choices
+        .filter((entry) => entry.disabled !== true)
+        .map((entry) => entry.id);
+      if (pressedAny(DIALOGUE_CHOICE_PREV_KEYS)) {
+        adventureUiState.dialogueSelectedChoiceId = cycleValue(choiceIds, adventureUiState.dialogueSelectedChoiceId, -1);
+      } else if (pressedAny(DIALOGUE_CHOICE_NEXT_KEYS)) {
+        adventureUiState.dialogueSelectedChoiceId = cycleValue(choiceIds, adventureUiState.dialogueSelectedChoiceId, 1);
       }
-    } else if (acceptedTriggerId === 'exit-gate' && gateReady()) {
-      sceneState.runComplete = true;
+      if (pressedInteract() || pressedAny(DIALOGUE_ADVANCE_KEYS)) {
+        chooseDialogueChoice2D(
+          sceneState.dialogue,
+          adventureUiState.dialogueSelectedChoiceId || choiceIds[0] || null,
+        );
+      }
+    } else if (pressedInteract() || pressedAny(DIALOGUE_ADVANCE_KEYS)) {
+      advanceDialogueConversation2D(sceneState.dialogue);
     }
+
+    syncDialogueUiState(sceneState.dialogue, adventureUiState);
+    adventureUiState.showControlsHint = false;
+    handleDialogueCompletion();
+    return true;
   }
 
   return {
@@ -188,19 +619,65 @@ export function createGameplayScene(context = {}) {
     },
 
     update(dt) {
+      applyInventoryUiSelection(sceneState.inventory, adventureUiState);
+      applyJournalUiSelection(sceneState.journal, adventureUiState);
+      syncDialogueUiState(sceneState.dialogue, adventureUiState);
       sceneState.elapsed += dt;
 
       if (sceneState.runComplete) {
+        if (pressedAny(JOURNAL_TOGGLE_KEYS)) {
+          adventureUiState.showJournal = adventureUiState.showJournal !== true;
+        }
         if (aura.input.isKeyPressed('enter')) {
           resetRun();
+          return;
         }
+        syncSessionState();
         syncHud();
+        syncOverlay();
+        return;
+      }
+
+      if (handleDialogueInput()) {
+        syncSessionState();
+        syncHud();
+        syncOverlay();
         return;
       }
 
       if (aura.input.isKeyPressed('h')) {
         adventureUiState.showControlsHint = adventureUiState.showControlsHint !== true;
       }
+      if (pressedAny(INVENTORY_TOGGLE_KEYS)) {
+        adventureUiState.showInventory = adventureUiState.showInventory !== true;
+        if (adventureUiState.showInventory === true) {
+          adventureUiState.showJournal = false;
+        }
+        adventureUiState.showControlsHint = false;
+      }
+      if (pressedAny(JOURNAL_TOGGLE_KEYS)) {
+        adventureUiState.showJournal = adventureUiState.showJournal !== true;
+        if (adventureUiState.showJournal === true) {
+          adventureUiState.showInventory = false;
+        }
+        adventureUiState.showControlsHint = false;
+      }
+
+      if (adventureUiState.showInventory === true) {
+        handleInventoryNavigation(sceneState.inventory, adventureUiState);
+        syncSessionState();
+        syncHud();
+        syncOverlay();
+        return;
+      }
+
+      if (adventureUiState.showJournal === true) {
+        handleJournalNavigation(sceneState.journal, adventureUiState);
+        syncSessionState();
+        syncHud();
+        syncOverlay();
+        return;
+      }
 
       const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
       const moveY = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
@@ -213,41 +690,55 @@ export function createGameplayScene(context = {}) {
       }
 
       moveActorThroughAdventureWorld(
+        sceneState.world,
         sceneState.player,
         moveX * ADVENTURE_CONFIG.playerSpeed * dt,
         moveY * ADVENTURE_CONFIG.playerSpeed * dt,
         ADVENTURE_CONFIG.playerSize,
       );
 
-      collectAdventureObjectives2D(sceneState.player, sceneState.relics);
-
       const playerRect = centeredRect(
         sceneState.player.x,
         sceneState.player.y,
         ADVENTURE_CONFIG.playerSize * 0.84,
         ADVENTURE_CONFIG.playerSize * 0.84,
       );
-      const triggerStep = stepRectTriggers2D(triggerTracker, playerRect, buildInteractionTriggers());
-      updateInteractionPromptState(promptState, triggerStep, {
-        interactPressed: pressedInteract(),
-      });
-      handleAcceptedPrompt();
+      const interactionResult = stepAdventureInteractables2D(
+        sceneState.interaction,
+        playerRect,
+        sceneState.interactables,
+        {
+          inventory: sceneState.inventory,
+          interactPressed: pressedInteract(),
+        },
+      );
+      applyInteractionResult(sceneState.interactables, interactionResult);
+      handleInteractionSideEffects(interactionResult);
+      if (interactionResult.acceptedId) {
+        syncInventoryUiState(sceneState.inventory, adventureUiState);
+        syncJournalUiState(sceneState.journal, adventureUiState);
+      }
+
       syncSessionState();
       syncHud();
+      syncOverlay();
     },
 
     onExit() {
       context.clearHudScreen?.();
+      context.clearOverlayScreen?.();
     },
 
     draw() {
-      aura.draw2d.clear(aura.rgba(0.03, 0.04, 0.06, 1.0));
+      aura.draw2d.clear(aura.rgba(0.02, 0.03, 0.05, 1.0));
       drawAdventureWorld({
-        beacons: sceneState.beacons,
-        gateReady: gateReady(),
+        world: sceneState.world,
+        interactables: sceneState.interactables,
         elapsed: sceneState.elapsed,
+        activeCheckpointId: sceneState.activeCheckpointId,
+        runComplete: sceneState.runComplete,
       });
-      drawAdventureRelics(sceneState.relics, sceneState.elapsed);
+      drawAdventureRelics(sceneState.interactables, sceneState.elapsed);
       drawAdventurePlayer(sceneState.player, ADVENTURE_CONFIG, {
         runComplete: sceneState.runComplete,
       });