@auraindustry/aurajs 0.0.7 → 0.1.1

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

@@ -0,0 +1,54 @@
+const playerPrefab = {
+  id: 'player',
+  kind: 'prefab',
+  role: 'player',
+  view: {
+    kind: 'actor2d',
+    collider: { shape: 'rect', size: { x: 28, y: 28 } },
+  },
+  hooks: {},
+  notes: ['Keep the player spawn and avatar semantics here even while the template stays JS-first.'],
+};
+
+export function createPlayerPrefab() {
+  return playerPrefab;
+}
+
+export function createPlayerState(spawn = { x: 0, y: 0 }) {
+  return {
+    x: Number(spawn.x) || 0,
+    y: Number(spawn.y) || 0,
+    facingX: 1,
+    facingY: 0,
+  };
+}
+
+export function resetPlayerPosition(player, spawn) {
+  player.x = Number(spawn?.x) || 0;
+  player.y = Number(spawn?.y) || 0;
+  player.facingX = 1;
+  player.facingY = 0;
+}
+
+export function drawAdventurePlayer(player, config, { runComplete = false } = {}) {
+  const half = config.playerSize * 0.5;
+  const bodyColor = runComplete
+    ? aura.rgb(0.9, 0.98, 0.6)
+    : aura.rgb(0.34, 0.84, 1.0);
+  aura.draw2d.rect(
+    player.x - half,
+    player.y - half,
+    config.playerSize,
+    config.playerSize,
+    bodyColor,
+  );
+  aura.draw2d.rect(
+    player.x - 4 + (player.facingX * 2),
+    player.y - 4 + (player.facingY * 2),
+    8,
+    8,
+    aura.rgb(0.98, 0.98, 1.0),
+  );
+}
+
+export default playerPrefab;

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

@@ -0,0 +1,38 @@
+const relicPrefab = {
+  id: 'relic',
+  kind: 'prefab',
+  role: 'pickup',
+  view: {
+    kind: 'pickup2d',
+  },
+  hooks: {},
+  notes: ['Treat relics as authored pickups first, then grow them into richer quest nouns later.'],
+};
+
+export function createRelicPrefab() {
+  return relicPrefab;
+}
+
+export function drawAdventureRelics(relics, elapsed = 0) {
+  for (const relic of relics) {
+    if (relic.collected) continue;
+    const pulse = 0.88 + (Math.sin((elapsed * 3.4) + relic.x) * 0.12);
+    const size = relic.radius * pulse;
+    aura.draw2d.rect(
+      relic.x - size,
+      relic.y - size,
+      size * 2,
+      size * 2,
+      aura.rgb(0.98, 0.9, 0.42),
+    );
+    aura.draw2d.rect(
+      relic.x - (size * 0.42),
+      relic.y - (size * 0.42),
+      size * 0.84,
+      size * 0.84,
+      aura.rgb(0.18, 0.12, 0.04),
+    );
+  }
+}
+
+export default relicPrefab;

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

