@auraindustry/aurajs 0.0.6 → 0.1.0

package/templates/create/2d-survivor/prefabs/enemies.prefab.js

@@ -0,0 +1,178 @@
+import { pickEnemyArchetypeForWave2D, spawnEnemy2D } from '../src/starter-utils/index.js';
+
+const enemiesPrefab = {
+  id: 'enemies',
+  kind: 'prefab',
+  role: 'enemy',
+  view: {
+    kind: 'actor2d',
+  },
+  hooks: {},
+  notes: ['Starter enemy helpers still live beside the authored prefab descriptor in this template.'],
+};
+
+function distanceSquared2D(ax, ay, bx, by) {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return (dx * dx) + (dy * dy);
+}
+
+export function spawnEnemyOnEdge(width, height, waveState, config) {
+  const side = Math.floor(Math.random() * 4);
+  let x = width * 0.5;
+  let y = height * 0.5;
+
+  if (side === 0) {
+    x = Math.random() * width;
+    y = -config.spawnPadding;
+  } else if (side === 1) {
+    x = width + config.spawnPadding;
+    y = Math.random() * height;
+  } else if (side === 2) {
+    x = Math.random() * width;
+    y = height + config.spawnPadding;
+  } else {
+    x = -config.spawnPadding;
+    y = Math.random() * height;
+  }
+
+  const wave = waveState?.wave || null;
+  const archetypeId = wave?.archetype || pickEnemyArchetypeForWave2D(waveState?.waveIndex || 0).id;
+  const enemy = spawnEnemy2D({
+    x,
+    y,
+    waveIndex: waveState?.waveIndex || 0,
+    archetypeId,
+  });
+
+  const hpScale = Number.isFinite(Number(wave?.hpScale)) ? Number(wave.hpScale) : 1.0;
+  const speedScale = Number.isFinite(Number(wave?.speedScale)) ? Number(wave.speedScale) : 1.0;
+  enemy.hp = Math.max(1, Math.round((enemy.size / 14) * hpScale));
+  enemy.speed = Math.max(60, enemy.speed * speedScale);
+  return enemy;
+}
+
+export function nearestEnemyToPlayer(player, enemies) {
+  if (enemies.length === 0) return null;
+
+  let best = enemies[0];
+  let bestDistance = distanceSquared2D(player.x, player.y, best.x, best.y);
+
+  for (let index = 1; index < enemies.length; index += 1) {
+    const candidate = enemies[index];
+    const candidateDistance = distanceSquared2D(player.x, player.y, candidate.x, candidate.y);
+    if (candidateDistance < bestDistance) {
+      best = candidate;
+      bestDistance = candidateDistance;
+    }
+  }
+
+  return best;
+}
+
+export function updateEnemyMovement(player, enemies, dt) {
+  for (const enemy of enemies) {
+    const dx = player.x - enemy.x;
+    const dy = player.y - enemy.y;
+    const magnitude = Math.hypot(dx, dy) || 1;
+    enemy.x += (dx / magnitude) * enemy.speed * dt;
+    enemy.y += (dy / magnitude) * enemy.speed * dt;
+  }
+}
+
+export function resolveBulletHits(bullets, enemies, config) {
+  const nextBullets = bullets.slice();
+  const nextEnemies = enemies.slice();
+  const impactEvents = [];
+  let scoreDelta = 0;
+
+  for (let bulletIndex = nextBullets.length - 1; bulletIndex >= 0; bulletIndex -= 1) {
+    const bullet = nextBullets[bulletIndex];
+    let consumed = false;
+
+    for (let enemyIndex = nextEnemies.length - 1; enemyIndex >= 0; enemyIndex -= 1) {
+      const enemy = nextEnemies[enemyIndex];
+      const enemyRadius = enemy.size * 0.46;
+      const hitRadius = enemyRadius + (config.bulletSize * 0.5);
+      const hitDistanceSq = distanceSquared2D(bullet.x, bullet.y, enemy.x, enemy.y);
+      if (hitDistanceSq > (hitRadius * hitRadius)) continue;
+
+      enemy.hp -= 1;
+      impactEvents.push({
+        x: enemy.x,
+        y: enemy.y,
+        defeated: enemy.hp <= 0,
+        scoreValue: enemy.scoreValue,
+        color: enemy.color,
+      });
+      nextBullets.splice(bulletIndex, 1);
+      consumed = true;
+      if (enemy.hp <= 0) {
+        scoreDelta += enemy.scoreValue;
+        nextEnemies.splice(enemyIndex, 1);
+      }
+      break;
+    }
+
+    if (consumed) continue;
+  }
+
+  return {
+    bullets: nextBullets,
+    enemies: nextEnemies,
+    scoreDelta,
+    impactEvents,
+  };
+}
+
+export function resolvePlayerContacts(player, enemies, config, touchInvulnerabilityRemaining, health) {
+  if (touchInvulnerabilityRemaining > 0) {
+    return {
+      enemies,
+      health,
+      invulnerability: touchInvulnerabilityRemaining,
+      playerHit: false,
+      contactPoint: null,
+      gameOver: health <= 0,
+    };
+  }
+
+  const nextEnemies = enemies.slice();
+  let nextHealth = health;
+  let nextInvulnerability = 0;
+  let playerHit = false;
+  let contactPoint = null;
+
+  for (let index = nextEnemies.length - 1; index >= 0; index -= 1) {
+    const enemy = nextEnemies[index];
+    const enemyRadius = enemy.size * 0.44;
+    const touchRadius = enemyRadius + config.playerTouchRadius;
+    const distanceSq = distanceSquared2D(player.x, player.y, enemy.x, enemy.y);
+    if (distanceSq > (touchRadius * touchRadius)) continue;
+
+    nextEnemies.splice(index, 1);
+    nextHealth -= 1;
+    nextInvulnerability = config.enemyHitInvulnerabilitySeconds;
+    playerHit = true;
+    contactPoint = { x: enemy.x, y: enemy.y };
+    break;
+  }
+
+  return {
+    enemies: nextEnemies,
+    health: nextHealth,
+    invulnerability: nextInvulnerability,
+    playerHit,
+    contactPoint,
+    gameOver: nextHealth <= 0,
+  };
+}
+
+export function drawEnemies(enemies) {
+  for (const enemy of enemies) {
+    const half = enemy.size * 0.5;
+    aura.draw2d.rect(enemy.x - half, enemy.y - half, enemy.size, enemy.size, aura.rgb(enemy.color.r, enemy.color.g, enemy.color.b));
+  }
+}
+
+export default enemiesPrefab;

