@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/helpers/starter-utils/core.js

@@ -0,0 +1,150 @@
+export function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+}
+
+export function axisFromKeys(input, negativeKeys, positiveKeys) {
+  const positive = positiveKeys.some((key) => input.isKeyDown(key)) ? 1 : 0;
+  const negative = negativeKeys.some((key) => input.isKeyDown(key)) ? 1 : 0;
+  return positive - negative;
+}
+
+export function createCooldown(durationSeconds) {
+  return {
+    duration: Math.max(0, Number(durationSeconds) || 0),
+    remaining: 0,
+  };
+}
+
+export function tickCooldown(cooldown, dt) {
+  cooldown.remaining = Math.max(0, cooldown.remaining - Math.max(0, Number(dt) || 0));
+}
+
+export function consumeCooldown(cooldown) {
+  if (cooldown.remaining > 0) return false;
+  cooldown.remaining = cooldown.duration;
+  return true;
+}
+
+export function createIntervalSpawner(intervalSeconds, options = {}) {
+  const interval = Math.max(0.016, Number(intervalSeconds) || 0.5);
+  const startReady = options.startReady === true;
+  return {
+    interval,
+    remaining: startReady ? 0 : interval,
+  };
+}
+
+export function tickIntervalSpawner(spawner, dt, onSpawn = null) {
+  spawner.remaining -= Math.max(0, Number(dt) || 0);
+  let spawned = 0;
+
+  while (spawner.remaining <= 0) {
+    spawned += 1;
+    spawner.remaining += spawner.interval;
+    if (typeof onSpawn === 'function') {
+      onSpawn(spawned);
+    }
+  }
+
+  return spawned;
+}
+
+export function centeredRect(cx, cy, w, h) {
+  return {
+    x: cx - (w * 0.5),
+    y: cy - (h * 0.5),
+    w,
+    h,
+  };
+}
+
+export function rectsOverlap(a, b) {
+  return (
+    a.x < b.x + b.w &&
+    a.x + a.w > b.x &&
+    a.y < b.y + b.h &&
+    a.y + a.h > b.y
+  );
+}
+
+function resolvePosition2D(value) {
+  if (!value || typeof value !== 'object') {
+    return { x: 0, y: 0 };
+  }
+  if (typeof value.x === 'number' && typeof value.y === 'number') {
+    return value;
+  }
+  if (value.position && typeof value.position === 'object') {
+    return resolvePosition2D(value.position);
+  }
+  return { x: 0, y: 0 };
+}
+
+export function distanceSquared2D(a, b) {
+  const left = resolvePosition2D(a);
+  const right = resolvePosition2D(b);
+  const dx = left.x - right.x;
+  const dy = left.y - right.y;
+  return (dx * dx) + (dy * dy);
+}
+
+export function removeWhere(items, predicate) {
+  let removed = 0;
+  for (let i = items.length - 1; i >= 0; i -= 1) {
+    if (!predicate(items[i], i)) continue;
+    items.splice(i, 1);
+    removed += 1;
+  }
+  return removed;
+}
+
+function resolvePosition3D(value) {
+  if (!value || typeof value !== 'object') {
+    return { x: 0, y: 0, z: 0 };
+  }
+  if (typeof value.x === 'number' && typeof value.y === 'number' && typeof value.z === 'number') {
+    return value;
+  }
+  if (value.position && typeof value.position === 'object') {
+    return resolvePosition3D(value.position);
+  }
+  return { x: 0, y: 0, z: 0 };
+}
+
+export function distanceSquared3D(a, b) {
+  const left = resolvePosition3D(a);
+  const right = resolvePosition3D(b);
+  const dx = left.x - right.x;
+  const dy = left.y - right.y;
+  const dz = left.z - right.z;
+  return (dx * dx) + (dy * dy) + (dz * dz);
+}
+
+export function tryJump(body, jumpSpeed) {
+  if (!body.onGround) return false;
+  body.vy = Number(jumpSpeed) || 0;
+  body.onGround = false;
+  return true;
+}
+
+export function stepVerticalMotion(body, dt, gravity, supportY) {
+  const frameDt = Math.max(0, Number(dt) || 0);
+  const grav = Math.max(0, Number(gravity) || 0);
+  const floorY = Number(supportY) || 0;
+
+  body.vy -= grav * frameDt;
+  body.y += body.vy * frameDt;
+
+  if (body.y <= floorY) {
+    body.y = floorY;
+    body.vy = 0;
+    body.onGround = true;
+  } else {
+    body.onGround = false;
+  }
+
+  return body.onGround;
+}