@@ -0,0 +1,125 @@
+import { BEACON_SITES, EXIT_GATE, WORLD_BOUNDS, WORLD_OBSTACLES } from '../content/gameplay/world.js';
+
+const worldPrefab = {
+  id: 'world',
+  kind: 'prefab',
+  role: 'world',
+  view: {
+    kind: 'environment2d',
+  },
+  hooks: {},
+  notes: ['Keep authored room layout in content/ and world rendering or collision affordances here.'],
+};
+
+function centeredRect(x, y, size) {
+  return {
+    x: x - (size * 0.5),
+    y: y - (size * 0.5),
+    w: size,
+    h: size,
+  };
+}
+
+function rectsOverlap(left, right) {
+  return left.x < right.x + right.w
+    && left.x + left.w > right.x
+    && left.y < right.y + right.h
+    && left.y + left.h > right.y;
+}
+
+function clampActorRect(rect) {
+  rect.x = Math.max(WORLD_BOUNDS.x, Math.min(WORLD_BOUNDS.x + WORLD_BOUNDS.width - rect.w, rect.x));
+  rect.y = Math.max(WORLD_BOUNDS.y, Math.min(WORLD_BOUNDS.y + WORLD_BOUNDS.height - rect.h, rect.y));
+  return rect;
+}
+
+function collidesWithObstacle(rect) {
+  return WORLD_OBSTACLES.some((obstacle) => rectsOverlap(rect, obstacle));
+}
+
+function applyActorRect(actor, rect, size) {
+  actor.x = rect.x + (size * 0.5);
+  actor.y = rect.y + (size * 0.5);
+}
+
+export function createWorldPrefab() {
+  return {
+    ...worldPrefab,
+    obstacleCount: WORLD_OBSTACLES.length,
+  };
+}
+
+export function moveActorThroughAdventureWorld(actor, deltaX, deltaY, size) {
+  const baseRect = centeredRect(actor.x, actor.y, size);
+
+  if (deltaX !== 0) {
+    const candidate = clampActorRect({
+      x: baseRect.x + deltaX,
+      y: baseRect.y,
+      w: baseRect.w,
+      h: baseRect.h,
+    });
+    if (!collidesWithObstacle(candidate)) {
+      baseRect.x = candidate.x;
+    }
+  }
+
+  if (deltaY !== 0) {
+    const candidate = clampActorRect({
+      x: baseRect.x,
+      y: baseRect.y + deltaY,
+      w: baseRect.w,
+      h: baseRect.h,
+    });
+    if (!collidesWithObstacle(candidate)) {
+      baseRect.y = candidate.y;
+    }
+  }
+
+  applyActorRect(actor, baseRect, size);
+}
+
+export function drawAdventureWorld({ beacons = [], gateReady = false, elapsed = 0 }) {
+  aura.draw2d.rect(
+    WORLD_BOUNDS.x - 24,
+    WORLD_BOUNDS.y - 24,
+    WORLD_BOUNDS.width + 48,
+    WORLD_BOUNDS.height + 48,
+    aura.rgb(0.06, 0.08, 0.11),
+  );
+  aura.draw2d.rect(
+    WORLD_BOUNDS.x,
+    WORLD_BOUNDS.y,
+    WORLD_BOUNDS.width,
+    WORLD_BOUNDS.height,
+    aura.rgb(0.12, 0.16, 0.12),
+  );
+
+  for (const obstacle of WORLD_OBSTACLES) {
+    aura.draw2d.rect(obstacle.x, obstacle.y, obstacle.w, obstacle.h, aura.rgb(0.22, 0.26, 0.24));
+  }
+
+  const beaconById = new Map(beacons.map((beacon) => [beacon.id, beacon]));
+  for (const site of BEACON_SITES) {
+    const lit = beaconById.get(site.id)?.lit === true;
+    const pulse = lit ? 1.0 : 0.9 + (Math.sin((elapsed * 2.2) + site.x) * 0.1);
+    const size = site.size * pulse;
+    aura.draw2d.rect(
+      site.x - (size * 0.5),
+      site.y - (size * 0.5),
+      size,
+      size,
+      lit ? aura.rgb(0.58, 1.0, 0.74) : aura.rgb(0.44, 0.58, 0.74),
+    );
+  }
+
+  aura.draw2d.rect(
+    EXIT_GATE.x,
+    EXIT_GATE.y,
+    EXIT_GATE.w,
+    EXIT_GATE.h,
+    gateReady ? aura.rgb(0.62, 1.0, 0.76) : aura.rgb(0.2, 0.24, 0.28),
+  );
+}
+
+export default worldPrefab;

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

