nova64 0.2.5 → 0.2.7

package/dist/runtime/api.js

@@ -0,0 +1,201 @@
+// runtime/api.js
+// Helpers to pack/unpack 64-bit color (RGBA64)
+function packRGBA64(r16, g16, b16, a16) {
+  // Ensure all values are integers before converting to BigInt
+  const r = BigInt(Math.floor(r16));
+  const g = BigInt(Math.floor(g16));
+  const b = BigInt(Math.floor(b16));
+  const a = BigInt(Math.floor(a16));
+  return (r << 48n) | (g << 32n) | (b << 16n) | a;
+}
+function unpackRGBA64(c) {
+  // Handle both BigInt and regular number inputs
+  if (typeof c === 'bigint') {
+    return {
+      r: Number((c >> 48n) & 0xffffn),
+      g: Number((c >> 32n) & 0xffffn),
+      b: Number((c >> 16n) & 0xffffn),
+      a: Number(c & 0xffffn),
+    };
+  } else {
+    // Handle regular number input - convert to BigInt first
+    const bigC = BigInt(Math.floor(c));
+    return {
+      r: Number((bigC >> 48n) & 0xffffn),
+      g: Number((bigC >> 32n) & 0xffffn),
+      b: Number((bigC >> 16n) & 0xffffn),
+      a: Number(bigC & 0xffffn),
+    };
+  }
+}
+function rgba8(r, g, b, a = 255) {
+  // Clamp input values to 0-255 range and ensure they're integers
+  const clampedR = Math.max(0, Math.min(255, Math.floor(r)));
+  const clampedG = Math.max(0, Math.min(255, Math.floor(g)));
+  const clampedB = Math.max(0, Math.min(255, Math.floor(b)));
+  const clampedA = Math.max(0, Math.min(255, Math.floor(a)));
+
+  const s = 257;
+  return packRGBA64(clampedR * s, clampedG * s, clampedB * s, clampedA * s);
+}
+
+import { BitmapFont } from './font.js';
+
+export function stdApi(gpu) {
+  const fb = gpu.getFramebuffer();
+
+  // Camera
+  const camRef = { x: 0, y: 0 };
+  function setCamera(x, y) {
+    camRef.x = x | 0;
+    camRef.y = y | 0;
+  }
+  function getCamera() {
+    return camRef;
+  }
+
+  function _colorToRGBA16(c) {
+    if (typeof c === 'bigint' || typeof c === 'number') {
+      return unpackRGBA64(c);
+    }
+    return { r: 65535, g: 65535, b: 65535, a: 65535 };
+  }
+  function cls(color) {
+    const { r, g, b, a } =
+      typeof color === 'bigint' ? unpackRGBA64(color) : { r: 0, g: 0, b: 0, a: 65535 };
+    fb.fill(r, g, b, a);
+  }
+  function pset(x, y, color) {
+    const { r, g, b, a } = _colorToRGBA16(color);
+    fb.pset((x | 0) - camRef.x, (y | 0) - camRef.y, r, g, b, a);
+  }
+  function line(x0, y0, x1, y1, color) {
+    const { r, g, b, a } = _colorToRGBA16(color);
+    x0 = (x0 | 0) - camRef.x;
+    y0 = (y0 | 0) - camRef.y;
+    x1 = (x1 | 0) - camRef.x;
+    y1 = (y1 | 0) - camRef.y;
+    let dx = Math.abs(x1 - x0),
+      sx = x0 < x1 ? 1 : -1;
+    let dy = -Math.abs(y1 - y0),
+      sy = y0 < y1 ? 1 : -1;
+    let err = dx + dy;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (x0 >= 0 && y0 >= 0 && x0 < fb.width && y0 < fb.height) fb.pset(x0, y0, r, g, b, a);
+      if (x0 === x1 && y0 === y1) break;
+      const e2 = 2 * err;
+      if (e2 >= dy) {
+        err += dy;
+        x0 += sx;
+      }
+      if (e2 <= dx) {
+        err += dx;
+        y0 += sy;
+      }
+    }
+  }
+  function rect(x, y, w, h, color, fill = false) {
+    const { r, g, b, a } = _colorToRGBA16(color);
+    x = (x | 0) - camRef.x;
+    y = (y | 0) - camRef.y;
+    w |= 0;
+    h |= 0;
+    const x0 = Math.max(0, x),
+      y0 = Math.max(0, y);
+    const x1 = Math.min(fb.width, x + w),
+      y1 = Math.min(fb.height, y + h);
+    if (fill) {
+      for (let yy = y0; yy < y1; yy++) {
+        for (let xx = x0; xx < x1; xx++) fb.pset(xx, yy, r, g, b, a);
+      }
+    } else {
+      for (let xx = x0; xx < x1; xx++) {
+        if (y >= 0 && y < fb.height) fb.pset(xx, y, r, g, b, a);
+        if (y + h - 1 >= 0 && y + h - 1 < fb.height) fb.pset(xx, y + h - 1, r, g, b, a);
+      }
+      for (let yy = y0; yy < y1; yy++) {
+        if (x >= 0 && x < fb.width) fb.pset(x, yy, r, g, b, a);
+        if (x + w - 1 >= 0 && x + w - 1 < fb.width) fb.pset(x + w - 1, yy, r, g, b, a);
+      }
+    }
+  }
+
+  function circle(x, y, radius, color, fill = false) {
+    const { r, g, b, a } = _colorToRGBA16(color);
+    x = (x | 0) - camRef.x;
+    y = (y | 0) - camRef.y;
+    radius |= 0;
+
+    if (fill) {
+      // Filled circle using scanline algorithm
+      for (let dy = -radius; dy <= radius; dy++) {
+        const dx = Math.floor(Math.sqrt(radius * radius - dy * dy));
+        for (let xx = x - dx; xx <= x + dx; xx++) {
+          const yy = y + dy;
+          if (xx >= 0 && xx < fb.width && yy >= 0 && yy < fb.height) {
+            fb.pset(xx, yy, r, g, b, a);
+          }
+        }
+      }
+    } else {
+      // Midpoint circle algorithm (Bresenham)
+      let dx = radius,
+        dy = 0,
+        err = 0;
+      while (dx >= dy) {
+        const plots = [
+          [x + dx, y + dy],
+          [x + dy, y + dx],
+          [x - dy, y + dx],
+          [x - dx, y + dy],
+          [x - dx, y - dy],
+          [x - dy, y - dx],
+          [x + dy, y - dx],
+          [x + dx, y - dy],
+        ];
+        for (const [px, py] of plots) {
+          if (px >= 0 && px < fb.width && py >= 0 && py < fb.height) {
+            fb.pset(px, py, r, g, b, a);
+          }
+        }
+        if (err <= 0) {
+          dy += 1;
+          err += 2 * dy + 1;
+        }
+        if (err > 0) {
+          dx -= 1;
+          err -= 2 * dx + 1;
+        }
+      }
+    }
+  }
+
+  function rectfill(x, y, w, h, color) {
+    rect(x, y, w, h, color, true);
+  }
+
+  function print(text, x, y, color = rgba8(255, 255, 255, 255), scale = 1) {
+    BitmapFont.draw(fb, text, (x | 0) - camRef.x, (y | 0) - camRef.y, color, scale);
+  }
+
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        cls,
+        pset,
+        line,
+        rect,
+        rectfill,
+        circle,
+        print,
+        packRGBA64,
+        rgba8,
+        setCamera,
+        getCamera,
+      });
+    },
+  };
+}
+
+export { packRGBA64, rgba8, unpackRGBA64 };

