@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/headless-test/runtime-coordinator.mjs

@@ -14,7 +14,8 @@ import { createHeadlessAnimationRuntime } from './runtime-animation.mjs';
 import { createHeadlessPrimitiveRuntime } from './runtime-primitives.mjs';
 import { createHeadlessWorldRuntime } from './runtime-world.mjs';
 
-export function createRuntimeContext(aura, testState) {
+export function createRuntimeContext(aura, testState, options = {}) {
+  const mathRef = options && typeof options === 'object' && options.math ? options.math : Math;
   const consoleShim = {
     log: (...args) => {
       testState.logs.push(['log', ...args]);
@@ -33,7 +34,7 @@ export function createRuntimeContext(aura, testState) {
   return {
     aura,
     console: consoleShim,
-    Math,
+    Math: mathRef,
     Date,
     setTimeout,
     clearTimeout,
@@ -49,6 +50,22 @@ const draw2dRenderTargets = new Map();
 const draw2dClipStack = [];
 let activeDraw2dRenderTarget = null;
 let activeDraw2dMaskCapture = null;
+const inputNormalize = (value) => String(value || '').trim().toLowerCase();
+const keyboardDown = new Set();
+const keyboardPressed = new Set();
+const keyboardReleased = new Set();
+const mouseButtonsDown = new Set();
+const mouseButtonsPressed = new Set();
+const mouseButtonsReleased = new Set();
+const gamepadButtonsDown = new Set();
+const gamepadButtonsPressed = new Set();
+const gamepadButtonsReleased = new Set();
+const gamepadAxes = Object.create(null);
+let mouseX = 0;
+let mouseY = 0;
+let mouseDeltaX = 0;
+let mouseDeltaY = 0;
+let mouseScroll = 0;
 
 const drawNoop = () => {
   testState.drawCalls += 1;
@@ -60,6 +77,119 @@ const drawNoop = () => {
   }
 };
 const stateNoop = () => {};
+const clearInputFrameTransitions = () => {
+  keyboardPressed.clear();
+  keyboardReleased.clear();
+  mouseButtonsPressed.clear();
+  mouseButtonsReleased.clear();
+  gamepadButtonsPressed.clear();
+  gamepadButtonsReleased.clear();
+  mouseDeltaX = 0;
+  mouseDeltaY = 0;
+  mouseScroll = 0;
+};
+const applyDownTransitions = (targetDown, targetPressed, values) => {
+  for (const value of Array.isArray(values) ? values : []) {
+    const normalized = inputNormalize(value);
+    if (!normalized) continue;
+    if (!targetDown.has(normalized)) {
+      targetPressed.add(normalized);
+    }
+    targetDown.add(normalized);
+  }
+};
+const applyUpTransitions = (targetDown, targetReleased, values) => {
+  for (const value of Array.isArray(values) ? values : []) {
+    const normalized = inputNormalize(value);
+    if (!normalized) continue;
+    if (targetDown.delete(normalized)) {
+      targetReleased.add(normalized);
+    }
+  }
+};
+const applyHeadlessInputFrame = (frame = {}) => {
+  clearInputFrameTransitions();
+  const input = frame && typeof frame === 'object' && !Array.isArray(frame) ? frame : {};
+  if (input.reset === true) {
+    keyboardDown.clear();
+    mouseButtonsDown.clear();
+    gamepadButtonsDown.clear();
+    for (const key of Object.keys(gamepadAxes)) {
+      delete gamepadAxes[key];
+    }
+  }
+
+  applyDownTransitions(keyboardDown, keyboardPressed, input.keysDown);
+  applyUpTransitions(keyboardDown, keyboardReleased, input.keysUp);
+
+  const mouse = input.mouse && typeof input.mouse === 'object' && !Array.isArray(input.mouse)
+    ? input.mouse
+    : null;
+  if (mouse) {
+    if (Number.isFinite(Number(mouse.x))) {
+      const nextX = Number(mouse.x);
+      mouseDeltaX = nextX - mouseX;
+      mouseX = nextX;
+    }
+    if (Number.isFinite(Number(mouse.y))) {
+      const nextY = Number(mouse.y);
+      mouseDeltaY = nextY - mouseY;
+      mouseY = nextY;
+    }
+    if (Number.isFinite(Number(mouse.scrollDelta))) {
+      mouseScroll = Number(mouse.scrollDelta);
+    } else if (Number.isFinite(Number(mouse.scroll))) {
+      mouseScroll = Number(mouse.scroll);
+    }
+    applyDownTransitions(mouseButtonsDown, mouseButtonsPressed, mouse.buttonsDown);
+    applyUpTransitions(mouseButtonsDown, mouseButtonsReleased, mouse.buttonsUp);
+  }
+
+  const gamepad = input.gamepad && typeof input.gamepad === 'object' && !Array.isArray(input.gamepad)
+    ? input.gamepad
+    : null;
+  if (gamepad) {
+    if (typeof gamepad.connected === 'boolean' && gamepad.connected !== true) {
+      gamepadButtonsDown.clear();
+      for (const key of Object.keys(gamepadAxes)) {
+        delete gamepadAxes[key];
+      }
+    }
+    if (gamepad.axes && typeof gamepad.axes === 'object' && !Array.isArray(gamepad.axes)) {
+      for (const [axis, value] of Object.entries(gamepad.axes)) {
+        const normalizedAxis = inputNormalize(axis);
+        if (!normalizedAxis) continue;
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric)) continue;
+        gamepadAxes[normalizedAxis] = numeric;
+      }
+    }
+    applyDownTransitions(gamepadButtonsDown, gamepadButtonsPressed, gamepad.buttonsDown);
+    applyUpTransitions(gamepadButtonsDown, gamepadButtonsReleased, gamepad.buttonsUp);
+  }
+};
+const snapshotHeadlessInput = () => ({
+  keysDown: [...keyboardDown].sort(),
+  keysPressed: [...keyboardPressed].sort(),
+  keysReleased: [...keyboardReleased].sort(),
+  mouse: {
+    x: mouseX,
+    y: mouseY,
+    deltaX: mouseDeltaX,
+    deltaY: mouseDeltaY,
+    scroll: mouseScroll,
+    buttonsDown: [...mouseButtonsDown].sort(),
+    buttonsPressed: [...mouseButtonsPressed].sort(),
+    buttonsReleased: [...mouseButtonsReleased].sort(),
+  },
+  gamepad: {
+    connected: gamepadButtonsDown.size > 0 || Object.keys(gamepadAxes).length > 0,
+    axes: { ...gamepadAxes },
+    buttonsDown: [...gamepadButtonsDown].sort(),
+    buttonsPressed: [...gamepadButtonsPressed].sort(),
+    buttonsReleased: [...gamepadButtonsReleased].sort(),
+  },
+});
 
   const {
     resolveHeadlessAssetPath,
@@ -1088,8 +1218,10 @@ const aura = {
   draw2d: {
     clear: drawNoop,
     rect: drawNoop,
+    rectFill: drawNoop,
     rectOutline: drawNoop,
     circle: drawNoop,
+    circleFill: drawNoop,
     circleOutline: drawNoop,
     line: drawNoop,
     triangle: drawNoop,
@@ -1293,9 +1425,9 @@ const aura = {
   },
 
   input: {
-    isDown: () => false,
-    isPressed: () => false,
-    isReleased: () => false,
+    isDown: (key) => keyboardDown.has(inputNormalize(key)),
+    isPressed: (key) => keyboardPressed.has(inputNormalize(key)),
+    isReleased: (key) => keyboardReleased.has(inputNormalize(key)),
     isKeyDown: (...args) => aura.input.isDown(...args),
     isKeyPressed: (...args) => aura.input.isPressed(...args),
     isKeyReleased: (...args) => aura.input.isReleased(...args),
@@ -1303,24 +1435,42 @@ const aura = {
     isMousePressed: (...args) => aura.input.mouse.isPressed(...args),
     isMouseReleased: (...args) => aura.input.mouse.isReleased(...args),
     getMousePosition: () => ({ x: aura.input.mouse.x, y: aura.input.mouse.y }),
-    getMouseDelta: () => ({ x: 0, y: 0 }),
+    getMouseDelta: () => ({ x: mouseDeltaX, y: mouseDeltaY }),
     isGamepadConnected: () => Boolean(aura.input.gamepad.connected),
     mouse: {
-      x: 0,
-      y: 0,
-      scroll: 0,
-      isDown: () => false,
-      isPressed: () => false,
-      isReleased: () => false,
+      get x() {
+        return mouseX;
+      },
+      get y() {
+        return mouseY;
+      },
+      get scroll() {
+        return mouseScroll;
+      },
+      isDown: (button) => mouseButtonsDown.has(inputNormalize(button)),
+      isPressed: (button) => mouseButtonsPressed.has(inputNormalize(button)),
+      isReleased: (button) => mouseButtonsReleased.has(inputNormalize(button)),
     },
     gamepad: {
-      connected: false,
-      axis: () => 0,
-      isDown: () => false,
-      isPressed: () => false,
-      isReleased: () => false,
+      get connected() {
+        return gamepadButtonsDown.size > 0 || Object.keys(gamepadAxes).length > 0;
+      },
+      axis: (axis) => {
+        const normalized = inputNormalize(axis);
+        return normalized && Object.prototype.hasOwnProperty.call(gamepadAxes, normalized)
+          ? gamepadAxes[normalized]
+          : 0;
+      },
+      isDown: (button) => gamepadButtonsDown.has(inputNormalize(button)),
+      isPressed: (button) => gamepadButtonsPressed.has(inputNormalize(button)),
+      isReleased: (button) => gamepadButtonsReleased.has(inputNormalize(button)),
       rumble: () => {},
     },
+    __headless: {
+      applyFrame: applyHeadlessInputFrame,
+      clearFrameTransitions: clearInputFrameTransitions,
+      snapshot: snapshotHeadlessInput,
+    },
   },
 
   storage: {
@@ -1492,23 +1642,26 @@ export async function executeSetup(aura) {
   }
 }
 
+export async function executeFrame(aura, dt = 1 / 60) {
+  if (aura.debug && typeof aura.debug.__inspectorTick === 'function') {
+    aura.debug.__inspectorTick(dt);
+  }
+  if (aura.anim2d && typeof aura.anim2d.update === 'function') {
+    await Promise.resolve(aura.anim2d.update(dt));
+  }
+  if (aura.ecs && typeof aura.ecs.run === 'function') {
+    await Promise.resolve(aura.ecs.run(dt));
+  }
+  if (typeof aura.update === 'function') {
+    await Promise.resolve(aura.update(dt));
+  }
+  if (typeof aura.draw === 'function') {
+    await Promise.resolve(aura.draw());
+  }
+}
+
 export async function executeFrameSteps(aura, frames) {
   for (let i = 0; i < frames; i += 1) {
-    const dt = 1 / 60;
-    if (aura.debug && typeof aura.debug.__inspectorTick === 'function') {
-      aura.debug.__inspectorTick(dt);
-    }
-    if (aura.anim2d && typeof aura.anim2d.update === 'function') {
-      await Promise.resolve(aura.anim2d.update(dt));
-    }
-    if (aura.ecs && typeof aura.ecs.run === 'function') {
-      await Promise.resolve(aura.ecs.run(dt));
-    }
-    if (typeof aura.update === 'function') {
-      await Promise.resolve(aura.update(dt));
-    }
-    if (typeof aura.draw === 'function') {
-      await Promise.resolve(aura.draw());
-    }
+    await executeFrame(aura, 1 / 60);
   }
 }

package/src/headless-test.mjs

@@ -11,6 +11,7 @@ import {
 import {
   createHeadlessAura,
   createRuntimeContext,
+  executeFrame,
   executeFrameSteps,
   executeSetup,
 } from './headless-test/runtime-coordinator.mjs';
@@ -18,6 +19,7 @@ import {
 export {
   createHeadlessAura,
   createRuntimeContext,
+  executeFrame,
   executeFrameSteps,
   executeSetup,
 };

package/src/helpers/2d/index.mjs

@@ -0,0 +1,183 @@
+import {
+  clamp,
+  axisFromKeys,
+  createCooldown,
+  tickCooldown,
+  consumeCooldown,
+  createIntervalSpawner,
+  tickIntervalSpawner,
+  centeredRect,
+  rectsOverlap,
+  removeWhere,
+  distanceSquared2D,
+  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,
+  createAutoplayController2D,
+  setAutoplayEnabled2D,
+  toggleAutoplayEnabled2D,
+  resolveAutoplayControl2D,
+  createRenderTargetExportState2D,
+  queueRenderTargetExport2D,
+  flushRenderTargetExport2D,
+  createRectTrigger2D,
+  createTriggerTracker,
+  getTriggerTrackerSnapshot,
+  stepRectTriggers2D,
+  stepTriggerTracker,
+  resolveTriggerInteraction,
+  createInteractionPromptState,
+  updateInteractionPromptState,
+  createWaveDirector,
+  activeWave,
+  stepWaveDirector,
+  listEnemyArchetypeIds2D,
+  getEnemyArchetype2D,
+  pickEnemyArchetypeForWave2D,
+  spawnEnemy2D,
+  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,
+  createAdventureObjectives,
+  resetAdventureObjectives,
+  countCompletedObjectives,
+  objectivesComplete,
+  firstPendingObjective,
+  collectAdventureObjectives2D,
+} from '../index.mjs';
+
+export { clamp, axisFromKeys, createCooldown, tickCooldown, consumeCooldown, createIntervalSpawner, tickIntervalSpawner, centeredRect, rectsOverlap, removeWhere, distanceSquared2D, 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, createAutoplayController2D, setAutoplayEnabled2D, toggleAutoplayEnabled2D, resolveAutoplayControl2D, createRenderTargetExportState2D, queueRenderTargetExport2D, flushRenderTargetExport2D, createRectTrigger2D, createTriggerTracker, getTriggerTrackerSnapshot, stepRectTriggers2D, stepTriggerTracker, resolveTriggerInteraction, createInteractionPromptState, updateInteractionPromptState, createWaveDirector, activeWave, stepWaveDirector, listEnemyArchetypeIds2D, getEnemyArchetype2D, pickEnemyArchetypeForWave2D, spawnEnemy2D, 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, createAdventureObjectives, resetAdventureObjectives, countCompletedObjectives, objectivesComplete, firstPendingObjective, collectAdventureObjectives2D };

package/src/helpers/index.mjs

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

package/src/helpers/starter-utils/adventure-objectives.js

@@ -0,0 +1,102 @@
+import { distanceSquared2D, distanceSquared3D } from './core.js';
+
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function normalizeId(value, fallback) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function normalizeLabel(value, fallback) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function normalizeObjectiveEntry(entry, index, options = {}) {
+  const dimension = options.dimension === '3d' ? '3d' : '2d';
+  const fallbackId = `objective-${index + 1}`;
+  const fallbackLabel = `Objective ${index + 1}`;
+  return {
+    id: normalizeId(entry?.id, fallbackId),
+    label: normalizeLabel(entry?.label ?? entry?.name, fallbackLabel),
+    x: finite(entry?.x),
+    y: finite(entry?.y),
+    z: dimension === '3d' ? finite(entry?.z) : 0,
+    radius: Math.max(0.1, finite(entry?.radius, finite(options.defaultRadius, 1))),
+    value: Math.max(1, Math.round(finite(entry?.value, 1))),
+    collected: entry?.collected === true,
+  };
+}
+
+export function createAdventureObjectives(entries = [], options = {}) {
+  return (Array.isArray(entries) ? entries : []).map((entry, index) => normalizeObjectiveEntry(entry, index, options));
+}
+
+export function resetAdventureObjectives(objectives) {
+  for (const objective of Array.isArray(objectives) ? objectives : []) {
+    objective.collected = false;
+  }
+  return objectives;
+}
+
+export function countCompletedObjectives(objectives) {
+  return (Array.isArray(objectives) ? objectives : []).reduce(
+    (total, objective) => total + (objective?.collected === true ? 1 : 0),
+    0,
+  );
+}
+
+export function objectivesComplete(objectives, requiredCount = null) {
+  const totalObjectives = Array.isArray(objectives) ? objectives.length : 0;
+  const threshold = Number.isFinite(Number(requiredCount))
+    ? Math.max(0, Math.min(totalObjectives, Number(requiredCount)))
+    : totalObjectives;
+  return countCompletedObjectives(objectives) >= threshold;
+}
+
+export function firstPendingObjective(objectives) {
+  return (Array.isArray(objectives) ? objectives : []).find((objective) => objective?.collected !== true) || null;
+}
+
+function collectAdventureObjectives(subject, objectives, pickupRadius, measureDistanceSquared) {
+  const collected = [];
+  const extraRadius = Math.max(0, finite(pickupRadius, 0));
+  let scoreDelta = 0;
+
+  for (const objective of Array.isArray(objectives) ? objectives : []) {
+    if (!objective || objective.collected === true) continue;
+    const threshold = objective.radius + extraRadius;
+    if (measureDistanceSquared(subject, objective) > (threshold * threshold)) continue;
+    objective.collected = true;
+    scoreDelta += objective.value;
+    collected.push({
+      id: objective.id,
+      label: objective.label,
+      value: objective.value,
+    });
+  }
+
+  return {
+    changed: collected.length > 0,
+    collected,
+    collectedCount: collected.length,
+    scoreDelta,
+    completedObjectives: countCompletedObjectives(objectives),
+    totalObjectives: Array.isArray(objectives) ? objectives.length : 0,
+  };
+}
+
+export function collectAdventureObjectives2D(subject, objectives, pickupRadius = 0) {
+  return collectAdventureObjectives(subject, objectives, pickupRadius, distanceSquared2D);
+}
+
+export function collectAdventureObjectives3D(subject, objectives, pickupRadius = 0) {
+  return collectAdventureObjectives(subject, objectives, pickupRadius, distanceSquared3D);
+}