nova64 0.2.6 → 0.2.7

package/dist/runtime/input.js

@@ -0,0 +1,225 @@
+// runtime/input.js
+// Gamepad button mapping (standard gamepad layout)
+const GAMEPAD_BUTTONS = {
+  0: 12, // A button → Start (button 12)
+  1: 13, // B button → Select (button 13)
+  2: 4, // X button → button 4
+  3: 5, // Y button → button 5
+  4: 6, // LB → button 6
+  5: 7, // RB → button 7
+  6: 8, // LT → button 8
+  7: 9, // RT → button 9
+  8: 13, // Select → button 13
+  9: 12, // Start → button 12
+  12: 0, // D-pad Up → button 0
+  13: 3, // D-pad Down → button 3
+  14: 1, // D-pad Left → button 1
+  15: 2, // D-pad Right → button 2
+};
+
+const KEYMAP = {
+  // arrows + Z X C V
+  0: 'ArrowLeft', // left
+  1: 'ArrowRight', // right
+  2: 'ArrowUp', // up
+  3: 'ArrowDown', // down
+  4: 'KeyZ',
+  5: 'KeyX',
+  6: 'KeyC',
+  7: 'KeyV',
+  8: 'KeyA',
+  9: 'KeyS',
+  10: 'KeyQ',
+  11: 'KeyW',
+  12: 'Enter', // Start
+  13: 'Space', // Select/Action
+};
+
+class Input {
+  constructor() {
+    this.keys = new Map();
+    this.prev = new Map();
+    this.mouse = { x: 0, y: 0, down: false, prevDown: false };
+    this.uiCallbacks = { setMousePosition: null, setMouseButton: null };
+
+    // Gamepad state
+    this.gamepadButtons = new Map();
+    this.gamepadPrev = new Map();
+    this.gamepadAxes = { leftX: 0, leftY: 0, rightX: 0, rightY: 0 };
+    this.gamepadDeadzone = 0.15;
+
+    if (typeof window !== 'undefined') {
+      window.addEventListener('keydown', e => {
+        this.keys.set(e.code, true);
+      });
+      window.addEventListener('keyup', e => {
+        this.keys.set(e.code, false);
+      });
+      window.addEventListener('blur', () => {
+        this.keys.clear();
+      });
+
+      // Mouse event listeners
+      window.addEventListener('mousemove', e => {
+        const canvas = document.querySelector('canvas');
+        if (canvas) {
+          const rect = canvas.getBoundingClientRect();
+          // Scale mouse position to Nova64's 640x360 resolution
+          this.mouse.x = Math.floor(((e.clientX - rect.left) / rect.width) * 640);
+          this.mouse.y = Math.floor(((e.clientY - rect.top) / rect.height) * 360);
+
+          // Update UI system if connected
+          if (this.uiCallbacks.setMousePosition) {
+            this.uiCallbacks.setMousePosition(this.mouse.x, this.mouse.y);
+          }
+        }
+      });
+
+      window.addEventListener('mousedown', _e => {
+        this.mouse.down = true;
+        if (this.uiCallbacks.setMouseButton) {
+          this.uiCallbacks.setMouseButton(true);
+        }
+      });
+
+      window.addEventListener('mouseup', _e => {
+        this.mouse.down = false;
+        if (this.uiCallbacks.setMouseButton) {
+          this.uiCallbacks.setMouseButton(false);
+        }
+      });
+
+      // Gamepad connection events
+      window.addEventListener('gamepadconnected', _e => {
+        // Gamepad connected
+      });
+
+      window.addEventListener('gamepaddisconnected', _e => {
+        this.gamepadButtons.clear();
+        this.gamepadPrev.clear();
+      });
+    }
+  }
+
+  pollGamepad() {
+    const gamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    const gamepad = gamepads[0]; // Use first connected gamepad
+
+    if (gamepad) {
+      // Read button states
+      gamepad.buttons.forEach((button, index) => {
+        const mappedButton = GAMEPAD_BUTTONS[index];
+        if (mappedButton !== undefined) {
+          this.gamepadButtons.set(mappedButton, button.pressed);
+        }
+      });
+
+      // Read axes with deadzone
+      if (gamepad.axes.length >= 4) {
+        this.gamepadAxes.leftX =
+          Math.abs(gamepad.axes[0]) > this.gamepadDeadzone ? gamepad.axes[0] : 0;
+        this.gamepadAxes.leftY =
+          Math.abs(gamepad.axes[1]) > this.gamepadDeadzone ? gamepad.axes[1] : 0;
+        this.gamepadAxes.rightX =
+          Math.abs(gamepad.axes[2]) > this.gamepadDeadzone ? gamepad.axes[2] : 0;
+        this.gamepadAxes.rightY =
+          Math.abs(gamepad.axes[3]) > this.gamepadDeadzone ? gamepad.axes[3] : 0;
+      }
+    }
+  }
+
+  // Connect UI system callbacks
+  connectUI(setMousePosition, setMouseButton) {
+    this.uiCallbacks.setMousePosition = setMousePosition;
+    this.uiCallbacks.setMouseButton = setMouseButton;
+  }
+  step() {
+    this.prev = new Map(this.keys);
+    this.mouse.prevDown = this.mouse.down;
+    this.gamepadPrev = new Map(this.gamepadButtons);
+    this.pollGamepad(); // Poll gamepad state every frame
+  }
+  btn(i) {
+    // Check keyboard OR gamepad
+    return !!this.keys.get(KEYMAP[i | 0] || '') || !!this.gamepadButtons.get(i | 0);
+  }
+  btnp(i) {
+    const code = KEYMAP[i | 0] || '';
+    const keyPressed = !!this.keys.get(code) && !this.prev.get(code);
+    const gamepadPressed = !!this.gamepadButtons.get(i | 0) && !this.gamepadPrev.get(i | 0);
+    return keyPressed || gamepadPressed;
+  }
+  key(code) {
+    return !!this.keys.get(code);
+  } // Direct key code checking — is currently held
+  keyp(code) {
+    return !!this.keys.get(code) && !this.prev.get(code);
+  } // just-pressed this frame
+
+  // Gamepad-specific functions
+  getGamepadAxis(axisName) {
+    return this.gamepadAxes[axisName] || 0;
+  }
+
+  isGamepadConnected() {
+    const gamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    return gamepads[0] !== null && gamepads[0] !== undefined;
+  }
+
+  // Helper functions for easier key checking
+  isKeyDown(keyCode) {
+    // Space must be checked before single-char conversion (' ' → 'Key ' is wrong)
+    if (keyCode === ' ') keyCode = 'Space';
+    // Handle single character keys by converting to KeyCode format
+    if (keyCode.length === 1) {
+      keyCode = 'Key' + keyCode.toUpperCase();
+    }
+    return !!this.keys.get(keyCode);
+  }
+
+  isKeyPressed(keyCode) {
+    // Space must be checked before single-char conversion (' ' → 'Key ' is wrong)
+    if (keyCode === ' ') keyCode = 'Space';
+    // Handle single character keys by converting to KeyCode format
+    if (keyCode.length === 1) {
+      keyCode = 'Key' + keyCode.toUpperCase();
+    }
+    return !!this.keys.get(keyCode) && !this.prev.get(keyCode);
+  }
+}
+
+export const input = new Input();
+
+export function inputApi() {
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        btn: i => input.btn(i),
+        btnp: i => input.btnp(i),
+        key: code => input.key(code),
+        keyp: code => input.keyp(code),
+        isKeyDown: code => input.isKeyDown(code),
+        isKeyPressed: code => input.isKeyPressed(code),
+        // Mouse functions
+        mouseX: () => input.mouse.x,
+        mouseY: () => input.mouse.y,
+        mouseDown: () => input.mouse.down,
+        mousePressed: () => input.mouse.down && !input.mouse.prevDown,
+        // Gamepad functions
+        gamepadAxis: axisName => input.getGamepadAxis(axisName),
+        gamepadConnected: () => input.isGamepadConnected(),
+        // Axis aliases for convenience
+        leftStickX: () => input.getGamepadAxis('leftX'),
+        leftStickY: () => input.getGamepadAxis('leftY'),
+        rightStickX: () => input.getGamepadAxis('rightX'),
+        rightStickY: () => input.getGamepadAxis('rightY'),
+      });
+    },
+    step() {
+      input.step();
+    },
+    connectUI(setMousePosition, setMouseButton) {
+      input.connectUI(setMousePosition, setMouseButton);
+    },
+  };
+}

