@auraindustry/aurajs 0.1.3 → 0.1.5

package/templates/create/shared/src/starter-utils/autoplay-debug-2d.js

@@ -0,0 +1,215 @@
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function keyName(value, fallback) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function normalizeAutoplayAxis(axis) {
+  return {
+    x: clamp(finite(axis?.x, 0), -1, 1),
+    y: clamp(finite(axis?.y, 0), -1, 1),
+  };
+}
+
+function normalizeAutoplayControl(control) {
+  return {
+    axis: normalizeAutoplayAxis(control?.axis),
+    aimAngle: Number.isFinite(Number(control?.aimAngle)) ? Number(control.aimAngle) : null,
+    fire: control?.fire === true,
+    dash: control?.dash === true,
+    extract: control?.extract === true,
+    weaponIndex: Number.isFinite(Number(control?.weaponIndex))
+      ? Math.max(0, Math.floor(Number(control.weaponIndex)))
+      : null,
+  };
+}
+
+export function createAutoplayController2D(options = {}) {
+  return {
+    enabled: options.enabled === true,
+    frameCount: Math.max(0, Math.floor(finite(options.frameCount, 0))),
+    lastReasonCode: keyName(options.lastReasonCode, 'autoplay_idle'),
+    lastControl: options.lastControl ? normalizeAutoplayControl(options.lastControl) : null,
+    buildControl: typeof options.buildControl === 'function' ? options.buildControl : null,
+  };
+}
+
+export function setAutoplayEnabled2D(controller, enabled = true) {
+  if (!controller || typeof controller !== 'object') {
+    throw new Error('autoplay controller is required.');
+  }
+  controller.enabled = enabled === true;
+  controller.lastReasonCode = controller.enabled ? 'autoplay_enabled' : 'autoplay_disabled';
+  return {
+    ok: true,
+    enabled: controller.enabled,
+    reasonCode: controller.lastReasonCode,
+  };
+}
+
+export function toggleAutoplayEnabled2D(controller) {
+  if (!controller || typeof controller !== 'object') {
+    throw new Error('autoplay controller is required.');
+  }
+  return setAutoplayEnabled2D(controller, controller.enabled !== true);
+}
+
+export function resolveAutoplayControl2D(controller, context = {}, buildControl = null) {
+  if (!controller || typeof controller !== 'object') {
+    throw new Error('autoplay controller is required.');
+  }
+  if (controller.enabled !== true) {
+    controller.lastReasonCode = 'autoplay_disabled';
+    return {
+      ok: true,
+      enabled: false,
+      reasonCode: controller.lastReasonCode,
+      frameCount: controller.frameCount,
+      control: null,
+    };
+  }
+
+  const builder = typeof buildControl === 'function' ? buildControl : controller.buildControl;
+  if (typeof builder !== 'function') {
+    controller.lastReasonCode = 'autoplay_builder_missing';
+    return {
+      ok: false,
+      enabled: true,
+      reasonCode: controller.lastReasonCode,
+      frameCount: controller.frameCount,
+      control: null,
+    };
+  }
+
+  try {
+    controller.frameCount += 1;
+    const control = normalizeAutoplayControl(builder(context, controller) || {});
+    controller.lastControl = control;
+    controller.lastReasonCode = 'autoplay_control_ready';
+    return {
+      ok: true,
+      enabled: true,
+      reasonCode: controller.lastReasonCode,
+      frameCount: controller.frameCount,
+      control,
+    };
+  } catch (error) {
+    controller.lastReasonCode = 'autoplay_builder_failed';
+    return {
+      ok: false,
+      enabled: true,
+      reasonCode: controller.lastReasonCode,
+      frameCount: controller.frameCount,
+      control: controller.lastControl,
+      error: String(error && error.message ? error.message : error),
+    };
+  }
+}
+
+export function createRenderTargetExportState2D(options = {}) {
+  return {
+    queued: options.queued === true,
+    path: keyName(options.path, 'aura-export.png'),
+    lastExportReason: keyName(options.lastExportReason, 'draw2d_export_idle'),
+    lastExportOk: options.lastExportOk !== false,
+    exportCount: Math.max(0, Math.floor(finite(options.exportCount, 0))),
+  };
+}
+
+export function queueRenderTargetExport2D(exportState, options = {}) {
+  if (!exportState || typeof exportState !== 'object') {
+    throw new Error('render target export state is required.');
+  }
+  exportState.queued = true;
+  exportState.path = keyName(options.path, exportState.path || 'aura-export.png');
+  return {
+    ok: true,
+    queued: true,
+    path: exportState.path,
+    reasonCode: 'draw2d_render_target_export_queued',
+  };
+}
+
+export function flushRenderTargetExport2D(exportState, renderTarget, aura, options = {}) {
+  if (!exportState || typeof exportState !== 'object') {
+    throw new Error('render target export state is required.');
+  }
+
+  const path = keyName(options.path, exportState.path || 'aura-export.png');
+  exportState.path = path;
+
+  if (exportState.queued !== true) {
+    return {
+      ok: true,
+      exported: false,
+      queued: false,
+      path,
+      reasonCode: 'draw2d_render_target_export_not_queued',
+    };
+  }
+
+  exportState.queued = false;
+
+  if (!renderTarget || typeof renderTarget !== 'object') {
+    exportState.lastExportReason = 'invalid_export_target';
+    exportState.lastExportOk = false;
+    return {
+      ok: false,
+      exported: false,
+      queued: false,
+      path,
+      reasonCode: exportState.lastExportReason,
+    };
+  }
+
+  if (!aura?.draw2d || typeof aura.draw2d.exportRenderTarget !== 'function') {
+    exportState.lastExportReason = 'draw2d_export_unavailable';
+    exportState.lastExportOk = false;
+    return {
+      ok: false,
+      exported: false,
+      queued: false,
+      path,
+      reasonCode: exportState.lastExportReason,
+    };
+  }
+
+  try {
+    const result = aura.draw2d.exportRenderTarget(renderTarget, path) || null;
+    const reasonCode = keyName(result?.reasonCode, 'draw2d_render_target_export_queued');
+    const ok = result?.ok !== false
+      && reasonCode !== 'unsupported_export_format'
+      && reasonCode !== 'invalid_export_target';
+    exportState.lastExportReason = reasonCode;
+    exportState.lastExportOk = ok;
+    if (ok) {
+      exportState.exportCount += 1;
+    }
+    return {
+      ok,
+      exported: ok,
+      queued: false,
+      path: keyName(result?.path, path),
+      reasonCode,
+      result,
+    };
+  } catch (error) {
+    exportState.lastExportReason = 'draw2d_render_target_export_failed';
+    exportState.lastExportOk = false;
+    return {
+      ok: false,
+      exported: false,
+      queued: false,
+      path,
+      reasonCode: exportState.lastExportReason,
+      error: String(error && error.message ? error.message : error),
+    };
+  }
+}