package/templates/create/2d-survivor/prefabs/enemy-swarm.prefab.js

@@ -0,0 +1,18 @@
+const enemySwarmPrefab = {
+  id: 'enemy-swarm',
+  kind: 'prefab',
+  role: 'enemy',
+  view: { kind: 'actor2d' },
+  components: {
+    archetype: 'swarm',
+    behaviorRole: 'surround',
+  },
+  hooks: {},
+  notes: ['Move survivor-specific spawn tuning here before adding more enemy classes.'],
+};
+
+export function createEnemySwarmPrefab() {
+  return enemySwarmPrefab;
+}
+
+export default enemySwarmPrefab;

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

@@ -0,0 +1,42 @@
+const playerPrefab = {
+  id: 'player',
+  kind: 'prefab',
+  role: 'player',
+  view: {
+    kind: 'actor2d',
+    collider: { shape: 'rect', size: { x: 28, y: 28 } },
+  },
+  hooks: {},
+  notes: ['Keep authored spawn/state ownership here even while the starter stays JS-first.'],
+};
+
+export function createPlayerPrefab() {
+  return playerPrefab;
+}
+
+export function createPlayerState() {
+  return { x: 0, y: 0 };
+}
+
+export function resetPlayerPosition(player, size) {
+  player.x = size.width * 0.5;
+  player.y = size.height * 0.5;
+}
+
+export function drawPlayer(player, config, dashTimer, touchInvulnerabilityRemaining, hitFlashVisible = false) {
+  const playerColor = hitFlashVisible
+    ? aura.rgb(1.0, 0.98, 0.72)
+    : (touchInvulnerabilityRemaining > 0
+      ? aura.rgb(1.0, 0.72, 0.72)
+      : (dashTimer > 0 ? aura.rgb(0.6, 1.0, 0.82) : aura.rgb(0.4, 0.84, 1.0)));
+
+  aura.draw2d.rect(
+    player.x - (config.playerSize * 0.5),
+    player.y - (config.playerSize * 0.5),
+    config.playerSize,
+    config.playerSize,
+    playerColor,
+  );
+}
+
+export default playerPrefab;