package/dist/runtime/logger.js

@@ -0,0 +1,60 @@
+// runtime/logger.js
+// Configurable logging system for Nova64.
+// Replaces scattered console.log calls with leveled, history-tracked output.
+// In production builds the level is automatically raised to WARN.
+
+export const LogLevel = Object.freeze({ DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 });
+
+class Logger {
+  constructor(initialLevel = LogLevel.INFO) {
+    this.level = initialLevel;
+    this.history = [];
+    this.maxHistory = 200;
+  }
+
+  _record(level, args) {
+    this.history.push({ level, args, ts: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+  }
+
+  debug(...args) {
+    if (this.level > LogLevel.DEBUG) return;
+    console.log('[Nova64:DEBUG]', ...args);
+    this._record('DEBUG', args);
+  }
+
+  info(...args) {
+    if (this.level > LogLevel.INFO) return;
+    console.log('[Nova64:INFO]', ...args);
+    this._record('INFO', args);
+  }
+
+  warn(...args) {
+    if (this.level > LogLevel.WARN) return;
+    console.warn('[Nova64:WARN]', ...args);
+    this._record('WARN', args);
+  }
+
+  error(...args) {
+    if (this.level > LogLevel.ERROR) return;
+    console.error('[Nova64:ERROR]', ...args);
+    this._record('ERROR', args);
+  }
+
+  setLevel(level) {
+    this.level = level;
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  clearHistory() {
+    this.history = [];
+  }
+}
+
+export const logger = new Logger(
+  // Raise to WARN in production so debug noise is suppressed
+  typeof import.meta !== 'undefined' && import.meta.env && import.meta.env.PROD
+    ? LogLevel.WARN
+    : LogLevel.INFO
+);

package/dist/runtime/physics.js

@@ -0,0 +1,101 @@
+// runtime/physics.js
+
+export function physicsApi() {
+  const bodies = new Set();
+  let gravity = 500; // px/s^2
+  let tileSize = 8;
+  let solidFn = (_tx, _ty) => false;
+
+  function setGravity(g) {
+    gravity = g;
+  }
+  function setTileSize(ts) {
+    tileSize = ts | 0;
+  }
+  function setTileSolidFn(fn) {
+    solidFn = fn;
+  }
+  const setCollisionMap = setTileSolidFn; // friendlier alias
+
+  function createBody(x, y, w, h, opts = {}) {
+    const b = Object.assign(
+      { x, y, w, h, vx: 0, vy: 0, restitution: 0, friction: 0.9, onGround: false },
+      opts
+    );
+    bodies.add(b);
+    return b;
+  }
+  function destroyBody(b) {
+    bodies.delete(b);
+  }
+
+  function _sweepAABB(b, dt) {
+    // Integrate velocity
+    b.vy += gravity * dt;
+    let nx = b.x + b.vx * dt;
+    let ny = b.y + b.vy * dt;
+    b.onGround = false;
+
+    // Resolve X axis
+    const xdir = Math.sign(b.vx);
+    if (xdir !== 0) {
+      const ahead = xdir > 0 ? nx + b.w : nx;
+      const top = Math.floor(b.y / tileSize);
+      const bottom = Math.floor((b.y + b.h - 1) / tileSize);
+      for (let ty = top; ty <= bottom; ty++) {
+        const tx = Math.floor(ahead / tileSize);
+        if (solidFn(tx, ty)) {
+          if (xdir > 0) nx = tx * tileSize - b.w - 0.01;
+          else nx = (tx + 1) * tileSize + 0.01;
+          b.vx = -b.vx * b.restitution;
+          break;
+        }
+      }
+    }
+
+    // Resolve Y axis
+    const ydir = Math.sign(b.vy);
+    if (ydir !== 0) {
+      const ahead = ydir > 0 ? ny + b.h : ny;
+      const left = Math.floor(nx / tileSize);
+      const right = Math.floor((nx + b.w - 1) / tileSize);
+      for (let tx = left; tx <= right; tx++) {
+        const ty = Math.floor(ahead / tileSize);
+        if (solidFn(tx, ty)) {
+          if (ydir > 0) {
+            ny = ty * tileSize - b.h - 0.01;
+            b.onGround = true;
+          } else {
+            ny = (ty + 1) * tileSize + 0.01;
+          }
+          b.vy = -b.vy * b.restitution;
+          break;
+        }
+      }
+    }
+
+    // Friction on ground
+    if (b.onGround) b.vx *= b.friction;
+
+    b.x = nx;
+    b.y = ny;
+  }
+
+  function step(dt) {
+    for (const b of bodies) _sweepAABB(b, dt);
+  }
+
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        createBody,
+        destroyBody,
+        stepPhysics: step,
+        setGravity,
+        setTileSize,
+        setTileSolidFn,
+        setCollisionMap,
+      });
+    },
+  };
+}