package/src/helpers/starter-utils/dialogue-2d.js

@@ -0,0 +1,351 @@
+function normalizeId(value, fallback = null) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return String(value);
+  }
+  return fallback;
+}
+
+function normalizeText(value, fallback = null) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function normalizeLineEntry(entry, index, fallbackSpeaker = null) {
+  const raw = typeof entry === 'string'
+    ? { text: entry }
+    : (entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null);
+  const text = normalizeText(raw?.text ?? raw?.line ?? raw?.label, null);
+  if (!text) return null;
+  return {
+    id: normalizeId(raw?.id, `line-${index + 1}`),
+    text,
+    speaker: normalizeText(raw?.speaker, fallbackSpeaker),
+    cue: normalizeText(raw?.cue),
+  };
+}
+
+function normalizeChoiceEntry(entry, index) {
+  const raw = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+  const label = normalizeText(raw?.label ?? raw?.text ?? raw?.title, null);
+  if (!label) return null;
+  return {
+    id: normalizeId(raw?.id, `choice-${index + 1}`),
+    label,
+    detail: normalizeText(raw?.detail ?? raw?.description),
+    nextNodeId: normalizeId(raw?.nextNodeId ?? raw?.next ?? raw?.target),
+    outcomeId: normalizeId(raw?.outcomeId ?? raw?.outcome ?? raw?.result),
+    disabled: raw?.disabled === true,
+  };
+}
+
+function normalizeNodeEntry(entry, index, fallbackSpeaker = null) {
+  const raw = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+  const id = normalizeId(raw?.id, `node-${index + 1}`);
+  const speaker = normalizeText(raw?.speaker, fallbackSpeaker);
+  const rawLines = Array.isArray(raw?.lines)
+    ? raw.lines
+    : [raw?.line ?? raw?.text].filter((value) => value != null);
+  const lines = rawLines
+    .map((lineEntry, lineIndex) => normalizeLineEntry(lineEntry, lineIndex, speaker))
+    .filter(Boolean);
+  const choices = (Array.isArray(raw?.choices) ? raw.choices : [])
+    .map((choiceEntry, choiceIndex) => normalizeChoiceEntry(choiceEntry, choiceIndex))
+    .filter(Boolean);
+  return {
+    id,
+    label: normalizeText(raw?.label ?? raw?.title, id),
+    speaker,
+    lines,
+    choices,
+    nextNodeId: normalizeId(raw?.nextNodeId ?? raw?.next ?? raw?.target),
+    outcomeId: normalizeId(raw?.outcomeId ?? raw?.outcome ?? raw?.result),
+  };
+}
+
+function normalizeConversationEntry(entry, index = 0) {
+  const raw = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+  const id = normalizeId(raw?.id, `conversation-${index + 1}`);
+  const speaker = normalizeText(raw?.speaker);
+  const nodes = (Array.isArray(raw?.nodes) ? raw.nodes : [])
+    .map((nodeEntry, nodeIndex) => normalizeNodeEntry(nodeEntry, nodeIndex, speaker))
+    .filter(Boolean);
+  const nodesById = Object.fromEntries(nodes.map((node) => [node.id, node]));
+  const startNodeId = normalizeId(raw?.startNodeId ?? raw?.start, nodes[0]?.id || null);
+  return {
+    id,
+    title: normalizeText(raw?.title ?? raw?.label, id),
+    speaker,
+    startNodeId: Object.prototype.hasOwnProperty.call(nodesById, startNodeId) ? startNodeId : (nodes[0]?.id || null),
+    nodes,
+    nodesById,
+  };
+}
+
+function touchDialogueState(state) {
+  if (!state || typeof state !== 'object') return;
+  state.revision = Number(state.revision || 0) + 1;
+}
+
+function getConversationStore(state) {
+  return state && typeof state === 'object' && state.conversations && typeof state.conversations === 'object'
+    ? state.conversations
+    : null;
+}
+
+function getActiveConversation(state) {
+  const store = getConversationStore(state);
+  const conversationId = normalizeId(state?.activeConversationId);
+  if (!store || !conversationId) return null;
+  return store[conversationId] || null;
+}
+
+function getActiveNode(state, conversation = getActiveConversation(state)) {
+  const nodeId = normalizeId(state?.activeNodeId);
+  if (!conversation || !nodeId) return null;
+  return conversation.nodesById[nodeId] || null;
+}
+
+function getNodeViewLineIndex(node, state) {
+  if (!node || !Array.isArray(node.lines) || node.lines.length <= 0) return -1;
+  const rawIndex = Number(state?.activeLineIndex || 0);
+  const safeIndex = Number.isFinite(rawIndex) ? Math.max(0, Math.floor(rawIndex)) : 0;
+  return Math.min(safeIndex, node.lines.length - 1);
+}
+
+function choicesVisible(node, state) {
+  if (!node || !Array.isArray(node.choices) || node.choices.length <= 0) return false;
+  if (!Array.isArray(node.lines) || node.lines.length <= 0) return true;
+  return getNodeViewLineIndex(node, state) >= node.lines.length - 1;
+}
+
+function resetActiveDialogueState(state) {
+  state.activeConversationId = null;
+  state.activeNodeId = null;
+  state.activeLineIndex = 0;
+  state.lastChoiceId = null;
+  state.visitedNodeIds = [];
+}
+
+function transitionToNode(state, conversation, nextNodeId) {
+  const targetId = normalizeId(nextNodeId);
+  if (!targetId || !conversation?.nodesById?.[targetId]) return false;
+  state.activeConversationId = conversation.id;
+  state.activeNodeId = targetId;
+  state.activeLineIndex = 0;
+  state.visitedNodeIds.push(targetId);
+  return true;
+}
+
+function cloneCompletion(completion) {
+  if (!completion || typeof completion !== 'object') return null;
+  return {
+    conversationId: normalizeId(completion.conversationId),
+    outcomeId: normalizeId(completion.outcomeId),
+    nodeId: normalizeId(completion.nodeId),
+    lineIndex: Number.isFinite(completion.lineIndex) ? completion.lineIndex : -1,
+    choiceId: normalizeId(completion.choiceId),
+    reason: normalizeId(completion.reason),
+    visitedNodeIds: Array.isArray(completion.visitedNodeIds) ? [...completion.visitedNodeIds] : [],
+    revision: Number(completion.revision || 0),
+  };
+}
+
+function registerConversationInternal(state, conversation, { touch = true } = {}) {
+  const store = getConversationStore(state);
+  if (!store) return null;
+  const normalized = normalizeConversationEntry(conversation, state.conversationOrder.length);
+  store[normalized.id] = normalized;
+  if (!Array.isArray(state.conversationOrder)) {
+    state.conversationOrder = [];
+  }
+  if (!state.conversationOrder.includes(normalized.id)) {
+    state.conversationOrder.push(normalized.id);
+  }
+  if (touch) touchDialogueState(state);
+  return normalized;
+}
+
+export function createDialogueState2D(options = {}) {
+  const state = {
+    conversations: {},
+    conversationOrder: [],
+    activeConversationId: null,
+    activeNodeId: null,
+    activeLineIndex: 0,
+    lastChoiceId: null,
+    lastCompletion: null,
+    visitedNodeIds: [],
+    revision: 0,
+  };
+
+  for (const conversation of (Array.isArray(options.conversations) ? options.conversations : [])) {
+    registerConversationInternal(state, conversation, { touch: false });
+  }
+
+  if (options.startConversationId) {
+    startDialogueConversation2D(state, options.startConversationId);
+  }
+
+  return state;
+}
+
+export function registerDialogueConversation2D(state, conversation) {
+  return registerConversationInternal(state, conversation, { touch: true });
+}
+
+export function startDialogueConversation2D(state, conversationOrId, options = {}) {
+  const conversation = typeof conversationOrId === 'string'
+    ? getConversationStore(state)?.[normalizeId(conversationOrId)] || null
+    : registerConversationInternal(state, conversationOrId, { touch: true });
+  if (!conversation) return getDialogueView2D(state);
+
+  const startNodeId = normalizeId(options.startNodeId, conversation.startNodeId);
+  if (!startNodeId || !conversation.nodesById[startNodeId]) return getDialogueView2D(state);
+
+  state.activeConversationId = conversation.id;
+  state.activeNodeId = startNodeId;
+  state.activeLineIndex = 0;
+  state.lastChoiceId = null;
+  state.visitedNodeIds = [startNodeId];
+  touchDialogueState(state);
+  return getDialogueView2D(state);
+}
+
+export function completeDialogueConversation2D(state, outcomeId = 'completed', options = {}) {
+  const conversation = getActiveConversation(state);
+  const node = getActiveNode(state, conversation);
+  if (!conversation) return cloneCompletion(state?.lastCompletion);
+
+  const completion = {
+    conversationId: conversation.id,
+    outcomeId: normalizeId(outcomeId, 'completed'),
+    nodeId: normalizeId(options.nodeId, node?.id || null),
+    lineIndex: getNodeViewLineIndex(node, state),
+    choiceId: normalizeId(options.choiceId, state?.lastChoiceId || null),
+    reason: normalizeId(options.reason, 'completed'),
+    visitedNodeIds: Array.isArray(state?.visitedNodeIds) ? [...state.visitedNodeIds] : [],
+    revision: 0,
+  };
+
+  resetActiveDialogueState(state);
+  touchDialogueState(state);
+  completion.revision = Number(state.revision || 0);
+  state.lastCompletion = completion;
+  return cloneCompletion(completion);
+}
+
+export function advanceDialogueConversation2D(state) {
+  const conversation = getActiveConversation(state);
+  const node = getActiveNode(state, conversation);
+  if (!conversation || !node) return getDialogueView2D(state);
+
+  if (choicesVisible(node, state)) {
+    return getDialogueView2D(state);
+  }
+
+  const lineIndex = getNodeViewLineIndex(node, state);
+  if (lineIndex >= 0 && lineIndex < node.lines.length - 1) {
+    state.activeLineIndex = lineIndex + 1;
+    touchDialogueState(state);
+    return getDialogueView2D(state);
+  }
+
+  if (node.nextNodeId) {
+    if (transitionToNode(state, conversation, node.nextNodeId)) {
+      touchDialogueState(state);
+      return getDialogueView2D(state);
+    }
+    completeDialogueConversation2D(state, node.outcomeId || 'completed', {
+      reason: 'missing_next_node',
+    });
+    return getDialogueView2D(state);
+  }
+
+  completeDialogueConversation2D(state, node.outcomeId || 'completed', {
+    reason: 'node_complete',
+  });
+  return getDialogueView2D(state);
+}
+
+export function chooseDialogueChoice2D(state, choiceId) {
+  const conversation = getActiveConversation(state);
+  const node = getActiveNode(state, conversation);
+  if (!conversation || !node || !choicesVisible(node, state)) {
+    return getDialogueView2D(state);
+  }
+
+  const targetId = normalizeId(choiceId);
+  const choice = node.choices.find((entry) => entry.id === targetId && entry.disabled !== true) || null;
+  if (!choice) return getDialogueView2D(state);
+
+  state.lastChoiceId = choice.id;
+  if (choice.nextNodeId) {
+    if (transitionToNode(state, conversation, choice.nextNodeId)) {
+      touchDialogueState(state);
+      return getDialogueView2D(state);
+    }
+    completeDialogueConversation2D(state, choice.outcomeId || node.outcomeId || 'completed', {
+      choiceId: choice.id,
+      reason: 'missing_next_node',
+    });
+    return getDialogueView2D(state);
+  }
+
+  completeDialogueConversation2D(state, choice.outcomeId || node.outcomeId || 'completed', {
+    choiceId: choice.id,
+    reason: 'choice_selected',
+  });
+  return getDialogueView2D(state);
+}
+
+export function getDialogueView2D(state) {
+  const conversation = getActiveConversation(state);
+  const node = getActiveNode(state, conversation);
+  const lineIndex = getNodeViewLineIndex(node, state);
+  const line = lineIndex >= 0 ? node.lines[lineIndex] || null : null;
+  const awaitingChoice = choicesVisible(node, state);
+  const choices = awaitingChoice
+    ? node.choices.map((entry) => ({
+      id: entry.id,
+      label: entry.label,
+      detail: entry.detail,
+      nextNodeId: entry.nextNodeId,
+      outcomeId: entry.outcomeId,
+      disabled: entry.disabled === true,
+    }))
+    : [];
+  const canAdvance = Boolean(node) && awaitingChoice !== true && (
+    (lineIndex >= 0 && lineIndex < node.lines.length - 1)
+    || Boolean(node?.nextNodeId)
+    || (Boolean(node) && !node?.nextNodeId && choices.length === 0)
+  );
+
+  return {
+    active: Boolean(conversation && node),
+    conversationId: conversation?.id || null,
+    title: conversation?.title || null,
+    nodeId: node?.id || null,
+    nodeLabel: node?.label || null,
+    lineIndex,
+    lineCount: Array.isArray(node?.lines) ? node.lines.length : 0,
+    line: line ? {
+      id: line.id,
+      text: line.text,
+      speaker: line.speaker,
+      cue: line.cue,
+      index: lineIndex,
+    } : null,
+    choices,
+    awaitingChoice,
+    canAdvance,
+    lastChoiceId: normalizeId(state?.lastChoiceId),
+    visitedNodeIds: Array.isArray(state?.visitedNodeIds) ? [...state.visitedNodeIds] : [],
+    lastCompletion: cloneCompletion(state?.lastCompletion),
+    revision: Number(state?.revision || 0),
+  };
+}