package/dist/runtime/assets.js

@@ -0,0 +1,27 @@
+// runtime/assets.js
+export class SpriteSheet {
+  constructor(image, width, tileSize = 8) {
+    this.image = image; // HTMLImageElement
+    this.sheetWidth = width;
+    this.tileSize = tileSize;
+    this.cols = Math.floor(width / tileSize);
+  }
+}
+
+export async function loadImageElement(url) {
+  const img = new Image();
+  img.src = url;
+  await img.decode();
+  return img;
+}
+
+export async function loadSpriteSheet(url, tileSize = 8) {
+  const img = await loadImageElement(url);
+  return new SpriteSheet(img, img.naturalWidth, tileSize);
+}
+
+export async function loadTilemap(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error('Failed to load tilemap: ' + url);
+  return await res.json(); // { width, height, data }
+}

package/dist/runtime/audio.js

@@ -0,0 +1,114 @@
+// runtime/audio.js
+export class AudioSystem {
+  constructor() {
+    this.ctx = null;
+    this.master = null;
+    this.channels = 8;
+    this.gains = [];
+  }
+  _ensure() {
+    if (this.ctx) return;
+    const ctx = new (window.AudioContext || window.webkitAudioContext)();
+    this.ctx = ctx;
+    this.master = ctx.createGain();
+    this.master.gain.value = 0.4;
+    this.master.connect(ctx.destination);
+    for (let i = 0; i < this.channels; i++) {
+      const g = ctx.createGain();
+      g.gain.value = 0.0;
+      g.connect(this.master);
+      this.gains.push(g);
+    }
+  }
+  setVolume(v) {
+    this._ensure();
+    this.master.gain.value = Math.max(0, Math.min(1, v));
+  }
+  // sfx({ wave:'square'|'sine'|'sawtooth'|'triangle'|'noise', freq:Hz, dur:sec, vol:0..1, sweep:Hz/sec })
+  sfx(opts = {}) {
+    this._ensure();
+    const ctx = this.ctx;
+    const { wave = 'square', freq = 440, dur = 0.2, vol = 0.5, sweep = 0 } = opts;
+    const g = this.gains[Math.floor(Math.random() * this.channels)];
+    const now = ctx.currentTime;
+    const v = Math.max(0, Math.min(1, vol));
+    g.gain.cancelScheduledValues(now);
+    g.gain.setValueAtTime(0, now);
+    g.gain.linearRampToValueAtTime(v, now + 0.005);
+    g.gain.linearRampToValueAtTime(0.0001, now + dur);
+
+    if (wave === 'noise') {
+      const bufferSize = 1 << 14;
+      const buffer = ctx.createBuffer(1, bufferSize, ctx.sampleRate);
+      const data = buffer.getChannelData(0);
+      for (let i = 0; i < bufferSize; i++) data[i] = Math.random() * 2 - 1;
+      const src = ctx.createBufferSource();
+      src.buffer = buffer;
+      src.connect(g);
+      src.start(now);
+      src.stop(now + dur);
+      return;
+    }
+
+    const osc = ctx.createOscillator();
+    osc.type = wave;
+    osc.frequency.setValueAtTime(freq, now);
+    if (sweep !== 0)
+      osc.frequency.linearRampToValueAtTime(Math.max(1, freq + sweep * dur), now + dur);
+    osc.connect(g);
+    osc.start(now);
+    osc.stop(now + dur);
+  }
+}
+
+export const audio = new AudioSystem();
+
+// Named SFX presets — use sfx('jump'), sfx('coin'), sfx(0), or sfx({wave, freq, ...})
+const SFX_PRESETS = {
+  // Numeric shortcuts (backward compat)
+  0: { wave: 'square', freq: 880, dur: 0.1, vol: 0.4 },
+  1: { wave: 'sine', freq: 220, dur: 0.3, vol: 0.3, sweep: -100 },
+  2: { wave: 'noise', dur: 0.2, vol: 0.3 },
+  // Named presets
+  jump: { wave: 'square', freq: 300, dur: 0.12, vol: 0.4, sweep: 200 },
+  land: { wave: 'noise', dur: 0.08, vol: 0.3 },
+  coin: { wave: 'sine', freq: 1046, dur: 0.15, vol: 0.5, sweep: 400 },
+  powerup: { wave: 'sine', freq: 440, dur: 0.4, vol: 0.5, sweep: 880 },
+  explosion: { wave: 'noise', dur: 0.4, vol: 0.8 },
+  laser: { wave: 'square', freq: 1200, dur: 0.1, vol: 0.4, sweep: -800 },
+  hit: { wave: 'square', freq: 200, dur: 0.15, vol: 0.5, sweep: -100 },
+  death: { wave: 'sawtooth', freq: 440, dur: 0.6, vol: 0.5, sweep: -400 },
+  select: { wave: 'sine', freq: 660, dur: 0.08, vol: 0.3 },
+  confirm: { wave: 'sine', freq: 880, dur: 0.12, vol: 0.3, sweep: 220 },
+  error: { wave: 'square', freq: 180, dur: 0.3, vol: 0.4, sweep: -30 },
+  blip: { wave: 'square', freq: 440, dur: 0.06, vol: 0.3 },
+};
+
+export function audioApi() {
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        /**
+         * Play a sound effect.
+         * @param {number|string|object} idOrOpts - Preset id (0/1/2), preset name ('jump','coin',...), or options object
+         * @param {object} [maybeOpts] - Extra options to merge when using a preset id/name
+         */
+        sfx: (idOrOpts, maybeOpts) => {
+          if (typeof idOrOpts === 'number' || typeof idOrOpts === 'string') {
+            const preset = SFX_PRESETS[idOrOpts];
+            if (preset) {
+              audio.sfx(Object.assign({}, preset, maybeOpts || {}));
+            }
+          } else {
+            audio.sfx(idOrOpts || {});
+          }
+        },
+        /**
+         * Set master volume (0 = silent, 1 = full).
+         * @param {number} v
+         */
+        setVolume: v => audio.setVolume(v),
+      });
+    },
+  };
+}