package/dist/runtime/screens.js

@@ -0,0 +1,213 @@
+// runtime/screens.js
+// Nova64 Screen Management System
+// Screen state machine with animated transitions (fade, slide-left, slide-right, wipe)
+import { logger } from './logger.js';
+
+export class ScreenManager {
+  constructor() {
+    this.screens = new Map();
+    this.currentScreen = null;
+    this.defaultScreen = null;
+    // Transition state
+    this._tr = null; // { type, progress, duration, fromName, toName, data, onEnd }
+  }
+
+  addScreen(name, screenDefinition) {
+    if (typeof screenDefinition === 'function') {
+      const Cls = screenDefinition;
+      this.screens.set(name, new Cls());
+    } else {
+      this.screens.set(name, screenDefinition);
+    }
+    if (!this.defaultScreen) this.defaultScreen = name;
+    return this;
+  }
+
+  // Immediate switch (no animation)
+  switchTo(screenName, data = {}) {
+    const screen = this.screens.get(screenName);
+    if (!screen) {
+      logger.warn("Screen '" + screenName + "' not found");
+      return false;
+    }
+    if (this.currentScreen) {
+      const c = this.screens.get(this.currentScreen);
+      if (c && typeof c.exit === 'function') c.exit();
+    }
+    this.currentScreen = screenName;
+    if (typeof screen.enter === 'function') screen.enter(data);
+    return true;
+  }
+
+  // Animated transition
+  // type: 'fade' | 'slide-left' | 'slide-right' | 'wipe' | 'instant'
+  transitionTo(screenName, type = 'fade', duration = 0.4, data = {}) {
+    if (this._tr && this._tr.active) return;
+    const toScreen = this.screens.get(screenName);
+    if (!toScreen) {
+      logger.warn("Screen '" + screenName + "' not found");
+      return;
+    }
+    this._tr = {
+      active: true,
+      type,
+      duration,
+      progress: 0,
+      fromName: this.currentScreen,
+      toName: screenName,
+      data,
+      onEnd: null,
+    };
+    if (typeof toScreen.enter === 'function') toScreen.enter(data);
+  }
+
+  onTransitionEnd(cb) {
+    if (this._tr) this._tr.onEnd = cb;
+  }
+
+  start(screenName = null) {
+    this.switchTo(screenName || this.defaultScreen);
+  }
+
+  update(dt) {
+    if (this._tr && this._tr.active) {
+      this._tr.progress += dt / this._tr.duration;
+      if (this._tr.progress >= 1) {
+        this._tr.progress = 1;
+        this._finishTransition();
+      }
+      const from = this._tr && this._tr.fromName ? this.screens.get(this._tr.fromName) : null;
+      const to = this._tr ? this.screens.get(this._tr.toName) : null;
+      if (from && typeof from.update === 'function') from.update(dt);
+      if (to && typeof to.update === 'function') to.update(dt);
+      return;
+    }
+    if (this.currentScreen) {
+      const s = this.screens.get(this.currentScreen);
+      if (s && typeof s.update === 'function') s.update(dt);
+    }
+  }
+
+  _finishTransition() {
+    const tr = this._tr;
+    if (tr.fromName) {
+      const old = this.screens.get(tr.fromName);
+      if (old && typeof old.exit === 'function') old.exit();
+    }
+    this.currentScreen = tr.toName;
+    this._tr = null;
+    if (typeof tr.onEnd === 'function') tr.onEnd();
+  }
+
+  draw() {
+    if (this._tr && this._tr.active) {
+      this._drawTransition();
+      return;
+    }
+    if (this.currentScreen) {
+      const s = this.screens.get(this.currentScreen);
+      if (s && typeof s.draw === 'function') s.draw();
+    }
+  }
+
+  _drawTransition() {
+    const { type, progress, fromName, toName } = this._tr;
+    const from = fromName ? this.screens.get(fromName) : null;
+    const to = this.screens.get(toName);
+    const t = Math.max(0, Math.min(1, progress));
+    const e = t * t * (3 - 2 * t); // smoothstep
+
+    if (type === 'fade') {
+      // Cross-fade via black
+      const midBlack = t < 0.5 ? Math.round(e * 510) : 0;
+      if (t < 0.5) {
+        if (from && typeof from.draw === 'function') from.draw();
+        if (midBlack > 0 && typeof globalThis.rect === 'function')
+          globalThis.rect(0, 0, 640, 360, globalThis.rgba8(0, 0, 0, Math.min(255, midBlack)), true);
+      } else {
+        if (to && typeof to.draw === 'function') to.draw();
+        const fadeIn = Math.round((1 - e) * 510);
+        if (fadeIn > 0 && typeof globalThis.rect === 'function')
+          globalThis.rect(0, 0, 640, 360, globalThis.rgba8(0, 0, 0, Math.min(255, fadeIn)), true);
+      }
+    } else if (type === 'slide-left' || type === 'slide-right') {
+      const dir = type === 'slide-left' ? -1 : 1;
+      const off = Math.round(e * 640);
+      const setC = typeof globalThis.setCamera === 'function' ? globalThis.setCamera : null;
+      if (from && typeof from.draw === 'function') {
+        if (setC) setC(dir * off, 0);
+        from.draw();
+      }
+      if (to && typeof to.draw === 'function') {
+        if (setC) setC(dir * off - dir * 640, 0);
+        to.draw();
+      }
+      if (setC) setC(0, 0);
+    } else if (type === 'wipe') {
+      if (to && typeof to.draw === 'function') to.draw();
+      if (from && typeof from.draw === 'function') {
+        const wipeX = Math.round(e * 640);
+        if (typeof globalThis.setCamera === 'function') globalThis.setCamera(wipeX, 0);
+        from.draw();
+        if (typeof globalThis.setCamera === 'function') globalThis.setCamera(0, 0);
+      }
+    } else {
+      if (to && typeof to.draw === 'function') to.draw();
+    }
+  }
+
+  getCurrentScreen() {
+    return this.currentScreen;
+  }
+  getCurrentScreenObject() {
+    return this.currentScreen ? this.screens.get(this.currentScreen) : null;
+  }
+  isTransitioning() {
+    return !!(this._tr && this._tr.active);
+  }
+
+  reset() {
+    if (this.currentScreen) {
+      const s = this.screens.get(this.currentScreen);
+      if (s && typeof s.exit === 'function') s.exit();
+    }
+    this.screens = new Map();
+    this.currentScreen = null;
+    this.defaultScreen = null;
+    this._tr = null;
+  }
+}
+
+// Base Screen class for class-based patterns
+export class Screen {
+  constructor() {
+    this.data = {};
+  }
+  enter(data = {}) {
+    this.data = { ...this.data, ...data };
+  }
+  exit() {}
+  update(_dt) {}
+  draw() {}
+}
+
+// Factory
+export function screenApi() {
+  const manager = new ScreenManager();
+  return {
+    manager,
+    exposeTo(target) {
+      target.ScreenManager = ScreenManager;
+      target.Screen = Screen;
+      target.screens = manager;
+      target.addScreen = (name, def) => manager.addScreen(name, def);
+      target.switchToScreen = (name, data) => manager.switchTo(name, data);
+      target.switchScreen = (name, data) => manager.switchTo(name, data);
+      target.transitionTo = (name, type, dur, data) => manager.transitionTo(name, type, dur, data);
+      target.onTransitionEnd = cb => manager.onTransitionEnd(cb);
+      target.isTransitioning = () => manager.isTransitioning();
+      target.getCurrentScreen = () => manager.getCurrentScreen();
+      target.startScreens = initial => manager.start(initial);
+    },
+  };
+}

package/dist/runtime/storage.js

@@ -0,0 +1,38 @@
+// runtime/storage.js
+export function storageApi(namespace = 'nova64') {
+  function _k(k) {
+    return namespace + ':' + k;
+  }
+  function saveJSON(key, obj) {
+    try {
+      localStorage.setItem(_k(key), JSON.stringify(obj));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function loadJSON(key, fallback = null) {
+    try {
+      const s = localStorage.getItem(_k(key));
+      return s ? JSON.parse(s) : fallback;
+    } catch (e) {
+      return fallback;
+    }
+  }
+  function remove(key) {
+    try {
+      localStorage.removeItem(_k(key));
+    } catch (e) {
+      /* ignore */
+    }
+  }
+  // Canonical names match docs (saveData/loadData) — saveJSON/loadJSON kept as aliases
+  const saveData = saveJSON;
+  const loadData = loadJSON;
+  const deleteData = remove;
+  return {
+    exposeTo(target) {
+      Object.assign(target, { saveData, loadData, deleteData, saveJSON, loadJSON, remove });
+    },
+  };
+}