package/src/helpers/starter-utils/enemy-archetypes-2d.js

@@ -0,0 +1,68 @@
+const ENEMY_ARCHETYPES_2D = Object.freeze({
+  scout: Object.freeze({
+    id: 'scout',
+    size: 24,
+    speedMin: 180,
+    speedMax: 260,
+    scoreValue: 8,
+    color: { r: 1.0, g: 0.44, b: 0.44 },
+  }),
+  striker: Object.freeze({
+    id: 'striker',
+    size: 30,
+    speedMin: 120,
+    speedMax: 210,
+    scoreValue: 12,
+    color: { r: 1.0, g: 0.58, b: 0.32 },
+  }),
+  tank: Object.freeze({
+    id: 'tank',
+    size: 38,
+    speedMin: 90,
+    speedMax: 150,
+    scoreValue: 20,
+    color: { r: 0.96, g: 0.34, b: 0.76 },
+  }),
+});
+
+export function listEnemyArchetypeIds2D() {
+  return Object.keys(ENEMY_ARCHETYPES_2D);
+}
+
+export function getEnemyArchetype2D(id) {
+  return ENEMY_ARCHETYPES_2D[id] || ENEMY_ARCHETYPES_2D.striker;
+}
+
+export function pickEnemyArchetypeForWave2D(waveIndex) {
+  const ids = listEnemyArchetypeIds2D();
+  if (ids.length === 0) return ENEMY_ARCHETYPES_2D.striker;
+  const normalized = Math.max(0, Math.trunc(Number(waveIndex) || 0));
+  const id = ids[normalized % ids.length];
+  return getEnemyArchetype2D(id);
+}
+
+export function spawnEnemy2D(options = {}) {
+  const {
+    x = 0,
+    y = 0,
+    waveIndex = 0,
+    archetypeId = null,
+    random = Math.random,
+  } = options;
+  const archetype = archetypeId
+    ? getEnemyArchetype2D(archetypeId)
+    : pickEnemyArchetypeForWave2D(waveIndex);
+
+  const randomValue = Math.max(0, Math.min(1, Number(random()) || 0));
+  const speed = archetype.speedMin + (randomValue * (archetype.speedMax - archetype.speedMin));
+
+  return {
+    x,
+    y,
+    speed,
+    size: archetype.size,
+    scoreValue: archetype.scoreValue,
+    color: archetype.color,
+    archetype: archetype.id,
+  };
+}