package/dist/runtime/collision.js

@@ -0,0 +1,47 @@
+// runtime/collision.js
+export function aabb(ax, ay, aw, ah, bx, by, bw, bh) {
+  return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
+}
+export function circle(ax, ay, ar, bx, by, br) {
+  const dx = ax - bx,
+    dy = ay - by;
+  return dx * dx + dy * dy <= (ar + br) * (ar + br);
+}
+
+// DDA raycast against a tilemap; tileFn(tx,ty)->boolean solid
+export function raycastTilemap(x0, y0, dx, dy, maxDist, tileSize, tileFn) {
+  let t = 0;
+  const stepX = Math.sign(dx) || 1;
+  const stepY = Math.sign(dy) || 1;
+  const invDx = dx !== 0 ? 1 / dx : 1e9;
+  const invDy = dy !== 0 ? 1 / dy : 1e9;
+  let tx = Math.floor(x0 / tileSize);
+  let ty = Math.floor(y0 / tileSize);
+  const nextBoundary = (p, dp, s) => {
+    const grid =
+      s > 0 ? (Math.floor(p / tileSize) + 1) * tileSize : Math.floor(p / tileSize) * tileSize;
+    return (grid - p) * (dp !== 0 ? 1 / dp : 1e9);
+  };
+  let tMaxX = nextBoundary(x0, dx, stepX);
+  let tMaxY = nextBoundary(y0, dy, stepY);
+  const tDeltaX = Math.abs(tileSize * invDx);
+  const tDeltaY = Math.abs(tileSize * invDy);
+
+  if (tileFn(tx, ty)) return { hit: true, tx, ty, t: 0, x: x0, y: y0 };
+
+  while (t <= maxDist) {
+    if (tMaxX < tMaxY) {
+      t = tMaxX;
+      tMaxX += tDeltaX;
+      tx += stepX;
+    } else {
+      t = tMaxY;
+      tMaxY += tDeltaY;
+      ty += stepY;
+    }
+    const x = x0 + dx * t;
+    const y = y0 + dy * t;
+    if (tileFn(tx, ty)) return { hit: true, tx, ty, t, x, y };
+  }
+  return { hit: false };
+}