package/templates/create/shared/src/starter-utils/combat-runtime-2d.js

@@ -0,0 +1,290 @@
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function positiveNumber(value, fallback, label) {
+  const numeric = finite(value, fallback);
+  if (!(numeric > 0)) {
+    throw new Error(`${label} must be a positive number.`);
+  }
+  return numeric;
+}
+
+function positiveInteger(value, fallback, label) {
+  const numeric = Math.floor(finite(value, fallback));
+  if (!(numeric >= 1)) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  return numeric;
+}
+
+function ratio01(value) {
+  return Math.max(0, Math.min(1, finite(value, 0)));
+}
+
+function keyName(value, fallback) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+export function applyShieldedDamage2D(target, amount, options = {}) {
+  if (!target || typeof target !== 'object') {
+    throw new Error('shielded damage target is required.');
+  }
+
+  const hpKey = keyName(options.hpKey, 'hp');
+  const shieldKey = keyName(options.shieldKey, 'shield');
+  const invulnKey = keyName(options.invulnKey, 'invuln');
+  const rechargeDelayKey = keyName(options.rechargeDelayKey, 'shieldRechargeDelay');
+  const rechargeTimerKey = keyName(options.rechargeTimerKey, 'shieldRechargeTimer');
+  const damageAmount = Math.max(0, finite(amount, 0));
+  const invulnDuration = Math.max(0, finite(options.invulnDuration, 0));
+
+  if (damageAmount <= 0) {
+    return {
+      ok: true,
+      applied: false,
+      reasonCode: 'no_damage',
+      defeated: finite(target[hpKey], 0) <= 0,
+      absorbed: 0,
+      hpLost: 0,
+      hp: finite(target[hpKey], 0),
+      shield: finite(target[shieldKey], 0),
+    };
+  }
+
+  if (finite(target[invulnKey], 0) > 0 && options.ignoreInvuln !== true) {
+    return {
+      ok: true,
+      applied: false,
+      reasonCode: 'invulnerable',
+      defeated: finite(target[hpKey], 0) <= 0,
+      absorbed: 0,
+      hpLost: 0,
+      hp: finite(target[hpKey], 0),
+      shield: finite(target[shieldKey], 0),
+    };
+  }
+
+  target[rechargeTimerKey] = finite(target[rechargeDelayKey], 0);
+
+  let remaining = damageAmount;
+  const shield = Math.max(0, finite(target[shieldKey], 0));
+  const absorbed = Math.min(shield, remaining);
+  if (absorbed > 0) {
+    target[shieldKey] = shield - absorbed;
+    remaining -= absorbed;
+  }
+
+  const hpBefore = Math.max(0, finite(target[hpKey], 0));
+  const hpLost = Math.min(hpBefore, remaining);
+  if (hpLost > 0) {
+    target[hpKey] = hpBefore - hpLost;
+  }
+
+  if (invulnDuration > 0) {
+    target[invulnKey] = Math.max(finite(target[invulnKey], 0), invulnDuration);
+  }
+
+  return {
+    ok: true,
+    applied: absorbed > 0 || hpLost > 0,
+    reasonCode: null,
+    defeated: finite(target[hpKey], 0) <= 0,
+    absorbed,
+    hpLost,
+    hp: Math.max(0, finite(target[hpKey], 0)),
+    shield: Math.max(0, finite(target[shieldKey], 0)),
+  };
+}
+
+export function stepShieldRecharge2D(target, dt, options = {}) {
+  if (!target || typeof target !== 'object') {
+    throw new Error('shield recharge target is required.');
+  }
+
+  const shieldKey = keyName(options.shieldKey, 'shield');
+  const maxShieldKey = keyName(options.maxShieldKey, 'maxShield');
+  const rechargeTimerKey = keyName(options.rechargeTimerKey, 'shieldRechargeTimer');
+  const rate = Math.max(0, finite(options.rate, 0));
+  const stepDt = Math.max(0, finite(dt, 0));
+
+  target[rechargeTimerKey] = Math.max(0, finite(target[rechargeTimerKey], 0) - stepDt);
+  if (target[rechargeTimerKey] > 0 || rate <= 0) {
+    return {
+      ok: true,
+      recharged: 0,
+      shield: Math.max(0, finite(target[shieldKey], 0)),
+      timer: target[rechargeTimerKey],
+    };
+  }
+
+  const maxShield = Math.max(0, finite(target[maxShieldKey], 0));
+  const shield = Math.max(0, finite(target[shieldKey], 0));
+  const nextShield = Math.min(maxShield, shield + (rate * stepDt));
+  const recharged = nextShield - shield;
+  target[shieldKey] = nextShield;
+
+  return {
+    ok: true,
+    recharged,
+    shield: nextShield,
+    timer: target[rechargeTimerKey],
+  };
+}
+
+export function restoreShieldedHealth2D(target, options = {}) {
+  if (!target || typeof target !== 'object') {
+    throw new Error('shield restore target is required.');
+  }
+
+  const hpKey = keyName(options.hpKey, 'hp');
+  const maxHpKey = keyName(options.maxHpKey, 'maxHp');
+  const shieldKey = keyName(options.shieldKey, 'shield');
+  const maxShieldKey = keyName(options.maxShieldKey, 'maxShield');
+  const hpAmount = Math.max(0, finite(options.hp, 0));
+  const shieldAmount = Math.max(0, finite(options.shield, 0));
+
+  if (hpAmount > 0) {
+    target[hpKey] = Math.min(Math.max(0, finite(target[maxHpKey], 0)), Math.max(0, finite(target[hpKey], 0)) + hpAmount);
+  }
+  if (shieldAmount > 0) {
+    target[shieldKey] = Math.min(Math.max(0, finite(target[maxShieldKey], 0)), Math.max(0, finite(target[shieldKey], 0)) + shieldAmount);
+  }
+
+  return {
+    ok: true,
+    hp: Math.max(0, finite(target[hpKey], 0)),
+    shield: Math.max(0, finite(target[shieldKey], 0)),
+  };
+}
+
+function normalizeDropEntries(entries = []) {
+  let runningWeight = 0;
+  return (Array.isArray(entries) ? entries : [])
+    .map((entry, index) => {
+      const raw = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+      if (!raw) return null;
+      const id = keyName(raw.id, `drop-${index + 1}`);
+      const weight = positiveNumber(raw.weight, 1, `drop "${id}" weight`);
+      runningWeight += weight;
+      return {
+        ...raw,
+        id,
+        weight,
+        cumulativeWeight: runningWeight,
+      };
+    })
+    .filter(Boolean);
+}
+
+export function createWeightedDropTable2D(entries = []) {
+  const normalized = normalizeDropEntries(entries);
+  return {
+    entries: normalized,
+    totalWeight: normalized.length > 0 ? normalized[normalized.length - 1].cumulativeWeight : 0,
+  };
+}
+
+export function rollWeightedDrop2D(table, sample = Math.random()) {
+  if (!table || !Array.isArray(table.entries) || table.entries.length === 0 || !(table.totalWeight > 0)) {
+    return null;
+  }
+
+  const threshold = ratio01(sample) * table.totalWeight;
+  for (const entry of table.entries) {
+    if (threshold <= entry.cumulativeWeight) {
+      return entry;
+    }
+  }
+  return table.entries[table.entries.length - 1] || null;
+}
+
+export function createEncounterPressure2D(options = {}) {
+  return {
+    kills: Math.max(0, Math.floor(finite(options.kills, 0))),
+    wave: Math.max(1, Math.floor(finite(options.wave, 1))),
+    combo: Math.max(0, Math.floor(finite(options.combo, 0))),
+    comboTimer: Math.max(0, finite(options.comboTimer, 0)),
+    comboWindow: positiveNumber(options.comboWindow, 2.1, 'combat pressure comboWindow'),
+    waveEveryKills: positiveInteger(options.waveEveryKills, 10, 'combat pressure waveEveryKills'),
+  };
+}
+
+export function recordEncounterKill2D(pressure, options = {}) {
+  if (!pressure || typeof pressure !== 'object') {
+    throw new Error('encounter pressure state is required.');
+  }
+
+  const comboWindow = positiveNumber(options.comboWindow, pressure.comboWindow, 'combat pressure comboWindow');
+  const waveEveryKills = positiveInteger(options.waveEveryKills, pressure.waveEveryKills, 'combat pressure waveEveryKills');
+
+  pressure.comboWindow = comboWindow;
+  pressure.waveEveryKills = waveEveryKills;
+  pressure.kills = Math.max(0, Math.floor(finite(pressure.kills, 0))) + 1;
+  pressure.combo = Math.max(0, Math.floor(finite(pressure.combo, 0))) + 1;
+  pressure.comboTimer = comboWindow;
+
+  const waveAdvanced = pressure.kills % waveEveryKills === 0;
+  if (waveAdvanced) {
+    pressure.wave = Math.max(1, Math.floor(finite(pressure.wave, 1))) + 1;
+  }
+
+  return {
+    ok: true,
+    waveAdvanced,
+    kills: pressure.kills,
+    combo: pressure.combo,
+    comboTimer: pressure.comboTimer,
+    wave: pressure.wave,
+  };
+}
+
+export function stepEncounterPressure2D(pressure, dt) {
+  if (!pressure || typeof pressure !== 'object') {
+    throw new Error('encounter pressure state is required.');
+  }
+
+  pressure.comboTimer = Math.max(0, finite(pressure.comboTimer, 0) - Math.max(0, finite(dt, 0)));
+  if (pressure.comboTimer <= 0) {
+    pressure.combo = 0;
+  }
+
+  return {
+    ok: true,
+    combo: pressure.combo,
+    comboTimer: pressure.comboTimer,
+    wave: Math.max(1, Math.floor(finite(pressure.wave, 1))),
+    kills: Math.max(0, Math.floor(finite(pressure.kills, 0))),
+  };
+}
+
+export function advanceBossPhase2D(entity, healthRatio, thresholds = [], options = {}) {
+  if (!entity || typeof entity !== 'object') {
+    throw new Error('boss phase entity is required.');
+  }
+
+  const phaseKey = keyName(options.phaseKey, 'phaseStage');
+  const normalizedThresholds = [...(Array.isArray(thresholds) ? thresholds : [])]
+    .map((entry) => ratio01(entry))
+    .sort((left, right) => right - left);
+  const currentPhase = Math.max(0, Math.floor(finite(entity[phaseKey], 0)));
+  let nextPhase = currentPhase;
+
+  for (let index = 0; index < normalizedThresholds.length; index += 1) {
+    if (ratio01(healthRatio) <= normalizedThresholds[index]) {
+      nextPhase = Math.max(nextPhase, index + 1);
+    }
+  }
+
+  if (options.mutate === true) {
+    entity[phaseKey] = nextPhase;
+  }
+
+  return {
+    ok: true,
+    shifted: nextPhase > currentPhase,
+    phaseStage: nextPhase,
+    previousPhaseStage: currentPhase,
+  };
+}