@@ -0,0 +1,256 @@
+import {
+  axisFromKeys,
+  centeredRect,
+  collectAdventureObjectives2D,
+  countCompletedObjectives,
+  createAdventureObjectives,
+  createInteractionPromptState,
+  createRectTrigger2D,
+  createTriggerTracker,
+  objectivesComplete,
+  resetAdventureObjectives,
+  stepRectTriggers2D,
+  updateInteractionPromptState,
+} 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';
+
+const INTERACT_KEYS = ['e', 'enter'];
+
+function createAdventureSessionSeed() {
+  return {
+    runsStarted: 0,
+    bestRelicCount: 0,
+    bestBeaconCount: 0,
+    bestTimeSeconds: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+  };
+}
+
+function createAdventureUiStateSeed() {
+  return {
+    showControlsHint: true,
+  };
+}
+
+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 pressedInteract() {
+  return INTERACT_KEYS.some((key) => aura.input.isKeyPressed(key));
+}
+
+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 sceneState = {
+    player: createPlayerState(PLAYER_SPAWN),
+    relics: createAdventureObjectives(RELIC_SPAWNS, {
+      dimension: '2d',
+      defaultRadius: ADVENTURE_CONFIG.relicRadius,
+    }),
+    beacons: createBeaconState(),
+    elapsed: 0,
+    runComplete: false,
+  };
+
+  function relicCount() {
+    return countCompletedObjectives(sceneState.relics);
+  }
+
+  function beaconCount() {
+    return sceneState.beacons.reduce((total, beacon) => total + (beacon.lit === true ? 1 : 0), 0);
+  }
+
+  function gateReady() {
+    return objectivesComplete(sceneState.relics) && beaconCount() >= sceneState.beacons.length;
+  }
+
+  function syncSessionState() {
+    adventureSession.lastSceneId = 'gameplay';
+    adventureSession.bestRelicCount = Math.max(Number(adventureSession.bestRelicCount || 0), relicCount());
+    adventureSession.bestBeaconCount = Math.max(Number(adventureSession.bestBeaconCount || 0), beaconCount());
+    adventureSession.bestTimeSeconds = Math.max(Number(adventureSession.bestTimeSeconds || 0), sceneState.elapsed);
+    adventureSession.lastElapsedSeconds = Number(sceneState.elapsed.toFixed(2));
+    adventureSession.lastOutcome = sceneState.runComplete ? 'route-cleared' : 'surveying';
+  }
+
+  function syncHud() {
+    context.setHudScreen?.('hud', {
+      relicCount: relicCount(),
+      relicTarget: sceneState.relics.length,
+      beaconCount: beaconCount(),
+      beaconTarget: sceneState.beacons.length,
+      promptText: promptState.prompt || '',
+      runComplete: sceneState.runComplete,
+      showControlsHint: adventureUiState.showControlsHint !== false,
+      fps: Number(aura.window.getFPS?.() || 0).toFixed(0),
+    });
+  }
+
+  function resetRun() {
+    resetPlayerPosition(sceneState.player, PLAYER_SPAWN);
+    resetAdventureObjectives(sceneState.relics);
+    sceneState.beacons = createBeaconState();
+    sceneState.elapsed = 0;
+    sceneState.runComplete = false;
+    promptState.visible = false;
+    promptState.ready = false;
+    promptState.prompt = null;
+    promptState.triggerId = null;
+    promptState.accepted = false;
+    promptState.acceptedTriggerId = null;
+    adventureSession.runsStarted += 1;
+    syncSessionState();
+    syncHud();
+  }
+
+  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',
+        },
+      ));
+    }
+
+    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;
+  }
+
+  function handleAcceptedPrompt() {
+    const acceptedTriggerId = promptState.acceptedTriggerId;
+    if (!acceptedTriggerId) return;
+
+    if (acceptedTriggerId.startsWith('beacon:')) {
+      const beaconId = acceptedTriggerId.slice('beacon:'.length);
+      const beacon = sceneState.beacons.find((entry) => entry.id === beaconId) || null;
+      if (beacon && relicCount() >= beacon.requiredRelics) {
+        beacon.lit = true;
+      }
+    } else if (acceptedTriggerId === 'exit-gate' && gateReady()) {
+      sceneState.runComplete = true;
+    }
+  }
+
+  return {
+    setup() {
+      resetRun();
+      console.log(ADVENTURE_TEXT.started);
+    },
+
+    update(dt) {
+      sceneState.elapsed += dt;
+
+      if (sceneState.runComplete) {
+        if (aura.input.isKeyPressed('enter')) {
+          resetRun();
+        }
+        syncHud();
+        return;
+      }
+
+      if (aura.input.isKeyPressed('h')) {
+        adventureUiState.showControlsHint = adventureUiState.showControlsHint !== true;
+      }
+
+      const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
+      const moveY = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
+      if (moveX !== 0 || moveY !== 0 || pressedInteract()) {
+        adventureUiState.showControlsHint = false;
+      }
+      if (moveX !== 0 || moveY !== 0) {
+        sceneState.player.facingX = moveX !== 0 ? Math.sign(moveX) : sceneState.player.facingX;
+        sceneState.player.facingY = moveY !== 0 ? Math.sign(moveY) : sceneState.player.facingY;
+      }
+
+      moveActorThroughAdventureWorld(
+        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();
+      syncSessionState();
+      syncHud();
+    },
+
+    onExit() {
+      context.clearHudScreen?.();
+    },
+
+    draw() {
+      aura.draw2d.clear(aura.rgba(0.03, 0.04, 0.06, 1.0));
+      drawAdventureWorld({
+        beacons: sceneState.beacons,
+        gateReady: gateReady(),
+        elapsed: sceneState.elapsed,
+      });
+      drawAdventureRelics(sceneState.relics, sceneState.elapsed);
+      drawAdventurePlayer(sceneState.player, ADVENTURE_CONFIG, {
+        runComplete: sceneState.runComplete,
+      });
+    },
+  };
+}