package/templates/create/2d-survivor/prefabs/projectiles.prefab.js

@@ -0,0 +1,56 @@
+const projectilesPrefab = {
+  id: 'projectiles',
+  kind: 'prefab',
+  role: 'custom',
+  view: {
+    kind: 'actor2d',
+  },
+  hooks: {},
+  notes: ['Starter projectile helpers still live beside the authored prefab descriptor in this template.'],
+};
+
+export function fireAutoBullet(player, target, config) {
+  if (!target) return null;
+  const dx = target.x - player.x;
+  const dy = target.y - player.y;
+  const magnitude = Math.hypot(dx, dy) || 1;
+
+  return {
+    x: player.x,
+    y: player.y,
+    vx: (dx / magnitude) * config.bulletSpeed,
+    vy: (dy / magnitude) * config.bulletSpeed,
+    ttl: config.bulletLifetimeSeconds,
+  };
+}
+
+export function updateBullets(bullets, dt) {
+  for (const bullet of bullets) {
+    bullet.x += bullet.vx * dt;
+    bullet.y += bullet.vy * dt;
+    bullet.ttl -= dt;
+  }
+}
+
+export function pruneBullets(bullets, size) {
+  return bullets.filter((bullet) => {
+    if (bullet.ttl <= 0) return false;
+    if (bullet.x < -24 || bullet.y < -24) return false;
+    if (bullet.x > size.width + 24 || bullet.y > size.height + 24) return false;
+    return true;
+  });
+}
+
+export function drawBullets(bullets, config) {
+  for (const bullet of bullets) {
+    aura.draw2d.rect(
+      bullet.x - (config.bulletSize * 0.5),
+      bullet.y - (config.bulletSize * 0.5),
+      config.bulletSize,
+      config.bulletSize,
+      aura.rgb(1.0, 0.94, 0.72),
+    );
+  }
+}
+
+export default projectilesPrefab;

package/templates/create/2d-survivor/scenes/boot.scene.js

@@ -0,0 +1,12 @@
+export function createBootScene() {
+  return {
+    id: 'boot',
+    template: "2d-survivor",
+    nextSceneId: 'gameplay',
+    notes: [
+      'Use this scene for splash, loading, title flow, and session handoff.',
+      'Keep long-lived boot orchestration here instead of bloating src/main.js.',
+      'Keep save or checkpoint resume handoff in src/runtime and appState instead of ad hoc globals.',
+    ],
+  };
+}

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