package/src/helpers/starter-utils/index.js

@@ -0,0 +1,26 @@
+import { clamp, axisFromKeys, createCooldown, tickCooldown, consumeCooldown, createIntervalSpawner, tickIntervalSpawner, centeredRect, rectsOverlap, removeWhere, distanceSquared2D, distanceSquared3D, tryJump, stepVerticalMotion } from './core.js';
+import { createSpriteAnimationLibrary2D, hasSpriteAnimationState2D, createSpriteAnimationRuntime2D, registerSpriteAnimationLibrary2D, createSpriteAnimator2D, playSpriteAnimator2D, syncSpriteAnimatorState2D, stepSpriteAnimationRuntime2D, getSpriteAnimatorState2D, resolveSpriteAnimatorFrame2D, drawSpriteAnimator2D, resolveSpriteFrameRect2D } from './animation-2d.js';
+import { createAnimationPackage2D, hasAnimationPackageState2D, registerAnimationPackage2D, createPackagedSpriteAnimator2D, getAnimationPackageLibrary2D, getAnimationPackageState2D } from './animation-packaging-2d.js';
+import { createAtlasAssetManifest2D, createAnimationPackageFromAtlasAsset2D } from './atlas-assets-2d.js';
+import { createSceneAudio2D, configureSceneAudio2D, ensureSceneMusic2D, setSceneMusicVolume2D, duckSceneMusic2D, playSceneStinger2D, pauseSceneAudio2D, resumeSceneAudio2D, syncSceneAudio2D, stopSceneAudio2D } from './scene-audio-2d.js';
+import { propertyTween2D, delayTween2D, sequenceTweens2D, parallelTweens2D, repeatTween2D, yoyoTween2D, moveTo2D, driftTo2D, fadeTo2D, scaleTo2D, rotateTo2D, pulse2D, punch2D, settleTo2D, createTweenComposer2D, playTweenPlan2D, cancelTweenPlan2D, stepTweenComposer2D, getTweenHandleState2D, isTweenHandleActive2D } from './tween-2d.js';
+import { createFloatingTextLayer2D, spawnFloatingText2D, stepFloatingTextLayer2D, getFloatingTextRenderState2D, drawFloatingTextLayer2D, createHitFlash2D, triggerHitFlash2D, stepHitFlash2D, isHitFlashVisible2D, createHitSparkLayer2D, spawnHitSpark2D, stepHitSparkLayer2D, drawHitSparkLayer2D, createHoverLift2D, setHoverLiftActive2D, stepHoverLift2D, getHoverLiftOffset2D } from './combat-feedback-2d.js';
+import { applyShieldedDamage2D, stepShieldRecharge2D, restoreShieldedHealth2D, createWeightedDropTable2D, rollWeightedDrop2D, createEncounterPressure2D, recordEncounterKill2D, stepEncounterPressure2D, advanceBossPhase2D } from './combat-runtime-2d.js';
+import { createRectTrigger2D, createProximityTrigger3D, createVolumeTrigger3D, createTriggerTracker, getTriggerTrackerSnapshot, stepRectTriggers2D, stepVolumeTriggers3D, stepTriggerTracker, resolveTriggerInteraction, createInteractionPromptState, updateInteractionPromptState } from './triggers.js';
+import { createWaveDirector, activeWave, stepWaveDirector } from './wave-director.js';
+import { listEnemyArchetypeIds2D, getEnemyArchetype2D, pickEnemyArchetypeForWave2D, spawnEnemy2D } from './enemy-archetypes-2d.js';
+import { createAutoplayController2D, setAutoplayEnabled2D, toggleAutoplayEnabled2D, resolveAutoplayControl2D, createRenderTargetExportState2D, queueRenderTargetExport2D, flushRenderTargetExport2D } from './autoplay-debug-2d.js';
+import { createInventory2D, addInventoryItem2D, removeInventoryItem2D, hasInventoryItem2D, listInventoryItems2D, selectInventoryCategory2D, selectInventoryItem2D, getSelectedInventoryItem2D, setInventoryItemEquipped2D, getInventoryView2D } from './inventory-2d.js';
+import { createDialogueState2D, registerDialogueConversation2D, startDialogueConversation2D, advanceDialogueConversation2D, chooseDialogueChoice2D, completeDialogueConversation2D, getDialogueView2D } from './dialogue-2d.js';
+import { createJournal2D, upsertJournalEntry2D, setJournalEntryStatus2D, listJournalEntries2D, selectJournalCategory2D, selectJournalEntry2D, getSelectedJournalEntry2D, getJournalView2D } from './journal-2d.js';
+import { createTilemapWorld2D, ensureTilemapWorldLoaded2D, unloadTilemapWorld2D, drawTilemapWorld2D, listTilemapWorldObjects2D, findTilemapWorldObject2D, resolveTilemapSpawn2D, queryTilemapWorldPoint2D, queryTilemapWorldAABB2D, isTilemapPointBlocked2D, moveActorThroughTilemapWorld2D } from './tilemap-world-2d.js';
+import { createStreamedWorld2D, listLoadedStreamedWorldRegions2D, findStreamedWorldRegionAtPoint2D, syncStreamedWorldFocus2D, queryStreamedWorldPoint2D, queryStreamedWorldAABB2D, queryStreamedWorldRay2D, unloadStreamedWorld2D } from './streamed-world-2d.js';
+import { captureStreamedWorldSnapshot2D, applyStreamedWorldSnapshot2D, saveStreamedWorldSnapshot2D, loadStreamedWorldSnapshot2D, deleteStreamedWorldSnapshot2D } from './world-persistence-2d.js';
+import { createTilemapNav2D, rebuildTilemapNav2D, invalidateTilemapNav2D, collectTilemapOccupiedCells2D, setTilemapNavOccupiedCells2D, findTilemapPath2D, resolveTilemapStep2D } from './tilemap-nav-2d.js';
+import { createWorldCompositor2D, ensureWorldCompositorTargets2D, destroyWorldCompositor2D, runWorldCompositor2D } from './world-compositor-2d.js';
+import { createAdventureInteractable2D, createAdventureInteractablesFromTilemapObjects2D, createAdventureInteractionState2D, stepAdventureInteractables2D } from './adventure-world-2d.js';
+import { createCheckpointSystem, updateCheckpointProgress, activeCheckpoint, respawnAtCheckpoint, createGoalZone, isGoalReached, createMovingPlatform3D, stepMovingPlatform3D } from './platformer-3d.js';
+import { createCharacterAvatar3D, setAvatarInput3D, setAvatarVisual3D, spawnCharacterAvatar3D, tickCharacterAvatar3D, getAvatarState3D, getAvatarRenderTransform3D } from './avatar-3d.js';
+import { createAdventureObjectives, resetAdventureObjectives, countCompletedObjectives, objectivesComplete, firstPendingObjective, collectAdventureObjectives2D, collectAdventureObjectives3D } from './adventure-objectives.js';
+
+export { clamp, axisFromKeys, createCooldown, tickCooldown, consumeCooldown, createIntervalSpawner, tickIntervalSpawner, centeredRect, rectsOverlap, removeWhere, distanceSquared2D, distanceSquared3D, tryJump, stepVerticalMotion, createSpriteAnimationLibrary2D, hasSpriteAnimationState2D, createSpriteAnimationRuntime2D, registerSpriteAnimationLibrary2D, createSpriteAnimator2D, playSpriteAnimator2D, syncSpriteAnimatorState2D, stepSpriteAnimationRuntime2D, getSpriteAnimatorState2D, resolveSpriteAnimatorFrame2D, drawSpriteAnimator2D, resolveSpriteFrameRect2D, createAnimationPackage2D, hasAnimationPackageState2D, registerAnimationPackage2D, createPackagedSpriteAnimator2D, getAnimationPackageLibrary2D, getAnimationPackageState2D, createAtlasAssetManifest2D, createAnimationPackageFromAtlasAsset2D, createSceneAudio2D, configureSceneAudio2D, ensureSceneMusic2D, setSceneMusicVolume2D, duckSceneMusic2D, playSceneStinger2D, pauseSceneAudio2D, resumeSceneAudio2D, syncSceneAudio2D, stopSceneAudio2D, propertyTween2D, delayTween2D, sequenceTweens2D, parallelTweens2D, repeatTween2D, yoyoTween2D, moveTo2D, driftTo2D, fadeTo2D, scaleTo2D, rotateTo2D, pulse2D, punch2D, settleTo2D, createTweenComposer2D, playTweenPlan2D, cancelTweenPlan2D, stepTweenComposer2D, getTweenHandleState2D, isTweenHandleActive2D, createFloatingTextLayer2D, spawnFloatingText2D, stepFloatingTextLayer2D, getFloatingTextRenderState2D, drawFloatingTextLayer2D, createHitFlash2D, triggerHitFlash2D, stepHitFlash2D, isHitFlashVisible2D, createHitSparkLayer2D, spawnHitSpark2D, stepHitSparkLayer2D, drawHitSparkLayer2D, createHoverLift2D, setHoverLiftActive2D, stepHoverLift2D, getHoverLiftOffset2D, applyShieldedDamage2D, stepShieldRecharge2D, restoreShieldedHealth2D, createWeightedDropTable2D, rollWeightedDrop2D, createEncounterPressure2D, recordEncounterKill2D, stepEncounterPressure2D, advanceBossPhase2D, createRectTrigger2D, createProximityTrigger3D, createVolumeTrigger3D, createTriggerTracker, getTriggerTrackerSnapshot, stepRectTriggers2D, stepVolumeTriggers3D, stepTriggerTracker, resolveTriggerInteraction, createInteractionPromptState, updateInteractionPromptState, createWaveDirector, activeWave, stepWaveDirector, listEnemyArchetypeIds2D, getEnemyArchetype2D, pickEnemyArchetypeForWave2D, spawnEnemy2D, createAutoplayController2D, setAutoplayEnabled2D, toggleAutoplayEnabled2D, resolveAutoplayControl2D, createRenderTargetExportState2D, queueRenderTargetExport2D, flushRenderTargetExport2D, createInventory2D, addInventoryItem2D, removeInventoryItem2D, hasInventoryItem2D, listInventoryItems2D, selectInventoryCategory2D, selectInventoryItem2D, getSelectedInventoryItem2D, setInventoryItemEquipped2D, getInventoryView2D, createDialogueState2D, registerDialogueConversation2D, startDialogueConversation2D, advanceDialogueConversation2D, chooseDialogueChoice2D, completeDialogueConversation2D, getDialogueView2D, createJournal2D, upsertJournalEntry2D, setJournalEntryStatus2D, listJournalEntries2D, selectJournalCategory2D, selectJournalEntry2D, getSelectedJournalEntry2D, getJournalView2D, createTilemapWorld2D, ensureTilemapWorldLoaded2D, unloadTilemapWorld2D, drawTilemapWorld2D, listTilemapWorldObjects2D, findTilemapWorldObject2D, resolveTilemapSpawn2D, queryTilemapWorldPoint2D, queryTilemapWorldAABB2D, isTilemapPointBlocked2D, moveActorThroughTilemapWorld2D, createStreamedWorld2D, listLoadedStreamedWorldRegions2D, findStreamedWorldRegionAtPoint2D, syncStreamedWorldFocus2D, queryStreamedWorldPoint2D, queryStreamedWorldAABB2D, queryStreamedWorldRay2D, unloadStreamedWorld2D, captureStreamedWorldSnapshot2D, applyStreamedWorldSnapshot2D, saveStreamedWorldSnapshot2D, loadStreamedWorldSnapshot2D, deleteStreamedWorldSnapshot2D, createTilemapNav2D, rebuildTilemapNav2D, invalidateTilemapNav2D, collectTilemapOccupiedCells2D, setTilemapNavOccupiedCells2D, findTilemapPath2D, resolveTilemapStep2D, createWorldCompositor2D, ensureWorldCompositorTargets2D, destroyWorldCompositor2D, runWorldCompositor2D, createAdventureInteractable2D, createAdventureInteractablesFromTilemapObjects2D, createAdventureInteractionState2D, stepAdventureInteractables2D, createCheckpointSystem, updateCheckpointProgress, activeCheckpoint, respawnAtCheckpoint, createGoalZone, isGoalReached, createMovingPlatform3D, stepMovingPlatform3D, createCharacterAvatar3D, setAvatarInput3D, setAvatarVisual3D, spawnCharacterAvatar3D, tickCharacterAvatar3D, getAvatarState3D, getAvatarRenderTransform3D, createAdventureObjectives, resetAdventureObjectives, countCompletedObjectives, objectivesComplete, firstPendingObjective, collectAdventureObjectives2D, collectAdventureObjectives3D };