package/templates/create/2d-adventure/src/runtime/capabilities.js

@@ -0,0 +1,34 @@
+function hasMethod(obj, method) {
+  return Boolean(obj) && typeof obj[method] === 'function';
+}
+
+function failWithReason(reasonCode, message) {
+  throw new Error(`[2d-adventure-template] ${message} [reason:${reasonCode}]`);
+}
+
+export function assertRuntimeCapabilities() {
+  const missing = [];
+  if (!hasMethod(aura.window, 'getFPS')) missing.push('aura.window.getFPS');
+  if (!hasMethod(aura.input, 'isKeyDown')) missing.push('aura.input.isKeyDown');
+  if (!hasMethod(aura.input, 'isKeyPressed')) missing.push('aura.input.isKeyPressed');
+  if (!hasMethod(aura.draw2d, 'clear')) missing.push('aura.draw2d.clear');
+  if (!hasMethod(aura.draw2d, 'rect')) missing.push('aura.draw2d.rect');
+  if (!hasMethod(aura.draw2d, 'text')) missing.push('aura.draw2d.text');
+  if (!hasMethod(aura.draw2d, 'measureText')) missing.push('aura.draw2d.measureText');
+  if (typeof aura.rgb !== 'function') missing.push('aura.rgb');
+  if (typeof aura.rgba !== 'function') missing.push('aura.rgba');
+  if (!aura.Color || !aura.Color.WHITE) missing.push('aura.Color.WHITE');
+
+  if (missing.length > 0) {
+    failWithReason('missing_runtime_api', `runtime missing required APIs: ${missing.join(', ')}`);
+  }
+
+  const small = aura.draw2d.measureText('Probe', { size: 8 });
+  const large = aura.draw2d.measureText('Probe', { size: 24 });
+  if (!Number.isFinite(Number(small?.width)) || !Number.isFinite(Number(large?.width)) || Number(large.width) <= Number(small.width)) {
+    failWithReason(
+      'placeholder_runtime_behavior',
+      'draw2d.measureText appears to be placeholder behavior (size does not affect width).',
+    );
+  }
+}

package/templates/create/2d-adventure/ui/hud.screen.js

@@ -0,0 +1,60 @@
+const hudScreen = {
+  id: 'hud',
+  kind: 'ui-screen',
+  role: 'hud',
+  draw: drawAdventureHud,
+  notes: ['This HUD is mounted through screenShell so the scene only owns gameplay state and prompt selection.'],
+};
+
+export function createHudScreen() {
+  return hudScreen;
+}
+
+export function drawAdventureHud(data = {}) {
+  let nextY = 12;
+  if (data.showControlsHint !== false) {
+    aura.draw2d.text('Move: Arrows/WASD  Interact: E or Enter', 12, nextY, {
+      color: aura.Color.WHITE,
+      size: 14,
+      align: 'left',
+    });
+    nextY += 22;
+  }
+
+  aura.draw2d.text(`Relics ${data.relicCount ?? 0}/${data.relicTarget ?? 0}`, 12, nextY, {
+    color: aura.Color.WHITE,
+    size: 14,
+    align: 'left',
+  });
+  nextY += 22;
+  aura.draw2d.text(`Beacons ${data.beaconCount ?? 0}/${data.beaconTarget ?? 0}  FPS ${data.fps ?? '0'}`, 12, nextY, {
+    color: aura.Color.WHITE,
+    size: 14,
+    align: 'left',
+  });
+  nextY += 22;
+
+  if (data.promptText) {
+    aura.draw2d.text(data.promptText, 12, nextY, {
+      color: aura.rgb(0.96, 0.86, 0.42),
+      size: 13,
+      align: 'left',
+    });
+    nextY += 24;
+  }
+
+  if (data.runComplete !== true) return;
+
+  aura.draw2d.text('RUINS SURVEY COMPLETE', 12, nextY, {
+    color: aura.rgb(0.58, 1.0, 0.74),
+    size: 24,
+    align: 'left',
+  });
+  aura.draw2d.text('Press Enter to restart the route', 12, nextY + 28, {
+    color: aura.Color.WHITE,
+    size: 16,
+    align: 'left',
+  });
+}
+
+export default hudScreen;