package/dist/runtime/console.js

@@ -0,0 +1,101 @@
+// runtime/console.js
+import { logger } from './logger.js';
+export class Nova64 {
+  constructor(gpu) {
+    this.gpu = gpu;
+    this.cart = null;
+    this._loadGeneration = 0; // Guard against concurrent loadCart race conditions
+  }
+  async loadCart(modulePath) {
+    // Bump generation — any earlier in-flight loadCart will see the mismatch and bail.
+    const gen = ++this._loadGeneration;
+    logger.info(`🧹 Clearing previous scene before loading new cart... (gen=${gen})`);
+
+    // CRITICAL: Null out cart FIRST to prevent old update() from running during transition
+    this.cart = null;
+
+    // Clear UI buttons and panels from previous cart
+    if (typeof globalThis.clearButtons === 'function') {
+      globalThis.clearButtons();
+    }
+    if (typeof globalThis.clearPanels === 'function') {
+      globalThis.clearPanels();
+    }
+
+    // Reset screen manager to clear registered screens from previous cart
+    if (globalThis.screens && typeof globalThis.screens.reset === 'function') {
+      globalThis.screens.reset();
+    }
+
+    // Clear the 3D scene completely before loading new cart
+    if (typeof globalThis.clearScene === 'function') {
+      globalThis.clearScene();
+    }
+
+    // Also clear any skybox
+    if (typeof globalThis.clearSkybox === 'function') {
+      globalThis.clearSkybox();
+    }
+
+    // Reset camera to default position
+    if (typeof globalThis.setCameraPosition === 'function') {
+      globalThis.setCameraPosition(0, 5, 10);
+    }
+    if (typeof globalThis.setCameraTarget === 'function') {
+      globalThis.setCameraTarget(0, 0, 0);
+    }
+
+    // Reset fog to default
+    if (typeof globalThis.setFog === 'function') {
+      globalThis.setFog(0x87ceeb, 50, 200);
+    }
+
+    logger.info('✅ Scene cleared, loading new cart:', modulePath);
+
+    const mod = await import(/* @vite-ignore */ modulePath + '?t=' + Date.now());
+
+    // RACE-CONDITION GUARD: If a newer loadCart was called while we awaited the
+    // import, our generation is stale — abort so only the latest cart initialises.
+    if (gen !== this._loadGeneration) {
+      logger.warn(
+        `⚠️ loadCart(${modulePath}) superseded by a newer load (gen ${gen} vs ${this._loadGeneration}), aborting.`
+      );
+      return;
+    }
+
+    // Clear scene AGAIN right before init — in case a concurrent loadCart
+    // already ran and added its own objects while we were awaiting import.
+    if (typeof globalThis.clearScene === 'function') {
+      globalThis.clearScene();
+    }
+    if (typeof globalThis.clearSkybox === 'function') {
+      globalThis.clearSkybox();
+    }
+    if (typeof globalThis.clearButtons === 'function') {
+      globalThis.clearButtons();
+    }
+    if (typeof globalThis.clearPanels === 'function') {
+      globalThis.clearPanels();
+    }
+
+    this.cart = {
+      init: mod.init || (() => {}),
+      update: mod.update || (() => {}),
+      draw: mod.draw || (() => {}),
+    };
+    try {
+      await this.cart.init();
+      // Final guard: if yet ANOTHER loadCart fired during init, don't keep this cart
+      if (gen !== this._loadGeneration) {
+        logger.warn(
+          `⚠️ loadCart(${modulePath}) superseded during init (gen ${gen} vs ${this._loadGeneration}), aborting.`
+        );
+        this.cart = null;
+        return;
+      }
+      logger.info('✅ Cart init() complete:', modulePath);
+    } catch (e) {
+      logger.error('❌ Cart init() threw:', e.message, e.stack);
+    }
+  }
+}