aurasu 0.1.7 → 0.1.8

package/aura.package-integrity.json

@@ -150,6 +150,36 @@
       "sha256": "7f0f8344db9fda1d6b3d0c6a45e36ae51d5198b7613deee326a85e67cd2f413b",
       "size": 2142
     },
+    {
+      "path": "assets/splash/aurajs-gg-wordmark.webp",
+      "sha256": "80a4ebd7d23f624aa1ead31c4702b3c21ce8c99075e80e4f3a371870585c73af",
+      "size": 21970
+    },
+    {
+      "path": "assets/splash/bg.webp",
+      "sha256": "3a8892862610ce453314dae576f6707470a7761eb2be5987b55501d9ccd41f54",
+      "size": 46216
+    },
+    {
+      "path": "assets/splash/boot-loop.wav",
+      "sha256": "569b8c457d478b003011d62f165ffd73ad11a598d28337b2c98ee8bb4357c0f7",
+      "size": 70604
+    },
+    {
+      "path": "assets/splash/boot-sting.wav",
+      "sha256": "386abbb357537ec0a284c9ff64de26821782de10002b2b5c9675b26bb755c44d",
+      "size": 48554
+    },
+    {
+      "path": "assets/splash/logo-mascot-sheet.webp",
+      "sha256": "aaa75bea690285b2c6df08182c248cdae6ca374057978cdba25d57d8fb70c225",
+      "size": 22036
+    },
+    {
+      "path": "assets/splash/logoholo.webp",
+      "sha256": "65bec52e3ecb6417aa74832a3153c837b9aaee6b3dd5d7e8536235b7d11442cd",
+      "size": 12782
+    },
     {
       "path": "assets/ui-back.wav",
       "sha256": "a4e071c73866aa94a7e34a636c18aff4a9c83a4bd3d5333f63f07704e982b793",
@@ -177,8 +207,8 @@
     },
     {
       "path": "bin/play.js",
-      "sha256": "9b444ba23f1ea908c16a2266b223f987386966a0248bad0e56f4d2d1beafee46",
-      "size": 40778
+      "sha256": "c29cc4a29d0470e46ce5555cbc4001f96d7458ab7a5975ad55b3248fb5859520",
+      "size": 42416
     },
     {
       "path": "config/gameplay/game.config.js",
@@ -192,7 +222,7 @@
     },
     {
       "path": "package.json",
-      "sha256": "d211b5fd827554a8baa78e1ca4ec03a9e343e4747e5772d0f329b18db0cd94bc",
+      "sha256": "4c081cac3332359fef0c3c4e224ccf1d3f48441c38e70dd54394225110dca757",
       "size": 568
     },
     {
@@ -212,8 +242,8 @@
     },
     {
       "path": "src/main.js",
-      "sha256": "441adcb9f5cd61413b82146b7c9b9b44782f7543a273cb8f6b66b5151a1ff8b7",
-      "size": 365
+      "sha256": "0b2f36b0a56d38529289077b7a43795edc4c064d9747c47f3c200426bbfb67d9",
+      "size": 577
     },
     {
       "path": "src/runtime/app-state.js",
@@ -255,6 +285,11 @@
       "sha256": "56321b896b4368973feb6f5581a9e27d2553b1be91d66206e88cf9ffb25723f8",
       "size": 6384
     },
+    {
+      "path": "src/runtime/splash.js",
+      "sha256": "00cd80250f0abffd14b27241d65dc0b3402c3814a5bb4395d0cd538b20ae59fc",
+      "size": 9799
+    },
     {
       "path": "src/runtime/ui-settings.js",
       "sha256": "c09e6ae51fa3dc507da5c8b1975598629081bad0af98faa32471ca5fb1b32c6e",
@@ -272,14 +307,14 @@
     }
   ],
   "package": {
-    "aurajsVersion": "0.1.1",
+    "aurajsVersion": "0.1.3",
     "bin": {
       "aurasu": "bin/play.js"
     },
     "description": "A hit-circle rhythm game built with AuraJS.",
     "name": "aurasu",
     "type": "module",
-    "version": "0.1.7"
+    "version": "0.1.8"
   },
   "publishedMetadata": {
     "authored": {

package/aura.package-integrity.sig

@@ -1 +1 @@
-O5bkJ0iWLdUelqYfyb8NY2J6Jug9Gl4w1LYuEJlnKiNLcQ6si5Gi8Q4tYvO9QesttU7qw8Boa+HYFCp6zWZDAg==
+dVntP3f6ovlY/3IR88FwdOm1RuqOGaSJlY4d4r0gcWHGG5C2uyapbrNxm2ufha+zqpUXCCma3tTrnEl0Y7oQBg==

package/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,6 +58,39 @@ 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) {
@@ -1063,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));
 
@@ -1092,6 +1157,7 @@ async function main() {
   if (command === 'play') {
     printBanner('PLAY');
     printSection(toDisplayTitle(packageName), 'Starting packaged local game session...');
+    await maybeOfferAuraMaxxInstall();
     const externalAssets = await maybePrepareExternalAssets('play');
     const multiplayerEnv = await resolveLocalMultiplayerCommandEnv();
     await runCommand(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aurasu",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "A hit-circle rhythm game built with AuraJS.",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "aura.package-integrity.sig"
   ],
   "dependencies": {
-    "@auraindustry/aurajs": "0.1.1"
+    "@auraindustry/aurajs": "0.1.3"
   },
   "keywords": [
     "aurajs",

package/src/main.js

@@ -1,16 +1,20 @@
 import { createApp } from './runtime/app.js';
+import { initSplash, updateSplash, drawSplash, isSplashActive } from './runtime/splash.js';
 
 const app = createApp();
 
 aura.setup = function setup() {
+  initSplash();
   return app.setup();
 };
 
 aura.update = function update(dt) {
+  if (isSplashActive()) { updateSplash(dt); return; }
   app.update(dt);
 };
 
 aura.draw = function draw() {
+  if (isSplashActive()) { drawSplash(); return; }
   app.draw();
 };
 

package/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 = [];
+}