@@ -0,0 +1,314 @@
+import {
+  axisFromKeys,
+  clamp,
+  consumeCooldown,
+  createCooldown,
+  createFloatingTextLayer2D,
+  createHitFlash2D,
+  createHitSparkLayer2D,
+  createWaveDirector,
+  drawFloatingTextLayer2D,
+  drawHitSparkLayer2D,
+  isHitFlashVisible2D,
+  spawnFloatingText2D,
+  spawnHitSpark2D,
+  stepWaveDirector,
+  stepFloatingTextLayer2D,
+  stepHitFlash2D,
+  stepHitSparkLayer2D,
+  tickCooldown,
+  triggerHitFlash2D,
+} from '../src/starter-utils/index.js';
+import { SURVIVOR_CONFIG, SURVIVOR_TEXT, SURVIVOR_WAVES } from '../config/gameplay/survivor.config.js';
+import {
+  createPlayerState,
+  drawPlayer,
+  resetPlayerPosition,
+} from '../prefabs/player.prefab.js';
+import {
+  drawEnemies,
+  nearestEnemyToPlayer,
+  resolveBulletHits,
+  resolvePlayerContacts,
+  spawnEnemyOnEdge,
+  updateEnemyMovement,
+} from '../prefabs/enemies.prefab.js';
+import {
+  drawBullets,
+  fireAutoBullet,
+  pruneBullets,
+  updateBullets,
+} from '../prefabs/projectiles.prefab.js';
+import { ensureUiState } from '../src/runtime/app-state.js';
+import { drawSurvivorHud } from '../ui/hud.screen.js';
+
+function createSurvivorSessionSeed() {
+  return {
+    runsStarted: 0,
+    bestScore: 0,
+    bestTimeSeconds: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+  };
+}
+
+function ensureSurvivorSession(context, appState) {
+  if (typeof context.ensureSessionState === 'function') {
+    return context.ensureSessionState('survivor', createSurvivorSessionSeed());
+  }
+  if (!appState.session || typeof appState.session !== 'object' || Array.isArray(appState.session)) {
+    appState.session = {};
+  }
+  if (!appState.session.survivor || typeof appState.session.survivor !== 'object' || Array.isArray(appState.session.survivor)) {
+    appState.session.survivor = createSurvivorSessionSeed();
+  }
+  return appState.session.survivor;
+}
+
+function createSurvivorUiStateSeed() {
+  return {
+    showControlsHint: true,
+  };
+}
+
+function ensureSurvivorUiState(context, appState) {
+  if (typeof context.ensureUiState === 'function') {
+    return context.ensureUiState('survivorHud', createSurvivorUiStateSeed());
+  }
+  if (!appState.ui || typeof appState.ui !== 'object' || Array.isArray(appState.ui)) {
+    appState.ui = {};
+  }
+  if (!appState.ui.survivorHud || typeof appState.ui.survivorHud !== 'object' || Array.isArray(appState.ui.survivorHud)) {
+    appState.ui.survivorHud = createSurvivorUiStateSeed();
+  }
+  return appState.ui.survivorHud;
+}
+
+export function createGameplayScene(context = {}) {
+  const appState = context.appState || {};
+  const survivorSession = ensureSurvivorSession(context, appState);
+  const survivorUiState = ensureSurvivorUiState(context, appState);
+  const sceneState = {
+    player: createPlayerState(),
+    bullets: [],
+    enemies: [],
+    score: 0,
+    elapsed: 0,
+    health: SURVIVOR_CONFIG.startingHealth,
+    gameOver: false,
+    shotCooldown: createCooldown(SURVIVOR_CONFIG.autoFireCooldownSeconds),
+    dashCooldown: createCooldown(SURVIVOR_CONFIG.dashCooldownSeconds),
+    touchInvulnerability: createCooldown(SURVIVOR_CONFIG.enemyHitInvulnerabilitySeconds),
+    dashTimer: 0,
+    floatingText: createFloatingTextLayer2D(),
+    hitSparks: createHitSparkLayer2D(),
+    playerHitFlash: createHitFlash2D(),
+    spawnDirector: createWaveDirector({
+      waves: SURVIVOR_WAVES,
+      loop: true,
+      betweenWaveDelay: SURVIVOR_CONFIG.betweenWaveDelaySeconds,
+    }),
+  };
+
+  function syncSessionState() {
+    survivorSession.lastSceneId = 'gameplay';
+    survivorSession.bestScore = Math.max(Number(survivorSession.bestScore || 0), sceneState.score);
+    survivorSession.bestTimeSeconds = Math.max(Number(survivorSession.bestTimeSeconds || 0), sceneState.elapsed);
+    survivorSession.lastScore = sceneState.score;
+    survivorSession.lastElapsedSeconds = Number(sceneState.elapsed.toFixed(2));
+    survivorSession.lastHealth = sceneState.health;
+    survivorSession.lastOutcome = sceneState.gameOver ? 'game-over' : 'running';
+  }
+
+  function resetRun() {
+    resetPlayerPosition(sceneState.player, aura.window.getSize());
+    sceneState.bullets = [];
+    sceneState.enemies = [];
+    sceneState.score = 0;
+    sceneState.elapsed = 0;
+    sceneState.health = SURVIVOR_CONFIG.startingHealth;
+    sceneState.gameOver = false;
+    sceneState.dashTimer = 0;
+    sceneState.shotCooldown = createCooldown(SURVIVOR_CONFIG.autoFireCooldownSeconds);
+    sceneState.dashCooldown = createCooldown(SURVIVOR_CONFIG.dashCooldownSeconds);
+    sceneState.touchInvulnerability = createCooldown(SURVIVOR_CONFIG.enemyHitInvulnerabilitySeconds);
+    sceneState.floatingText = createFloatingTextLayer2D({
+      maxEntries: 24,
+      rise: 18,
+      lifetime: 0.45,
+      size: 14,
+      color: aura.Color.WHITE,
+    });
+    sceneState.hitSparks = createHitSparkLayer2D({
+      maxEntries: 16,
+      radius: 14,
+      innerRadius: 2,
+      lifetime: 0.18,
+      lineWidth: 2,
+      color: aura.rgb(1.0, 0.94, 0.48),
+    });
+    sceneState.playerHitFlash = createHitFlash2D({
+      duration: 0.28,
+      flashesPerSecond: 12,
+    });
+    sceneState.spawnDirector = createWaveDirector({
+      waves: SURVIVOR_WAVES,
+      loop: true,
+      betweenWaveDelay: SURVIVOR_CONFIG.betweenWaveDelaySeconds,
+    });
+    survivorSession.runsStarted += 1;
+    syncSessionState();
+  }
+
+  return {
+    setup() {
+      resetRun();
+      console.log(SURVIVOR_TEXT.started);
+    },
+
+    update(dt) {
+      const size = aura.window.getSize();
+      sceneState.elapsed += dt;
+      stepFloatingTextLayer2D(sceneState.floatingText, dt);
+      stepHitSparkLayer2D(sceneState.hitSparks, dt);
+      stepHitFlash2D(sceneState.playerHitFlash, dt);
+
+      if (sceneState.gameOver) {
+        if (aura.input.isKeyPressed('enter')) resetRun();
+        return;
+      }
+
+      tickCooldown(sceneState.shotCooldown, dt);
+      tickCooldown(sceneState.dashCooldown, dt);
+      tickCooldown(sceneState.touchInvulnerability, dt);
+      if (aura.input.isKeyPressed('h')) {
+        survivorUiState.showControlsHint = survivorUiState.showControlsHint !== true;
+      }
+
+      if (aura.input.isKeyPressed('shift') && consumeCooldown(sceneState.dashCooldown)) {
+        sceneState.dashTimer = SURVIVOR_CONFIG.dashDurationSeconds;
+      }
+      sceneState.dashTimer = Math.max(0, sceneState.dashTimer - dt);
+
+      const moveX = axisFromKeys(aura.input, ['arrowleft', 'a'], ['arrowright', 'd']);
+      const moveY = axisFromKeys(aura.input, ['arrowup', 'w'], ['arrowdown', 's']);
+      const moveSpeed = sceneState.dashTimer > 0 ? SURVIVOR_CONFIG.dashSpeed : SURVIVOR_CONFIG.moveSpeed;
+
+      sceneState.player.x += moveX * moveSpeed * dt;
+      sceneState.player.y += moveY * moveSpeed * dt;
+      sceneState.player.x = clamp(
+        sceneState.player.x,
+        SURVIVOR_CONFIG.playerSize * 0.5,
+        size.width - (SURVIVOR_CONFIG.playerSize * 0.5),
+      );
+      sceneState.player.y = clamp(
+        sceneState.player.y,
+        SURVIVOR_CONFIG.playerSize * 0.5,
+        size.height - (SURVIVOR_CONFIG.playerSize * 0.5),
+      );
+
+      if (consumeCooldown(sceneState.shotCooldown)) {
+        const bullet = fireAutoBullet(
+          sceneState.player,
+          nearestEnemyToPlayer(sceneState.player, sceneState.enemies),
+          SURVIVOR_CONFIG,
+        );
+        if (bullet) sceneState.bullets.push(bullet);
+      }
+
+      stepWaveDirector(sceneState.spawnDirector, dt, (waveState) => {
+        sceneState.enemies.push(spawnEnemyOnEdge(size.width, size.height, waveState, SURVIVOR_CONFIG));
+      });
+
+      updateBullets(sceneState.bullets, dt);
+      sceneState.bullets = pruneBullets(sceneState.bullets, size);
+
+      updateEnemyMovement(sceneState.player, sceneState.enemies, dt);
+      const hitResolution = resolveBulletHits(sceneState.bullets, sceneState.enemies, SURVIVOR_CONFIG);
+      sceneState.bullets = hitResolution.bullets;
+      sceneState.enemies = hitResolution.enemies;
+      sceneState.score += hitResolution.scoreDelta;
+      for (const impact of hitResolution.impactEvents) {
+        spawnHitSpark2D(sceneState.hitSparks, {
+          x: impact.x,
+          y: impact.y,
+          count: impact.defeated ? 7 : 5,
+          radius: impact.defeated ? 18 : 12,
+          color: impact.defeated
+            ? aura.rgb(1.0, 0.96, 0.56)
+            : aura.rgb(1.0, 0.86, 0.42),
+        });
+        spawnFloatingText2D(sceneState.floatingText, {
+          text: impact.defeated ? `+${impact.scoreValue}` : '-1',
+          x: impact.x,
+          y: impact.y - 10,
+          driftX: impact.defeated ? 4 : 0,
+          rise: impact.defeated ? 24 : 18,
+          lifetime: impact.defeated ? 0.55 : 0.4,
+          size: impact.defeated ? 16 : 14,
+          color: impact.defeated ? aura.rgb(1.0, 0.96, 0.52) : aura.Color.WHITE,
+        });
+      }
+
+      const contactResolution = resolvePlayerContacts(
+        sceneState.player,
+        sceneState.enemies,
+        SURVIVOR_CONFIG,
+        sceneState.touchInvulnerability.remaining,
+        sceneState.health,
+      );
+      sceneState.enemies = contactResolution.enemies;
+      sceneState.health = contactResolution.health;
+      sceneState.touchInvulnerability.remaining = contactResolution.invulnerability;
+      if (contactResolution.playerHit && contactResolution.contactPoint) {
+        triggerHitFlash2D(sceneState.playerHitFlash);
+        spawnHitSpark2D(sceneState.hitSparks, {
+          x: contactResolution.contactPoint.x,
+          y: contactResolution.contactPoint.y,
+          count: 6,
+          radius: 16,
+          color: aura.rgb(1.0, 0.52, 0.52),
+        });
+        spawnFloatingText2D(sceneState.floatingText, {
+          text: '-1 HP',
+          x: sceneState.player.x,
+          y: sceneState.player.y - (SURVIVOR_CONFIG.playerSize * 0.9),
+          driftX: 2,
+          rise: 22,
+          lifetime: 0.5,
+          size: 15,
+          color: aura.rgb(1.0, 0.52, 0.52),
+        });
+      }
+      if (contactResolution.gameOver) {
+        sceneState.gameOver = true;
+      }
+      syncSessionState();
+    },
+
+    draw() {
+      const fps = aura.window.getFPS().toFixed(0);
+      aura.draw2d.clear(aura.rgba(0.05, 0.05, 0.08, 1.0));
+      drawEnemies(sceneState.enemies);
+      drawHitSparkLayer2D(aura, sceneState.hitSparks);
+      drawBullets(sceneState.bullets, SURVIVOR_CONFIG);
+      drawPlayer(
+        sceneState.player,
+        SURVIVOR_CONFIG,
+        sceneState.dashTimer,
+        sceneState.touchInvulnerability.remaining,
+        isHitFlashVisible2D(sceneState.playerHitFlash),
+      );
+      drawFloatingTextLayer2D(aura, sceneState.floatingText);
+      drawSurvivorHud({
+        spawnDirector: sceneState.spawnDirector,
+        health: sceneState.health,
+        score: sceneState.score,
+        fps,
+        elapsed: sceneState.elapsed,
+        gameOver: sceneState.gameOver,
+        showControlsHint: survivorUiState.showControlsHint !== false,
+      });
+    },
+  };
+}

package/templates/create/2d-survivor/scenes/menu.scene.js

@@ -0,0 +1,9 @@
+export function createMenuScene() {
+  return {
+    id: "menu",
+    nextSceneId: "gameplay",
+    notes: [
+  "Use this for loadout previews, difficulty, and survivor meta UI."
+],
+  };
+}