@auraindustry/aurajs 0.1.0 → 0.1.3

package/templates/create/shared/src/runtime/splash.js

@@ -0,0 +1,305 @@
+// AuraJS Splash — unified retro paper-card boot screen.
+// Auto-wired by createApp(). Shows once on launch, then hands off to the game.
+
+const FADE_IN = 0.7;
+const HOLD = 1.8;
+const FADE_OUT = 0.7;
+const TOTAL = FADE_IN + HOLD + FADE_OUT;
+
+const PAPER = [0.89, 0.89, 0.89];
+const PAPER_SHADOW = [0.80, 0.80, 0.80];
+const PAPER_EDGE = [0.41, 0.41, 0.41];
+const INK = [0.1, 0.1, 0.1];
+const INK_MUTED = [0.42, 0.42, 0.42];
+const MASCOT_FRAME_W = 64;
+const MASCOT_FRAME_H = 84;
+const MASCOT_SEQUENCE = Object.freeze([0, 1, 2, 1]);
+const SPLASH_STING_PATH = 'splash/boot-sting.wav';
+const SPLASH_LOOP_PATH = 'splash/boot-loop.wav';
+const SPLASH_BUS = 'splash';
+const QUIET_BUSES = Object.freeze(['default', 'music', 'sfx']);
+
+let state = null;
+
+function has(obj, method) {
+  return Boolean(obj) && typeof obj[method] === 'function';
+}
+
+function color(rgb, alpha = 1) {
+  return aura.rgba(rgb[0], rgb[1], rgb[2], alpha);
+}
+
+function drawShadowText(text, x, y, options = {}) {
+  const {
+    shadowOffset = 2,
+    shadowColor = color(INK_MUTED, 0.3),
+    ...rest
+  } = options;
+  aura.draw2d.text(text, x + shadowOffset, y + shadowOffset, {
+    ...rest,
+    color: shadowColor,
+  });
+  aura.draw2d.text(text, x, y, rest);
+}
+
+export function initSplash() {
+  state = {
+    t: 0,
+    logo: null,
+    mascot: null,
+    wordmark: null,
+    font: null,
+    stingHandle: null,
+    loopHandle: null,
+    busVolumes: null,
+    pausedHandles: [],
+  };
+  try { if (has(aura.assets, 'load')) state.logo = aura.assets.load('splash/logoholo.webp'); } catch (_) {}
+  try { if (has(aura.assets, 'load')) state.mascot = aura.assets.load('splash/logo-mascot-sheet.webp'); } catch (_) {}
+  try { if (has(aura.assets, 'load')) state.wordmark = aura.assets.load('splash/aurajs-gg-wordmark.webp'); } catch (_) {}
+  try {
+    if (has(aura.assets, 'loadBitmapFont')) {
+      const result = aura.assets.loadBitmapFont();
+      if (result && result.ok && result.font) state.font = result.font;
+    }
+  } catch (_) {}
+  captureBusVolumes();
+  applySplashBusIsolation();
+  try {
+    if (aura.audio && aura.audio.supported !== false && typeof aura.audio.play === 'function') {
+      state.loopHandle = aura.audio.play(SPLASH_LOOP_PATH, {
+        loop: true,
+        volume: 0.22,
+        bus: SPLASH_BUS,
+      });
+      state.stingHandle = aura.audio.play(SPLASH_STING_PATH, {
+        loop: false,
+        volume: 0.54,
+        bus: SPLASH_BUS,
+      });
+    }
+  } catch (_) {}
+}
+
+export function isSplashActive() {
+  return state !== null;
+}
+
+export function updateSplash(dt) {
+  if (!state) return;
+  syncPausedTracks();
+  try {
+    if (aura.audio && typeof aura.audio.update === 'function') {
+      aura.audio.update(Number(dt) > 0 ? Number(dt) : (1 / 60));
+    }
+  } catch (_) {}
+  state.t += dt;
+  if (state.t >= TOTAL) {
+    stopSplashAudio();
+    state = null;
+  }
+}
+
+export function drawSplash() {
+  if (!state) return;
+  const { width: w, height: h } = has(aura.window, 'getSize')
+    ? aura.window.getSize()
+    : { width: 640, height: 480 };
+  const t = state.t;
+  const cx = w / 2;
+  const cy = h / 2;
+
+  let a = 1;
+  if (t < FADE_IN) a = easeOut(t / FADE_IN);
+  else if (t > FADE_IN + HOLD) a = 1 - easeIn((t - FADE_IN - HOLD) / FADE_OUT);
+
+  aura.draw2d.clear(color(PAPER));
+
+  const panelW = Math.min(Math.floor(w * 0.48), 580);
+  const panelH = Math.min(Math.floor(h * 0.72), 620);
+  const panelX = Math.floor(cx - (panelW * 0.5));
+  const panelY = Math.floor(cy - (panelH * 0.5));
+
+  aura.draw2d.rectFill(panelX + 6, panelY + 6, panelW, panelH, color(INK, 0.08 * a));
+  aura.draw2d.rectFill(panelX, panelY, panelW, panelH, color(PAPER_EDGE, a));
+  aura.draw2d.rectFill(panelX + 6, panelY + 6, panelW - 12, panelH - 12, color(PAPER, a));
+  aura.draw2d.rectFill(panelX + 12, panelY + 12, panelW - 24, panelH - 24, color(PAPER, a * 0.96));
+
+  const floatY = Math.sin(t * 1.4 * Math.PI * 2) * 2;
+  const breathe = 0.985 + 0.015 * (0.5 + 0.5 * Math.sin(t * Math.PI * 2));
+  const mascotScale = Math.max(1, Math.min(Math.floor(Math.min(w, h) / 260), 2));
+  const mascotW = Math.floor(MASCOT_FRAME_W * mascotScale * breathe);
+  const mascotH = Math.floor(MASCOT_FRAME_H * mascotScale * breathe);
+  const mascotX = Math.floor(cx - (mascotW * 0.5));
+  const mascotY = Math.floor(panelY + panelH * 0.40 + floatY);
+  const mascotFrame = MASCOT_SEQUENCE[Math.floor(t * 7.5) % MASCOT_SEQUENCE.length] || 0;
+
+  aura.draw2d.rectFill(
+    mascotX + Math.floor(mascotW * 0.18),
+    mascotY + mascotH - 8,
+    Math.floor(mascotW * 0.64),
+    6,
+    color(INK, a * 0.08),
+  );
+
+  if (state.mascot) {
+    aura.draw2d.sprite(state.mascot, mascotX, mascotY, {
+      width: mascotW,
+      height: mascotH,
+      frameX: mascotFrame * MASCOT_FRAME_W,
+      frameY: 0,
+      frameW: MASCOT_FRAME_W,
+      frameH: MASCOT_FRAME_H,
+      alpha: a,
+    });
+  } else if (state.logo) {
+    const sz = Math.min(Math.floor(panelW * 0.24), Math.floor(h * 0.14)) * breathe;
+    aura.draw2d.sprite(state.logo, Math.floor(cx - sz / 2), Math.floor(mascotY + 6), {
+      width: sz,
+      height: sz,
+      alpha: a,
+    });
+  }
+
+  const ta = clamp(a * easeOut(clamp((t - 0.2) / (FADE_IN * 0.6))));
+  const sa = clamp(a * easeOut(clamp((t - 0.4) / (FADE_IN * 0.6))));
+  const scale = Math.min(w, h) / 480;
+  const tsz = Math.max(24, Math.round(scale * 28));
+  const ssz = Math.max(11, Math.round(scale * 12));
+  const wordmarkW = Math.min(Math.floor(panelW * 0.52), 290);
+  const wordmarkH = Math.floor(wordmarkW * (768 / 1408));
+  const wordmarkX = Math.floor(cx - (wordmarkW * 0.5));
+  const wordmarkY = Math.floor(panelY + 36);
+  const sY = Math.floor(panelY + panelH - 108);
+  const fo = state.font ? { font: state.font } : {};
+
+  if (state.wordmark) {
+    aura.draw2d.sprite(state.wordmark, wordmarkX, wordmarkY, {
+      width: wordmarkW,
+      height: wordmarkH,
+      alpha: ta,
+      tint: color(INK, ta),
+    });
+  } else {
+    drawShadowText('AuraJS.gg', cx, wordmarkY + Math.floor(wordmarkH * 0.55), {
+      ...fo,
+      size: tsz,
+      color: color(INK, ta),
+      shadowColor: color(INK_MUTED, ta * 0.28),
+      align: 'center',
+    });
+  }
+
+  drawShadowText('Open-Source. MIT.', cx, sY, {
+    ...fo,
+    size: ssz,
+    color: color(INK_MUTED, sa),
+    shadowColor: color(PAPER_EDGE, sa * 0.18),
+    shadowOffset: 1,
+    align: 'center',
+  });
+  drawShadowText('Who needs publishers?', cx, sY + Math.max(16, Math.round(ssz * 1.45)), {
+    ...fo,
+    size: ssz,
+    color: color(INK_MUTED, sa),
+    shadowColor: color(PAPER_EDGE, sa * 0.18),
+    shadowOffset: 1,
+    align: 'center',
+  });
+
+  const rw = Math.min(panelW - 140, 240);
+  aura.draw2d.rectFill(Math.floor(cx - rw / 2), Math.floor(sY + Math.max(34, ssz * 3.2)), rw, 2, color(PAPER_EDGE, sa * 0.38));
+}
+
+function easeOut(t) {
+  const u = 1 - clamp(t);
+  return 1 - (u * u * u);
+}
+
+function easeIn(t) {
+  const c = clamp(t);
+  return c * c * c;
+}
+
+function clamp(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+
+function stopSplashAudio() {
+  if (!state || !aura.audio || typeof aura.audio.stop !== 'function') return;
+  try {
+    if (state.stingHandle != null) aura.audio.stop(state.stingHandle);
+  } catch (_) {}
+  try {
+    if (state.loopHandle != null) aura.audio.stop(state.loopHandle);
+  } catch (_) {}
+  restoreAudioState();
+  state.stingHandle = null;
+  state.loopHandle = null;
+}
+
+function captureBusVolumes() {
+  if (!state || !aura.audio || typeof aura.audio.getMixerState !== 'function') return;
+  try {
+    const mixer = aura.audio.getMixerState();
+    const buses = Array.isArray(mixer?.buses) ? mixer.buses : [];
+    state.busVolumes = buses.reduce((acc, entry) => {
+      const bus = String(entry?.bus || '').trim();
+      if (!bus) return acc;
+      acc[bus] = Number(entry?.volume);
+      return acc;
+    }, {});
+  } catch (_) {}
+}
+
+function applySplashBusIsolation() {
+  if (!state || !aura.audio || typeof aura.audio.setBusVolume !== 'function') return;
+  try { aura.audio.setBusVolume(SPLASH_BUS, 1); } catch (_) {}
+  for (const bus of QUIET_BUSES) {
+    try { aura.audio.setBusVolume(bus, 0); } catch (_) {}
+  }
+}
+
+function syncPausedTracks() {
+  if (!state || !aura.audio || typeof aura.audio.getMixerState !== 'function' || typeof aura.audio.pause !== 'function') return;
+  try {
+    const mixer = aura.audio.getMixerState();
+    const tracks = Array.isArray(mixer?.tracks) ? mixer.tracks : [];
+    const splashHandles = [state.stingHandle, state.loopHandle].filter((handle) => handle != null);
+    const pausedHandles = new Set(Array.isArray(state.pausedHandles) ? state.pausedHandles : []);
+    for (const track of tracks) {
+      const handle = Number(track?.handle);
+      if (!Number.isInteger(handle) || handle <= 0) continue;
+      if (splashHandles.includes(handle)) continue;
+      if (track?.paused === true || pausedHandles.has(handle)) continue;
+      try {
+        aura.audio.pause(handle);
+        pausedHandles.add(handle);
+      } catch (_) {}
+    }
+    state.pausedHandles = Array.from(pausedHandles);
+  } catch (_) {}
+}
+
+function restoreAudioState() {
+  if (!state || !aura.audio) return;
+  if (typeof aura.audio.setBusVolume === 'function') {
+    const snapshot = state.busVolumes && typeof state.busVolumes === 'object' ? state.busVolumes : null;
+    if (snapshot) {
+      for (const [bus, volume] of Object.entries(snapshot)) {
+        try { aura.audio.setBusVolume(bus, Number(volume)); } catch (_) {}
+      }
+    } else {
+      for (const bus of QUIET_BUSES) {
+        try { aura.audio.setBusVolume(bus, 1); } catch (_) {}
+      }
+    }
+    try { aura.audio.setBusVolume(SPLASH_BUS, 1); } catch (_) {}
+  }
+  if (typeof aura.audio.resume === 'function') {
+    for (const handle of Array.isArray(state.pausedHandles) ? state.pausedHandles : []) {
+      try { aura.audio.resume(handle); } catch (_) {}
+    }
+  }
+  state.pausedHandles = [];
+}

package/templates/create/video-cutscene/src/runtime/app.js

@@ -1,6 +1,7 @@
 import { createSceneRegistry } from './scene-registry.js';
 import { createProjectInspector } from './project-inspector.js';
 import { assertRuntimeCapabilities } from './capabilities.js';
+import { initSplash, updateSplash, drawSplash, isSplashActive } from './splash.js';
 
 export function createApp() {
   const sceneRegistry = createSceneRegistry({
@@ -26,13 +27,16 @@ export function createApp() {
     },
     setup() {
       assertRuntimeCapabilities();
+      initSplash();
       activeScene()?.setup?.();
     },
     update(dt) {
+      if (isSplashActive()) { updateSplash(dt); return; }
       projectInspector.syncInput(globalThis.aura?.input || null);
       activeScene()?.update?.(dt);
     },
     draw() {
+      if (isSplashActive()) { drawSplash(); return; }
       activeScene()?.draw?.();
       projectInspector.draw({ activeSceneId });
     },

package/templates/create-bin/play.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { cpSync, createWriteStream, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -58,9 +58,50 @@ const ALL_COMMANDS = ['dev', 'join', 'play', 'fork', 'publish', 'session', 'stat
 const ROOM_CODE_PATTERN = /^[A-Z0-9]{4,8}$/;
 const FORK_EXCLUDED_TOP_LEVEL = new Set(['.aura', '.git', '.logs', 'build', 'dist', 'node_modules']);
 
+function resolveAuraMaxxBinary() {
+  return process.platform === 'win32' ? 'auramaxx.cmd' : 'auramaxx';
+}
+
+function resolveNpmBinary() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function isAuraMaxxInstalled() {
+  const probe = spawnSync(resolveAuraMaxxBinary(), ['--version'], {
+    stdio: 'ignore',
+    env: process.env,
+  });
+  return !probe.error && probe.status === 0;
+}
+
+async function installAuraMaxxGlobally() {
+  return new Promise((resolveInstall) => {
+    const child = spawn(
+      resolveNpmBinary(),
+      ['install', '-g', 'auramaxx', '--foreground-scripts'],
+      {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+        env: process.env,
+      },
+    );
+
+    child.on('error', () => resolveInstall(false));
+    child.on('close', (code) => resolveInstall((code ?? 1) === 0));
+  });
+}
+
 function resolveLocalAuraCli(startRoot) {
   let current = resolve(startRoot);
   while (true) {
+    const monorepoCandidate = resolve(current, 'packages', 'aurascript', 'src', 'cli', 'src', 'cli.mjs');
+    if (existsSync(monorepoCandidate)) {
+      return monorepoCandidate;
+    }
+    const packageSourceCandidate = resolve(current, 'src', 'cli', 'src', 'cli.mjs');
+    if (existsSync(packageSourceCandidate)) {
+      return packageSourceCandidate;
+    }
     const candidate = resolve(current, 'node_modules', '@auraindustry', 'aurajs', 'src', 'cli.mjs');
     if (existsSync(candidate)) {
       return candidate;
@@ -495,6 +536,41 @@ function parseArgs(argv) {
   };
 }
 
+function parsePublishArgs(args) {
+  const passthroughArgs = [];
+  let npmToken = null;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = String(args[index] || '');
+    if (token === '--token') {
+      if ((index + 1) >= args.length) {
+        throw createCliError('publish requires a token value after --token.');
+      }
+      npmToken = String(args[index + 1] || '').trim();
+      index += 1;
+      continue;
+    }
+    if (token.startsWith('--token=')) {
+      npmToken = token.slice('--token='.length).trim();
+      continue;
+    }
+    passthroughArgs.push(token);
+  }
+
+  if (npmToken !== null && npmToken.length === 0) {
+    throw createCliError('publish requires a non-empty token value after --token.');
+  }
+
+  return {
+    commandArgs: passthroughArgs,
+    env: npmToken
+      ? {
+        NODE_AUTH_TOKEN: npmToken,
+      }
+      : null,
+  };
+}
+
 function readJsonIfExists(filePath) {
   if (!existsSync(filePath)) {
     return null;
@@ -604,6 +680,7 @@ function resolveProjectMultiplayerConfig() {
       relayHost: null,
       coordinatorUrl: null,
       relayUrl: null,
+      launcherBaseUrl: null,
       showDiagnostics: null,
       chatEnabled: null,
       chatHistoryLimit: null,
@@ -619,6 +696,7 @@ function resolveProjectMultiplayerConfig() {
     relayHost: readOptionalCliText(raw.relay || raw.relayHost),
     coordinatorUrl: readOptionalCliText(raw.coordinatorUrl),
     relayUrl: readOptionalCliText(raw.relayUrl),
+    launcherBaseUrl: readOptionalCliText(raw.launcherBaseUrl || raw.launcherUrl),
     showDiagnostics: typeof raw.showDiagnostics === 'boolean' ? raw.showDiagnostics : null,
     chatEnabled: typeof raw.chatEnabled === 'boolean' ? raw.chatEnabled : null,
     chatHistoryLimit: historyLimit,
@@ -679,6 +757,9 @@ async function resolveLocalMultiplayerCommandEnv() {
   if (relayUrl) {
     env.AURA_RELAY_URL = relayUrl;
   }
+  if (projectMultiplayer.launcherBaseUrl) {
+    env.AURA_MULTIPLAYER_LAUNCHER_BASE_URL = projectMultiplayer.launcherBaseUrl;
+  }
   if (typeof projectMultiplayer.showDiagnostics === 'boolean') {
     env.AURA_MULTIPLAYER_SHOW_DIAGNOSTICS = projectMultiplayer.showDiagnostics ? '1' : '0';
   }
@@ -900,7 +981,7 @@ function assertJoinSupported() {
       : 'project capability declarations';
     throw new Error(
       `join unavailable: multiplayer is disabled in ${sourceDetail}. `
-      + `Use \`npm run play\` for a normal local launch or \`${packageBin} play\` for a packaged launch.`,
+      + `Use \`npm run dev\` for the local authoring loop, \`npm run play\` for a packaged local launch, or \`${packageBin} play\` for an installed package launch.`,
     );
   }
 }
@@ -1015,6 +1096,38 @@ async function chooseDefaultCommand() {
   return choice;
 }
 
+async function maybeOfferAuraMaxxInstall() {
+  if (isAuraMaxxInstalled()) {
+    return;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return;
+  }
+
+  printSection('AuraMaxx', 'AuraMaxx is not installed globally.');
+  const choice = await promptSelect(
+    '  Install AuraMaxx now?',
+    [
+      { value: 'yes', label: 'Yes, install AuraMaxx' },
+      { value: 'no', label: 'No, continue playing' },
+    ],
+    'yes',
+  );
+
+  if (choice !== 'yes') {
+    return;
+  }
+
+  printSection('AuraMaxx', 'Installing global CLI...');
+  const installed = await installAuraMaxxGlobally();
+  if (installed) {
+    printSection('AuraMaxx', 'Installed. Continuing play...');
+    return;
+  }
+  printSection('AuraMaxx', 'Install failed. Continuing play...');
+}
+
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
 
@@ -1043,7 +1156,8 @@ async function main() {
 
   if (command === 'play') {
     printBanner('PLAY');
-    printSection(toDisplayTitle(packageName), 'Starting game + dev session...');
+    printSection(toDisplayTitle(packageName), 'Starting packaged local game session...');
+    await maybeOfferAuraMaxxInstall();
     const externalAssets = await maybePrepareExternalAssets('play');
     const multiplayerEnv = await resolveLocalMultiplayerCommandEnv();
     await runCommand(
@@ -1140,8 +1254,11 @@ async function main() {
       printSection(toDisplayTitle(packageName), 'Publish lifecycle detected, skipping wrapper recursion.');
       return;
     }
+    const publish = parsePublishArgs(commandArgs);
     printSection(toDisplayTitle(packageName), 'Publishing npm package (source + assets)...');
-    await runCommand('publish', resolveAuraCliInvocation(['publish', ...commandArgs]));
+    await runCommand('publish', resolveAuraCliInvocation(['publish', ...publish.commandArgs]), {
+      env: publish.env,
+    });
     return;
   }
 

package/templates/starter/src/main.js

@@ -3,6 +3,7 @@
 // - modules.physics: enables aura.physics.*
 // - modules.network: enables aura.net.*
 // - modules.steam: enables aura.steam.*
+import { initSplash, updateSplash, drawSplash, isSplashActive } from './runtime/splash.js';
 
 let x = 400;
 let y = 300;
@@ -153,6 +154,7 @@ function clearScreen(color) {
 
 aura.setup = function () {
   assertRuntimeCapabilities();
+  initSplash();
   console.log("{{PROJECT_NAME}} started");
   if (!hasAsset(PLAYER_SPRITE_PATH)) {
     console.log(`Tip: add assets/${PLAYER_SPRITE_PATH} to preview sprite draw2d options.`);
@@ -163,6 +165,7 @@ aura.setup = function () {
 };
 
 aura.update = function (dt) {
+  if (isSplashActive()) { updateSplash(dt); return; }
   if (keyDown("arrowright")) x += speed * dt;
   if (keyDown("arrowleft"))  x -= speed * dt;
   if (keyDown("arrowup"))    y -= speed * dt;
@@ -186,6 +189,7 @@ aura.update = function (dt) {
 };
 
 aura.draw = function () {
+  if (isSplashActive()) { drawSplash(); return; }
   const bg = rgba(0.08, 0.08, 0.12, 1.0);
   clearScreen(bg);