package/templates/create/2d-survivor/config/gameplay/survivor.config.js

@@ -0,0 +1,33 @@
+export const SURVIVOR_CONFIG = Object.freeze({
+  playerSize: 28,
+  moveSpeed: 320,
+  dashSpeed: 560,
+  dashDurationSeconds: 0.16,
+  dashCooldownSeconds: 1.2,
+  bulletSize: 6,
+  bulletSpeed: 560,
+  bulletLifetimeSeconds: 1.1,
+  autoFireCooldownSeconds: 0.16,
+  playerTouchRadius: 24,
+  enemyHitInvulnerabilitySeconds: 0.65,
+  startingHealth: 5,
+  spawnPadding: 28,
+  betweenWaveDelaySeconds: 0.8,
+});
+
+export const SURVIVOR_WAVES = Object.freeze([
+  Object.freeze({ maxSpawns: 16, spawnEvery: 0.52, archetype: 'scout', hpScale: 1.0, speedScale: 1.0 }),
+  Object.freeze({ maxSpawns: 14, spawnEvery: 0.48, archetype: 'striker', hpScale: 1.3, speedScale: 1.05 }),
+  Object.freeze({ maxSpawns: 12, spawnEvery: 0.44, archetype: 'tank', hpScale: 1.9, speedScale: 1.02 }),
+  Object.freeze({ maxSpawns: 22, spawnEvery: 0.36, archetype: null, hpScale: 1.4, speedScale: 1.12 }),
+]);
+
+export const SURVIVOR_TEXT = Object.freeze({
+  started: '{{PROJECT_TITLE}} started (2D survivor template)',
+  controls: 'Move: Arrows/WASD  Dash: Shift',
+  hudLinePrefix: 'Auto-fire online',
+  elapsedPrefix: 'Time',
+  gameOverTitle: 'RUN FAILED',
+  gameOverPrompt: 'Press Enter to restart',
+  waveDone: 'done',
+});

package/templates/create/2d-survivor/content/gameplay/spawn-zones.json

@@ -0,0 +1,29 @@
+{
+  "schema": "aurajs.spawn-zones.v1",
+  "zones": [
+    {
+      "id": "north-lane",
+      "x": 0.5,
+      "y": 0.08,
+      "weight": 1
+    },
+    {
+      "id": "east-lane",
+      "x": 0.92,
+      "y": 0.52,
+      "weight": 1.2
+    },
+    {
+      "id": "south-lane",
+      "x": 0.5,
+      "y": 0.94,
+      "weight": 1
+    },
+    {
+      "id": "west-lane",
+      "x": 0.08,
+      "y": 0.52,
+      "weight": 1.1
+    }
+  ]
+}

package/templates/create/2d-survivor/content/registries/.gitkeep

@@ -0,0 +1 @@
+

package/templates/create/2d-survivor/docs/design/.gitkeep

@@ -0,0 +1 @@
+

package/templates/create/2d-survivor/docs/design/loop.md

@@ -0,0 +1,5 @@
+# 2D Survivor Loop
+
+1. Kite the swarm, auto-fire, and survive long enough to outscale the pressure.
+1. Keep tuning in `config/gameplay/survivor.config.js`, authored spawn lanes in `content/gameplay/spawn-zones.json`, and reusable combat pieces in `prefabs/`.
+1. Extend from here with enemy families, drops, and pacing rules before layering on larger progression systems.