nova64 0.2.1

package/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/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/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 });
+    },
+  };
+}

package/runtime/store.js

@@ -0,0 +1,151 @@
+// runtime/store.js
+// Zustand-powered reactive game state for Nova64 carts
+import { logger } from './logger.js';
+// Usage from any cart:
+//   const store = createGameStore({ hp: 100, score: 0 });
+//   store.setState({ score: store.getState().score + 10 });
+//   store.subscribe(state => logger.debug('score changed:', state.score));
+//
+// The built-in novaStore is a global singleton all carts can read/write:
+//   novaStore.setState({ level: 2 });
+//   const { score, lives } = novaStore.getState();
+
+let _createStore;
+
+// Try to use real Zustand vanilla, fall back to a compatible hand-rolled version
+// so the file works even before `npm install` resolves.
+async function _loadZustand() {
+  try {
+    const mod = await import('zustand/vanilla');
+    _createStore = mod.createStore;
+    logger.info('✅ Nova64 Store: using Zustand/vanilla');
+  } catch {
+    // Hand-rolled Zustand-compatible store (same API surface)
+    _createStore = function createStorePolyfill(initializer) {
+      let state;
+      const listeners = new Set();
+
+      const setState = (partial, replace = false) => {
+        const next = typeof partial === 'function' ? partial(state) : partial;
+        const nextState = replace ? next : Object.assign({}, state, next);
+        if (nextState !== state) {
+          const prev = state;
+          state = nextState;
+          listeners.forEach(l => l(state, prev));
+        }
+      };
+
+      const getState = () => state;
+
+      const subscribe = listener => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      };
+
+      const destroy = () => listeners.clear();
+
+      const api = { setState, getState, subscribe, destroy };
+      state =
+        typeof initializer === 'function' ? initializer(setState, getState, api) : initializer;
+      return api;
+    };
+    logger.info(
+      'ℹ️ Nova64 Store: using built-in store polyfill (run pnpm install to enable Zustand)'
+    );
+  }
+}
+
+// Pre-initialize synchronously with polyfill so stores work immediately,
+// then swap to real Zustand if available — existing stores keep their state.
+_createStore = function createStorePolyfill(initializer) {
+  let state;
+  const listeners = new Set();
+
+  const setState = (partial, replace = false) => {
+    const next = typeof partial === 'function' ? partial(state) : partial;
+    const nextState = replace ? next : Object.assign({}, state, next);
+    if (nextState !== state) {
+      const prev = state;
+      state = nextState;
+      listeners.forEach(l => l(state, prev));
+    }
+  };
+
+  const getState = () => state;
+  const subscribe = listener => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => listeners.clear();
+
+  const api = { setState, getState, subscribe, destroy };
+  state =
+    typeof initializer === 'function' ? initializer(setState, getState, api) : initializer || {};
+  return api;
+};
+
+// Attempt to upgrade to real Zustand asynchronously
+_loadZustand();
+
+/**
+ * createGameStore(initialState) → store
+ * Creates a new reactive store for a cart.
+ * Identical to Zustand vanilla's createStore.
+ *
+ * @param {object|function} initialState  Plain object or Zustand initializer fn
+ * @returns {{ getState, setState, subscribe, destroy }}
+ */
+export function createGameStore(initialState) {
+  return _createStore(initialState);
+}
+
+/**
+ * novaStore — built-in singleton store, auto-ticked by the main loop.
+ * All carts can read/write without any setup.
+ *
+ * getState() returns:
+ *   { gameState, score, lives, level, time, paused, playerX, playerY }
+ */
+export const novaStore = _createStore({
+  gameState: 'start', // 'start' | 'playing' | 'paused' | 'gameover' | 'win'
+  score: 0,
+  lives: 3,
+  level: 1,
+  time: 0,
+  paused: false,
+  playerX: 0,
+  playerY: 0,
+});
+
+export function storeApi() {
+  return {
+    exposeTo(target) {
+      target.createGameStore = createGameStore;
+      target.novaStore = novaStore;
+    },
+
+    // Called by main loop each frame to increment global time
+    tick(dt) {
+      const s = novaStore.getState();
+      if (!s.paused) {
+        novaStore.setState({ time: s.time + dt });
+      }
+    },
+
+    reset() {
+      novaStore.setState(
+        {
+          gameState: 'start',
+          score: 0,
+          lives: 3,
+          level: 1,
+          time: 0,
+          paused: false,
+          playerX: 0,
+          playerY: 0,
+        },
+        /*replace=*/ true
+      );
+    },
+  };
+}

package/runtime/textinput.js

@@ -0,0 +1,68 @@
+// runtime/textinput.js
+class TextInput {
+  constructor() {
+    this.active = false;
+    this.value = '';
+    this.maxLen = 128;
+    this.placeholder = '';
+    this._build();
+  }
+  _build() {
+    const el = document.createElement('input');
+    el.type = 'text';
+    el.autocomplete = 'off';
+    el.spellcheck = false;
+    el.style.position = 'fixed';
+    el.style.left = '50%';
+    el.style.top = '10px';
+    el.style.transform = 'translateX(-50%)';
+    el.style.zIndex = '9998';
+    el.style.fontSize = '14px';
+    el.style.padding = '6px 10px';
+    el.style.borderRadius = '8px';
+    el.style.border = '1px solid #2a324a';
+    el.style.background = '#202538';
+    el.style.color = '#dcdfe4';
+    el.style.display = 'none';
+    document.body.appendChild(el);
+    el.addEventListener('input', () => {
+      if (el.value.length > this.maxLen) el.value = el.value.slice(0, this.maxLen);
+      this.value = el.value;
+    });
+    this.el = el;
+  }
+  start(opts = {}) {
+    this.active = true;
+    this.value = opts.value || '';
+    this.maxLen = opts.maxLen || 128;
+    this.placeholder = opts.placeholder || '';
+    this.el.placeholder = this.placeholder;
+    this.el.value = this.value;
+    this.el.style.display = 'block';
+    this.el.focus();
+    this.el.selectionStart = this.el.selectionEnd = this.el.value.length;
+  }
+  stop() {
+    this.active = false;
+    this.el.style.display = 'none';
+    this.el.blur();
+    return this.value;
+  }
+  get() {
+    return this.value;
+  }
+}
+
+const input = new TextInput();
+
+export function textInputApi() {
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        startTextInput: opts => input.start(opts || {}),
+        stopTextInput: () => input.stop(),
+        getTextInput: () => input.get(),
+      });
+    },
+  };
+}

package/runtime/ui/buttons.js

@@ -0,0 +1,124 @@
+// runtime/ui/buttons.js
+// Button creation, update, and rendering
+
+/**
+ * @param {{ g: object, colors: object, buttons: Array, mouse: { x:number, y:number, down:boolean, pressed:boolean },
+ *           state: object, drawText: Function, setTextAlign: Function, setTextBaseline: Function }} ctx
+ */
+export function uiButtonsModule({
+  g,
+  colors,
+  buttons,
+  mouse,
+  state,
+  drawText,
+  setTextAlign,
+  setTextBaseline,
+}) {
+  function createButton(x, y, width, height, text, callback, options = {}) {
+    const button = {
+      id: `button_${Date.now()}_${Math.random()}`,
+      x,
+      y,
+      width,
+      height,
+      text,
+      callback,
+      enabled: options.enabled !== undefined ? options.enabled : true,
+      visible: options.visible !== undefined ? options.visible : true,
+      normalColor: options.normalColor || colors.primary,
+      hoverColor: options.hoverColor || g.rgba8(50, 150, 255, 255),
+      pressedColor: options.pressedColor || g.rgba8(0, 80, 200, 255),
+      disabledColor: options.disabledColor || g.rgba8(100, 100, 100, 255),
+      textColor: options.textColor || colors.white,
+      borderColor: options.borderColor || colors.white,
+      borderWidth: options.borderWidth !== undefined ? options.borderWidth : 2,
+      hovered: false,
+      pressed: false,
+      rounded: options.rounded || false,
+      icon: options.icon || null,
+    };
+    buttons.push(button);
+    return button;
+  }
+
+  function updateButton(button) {
+    if (!button.enabled || !button.visible) {
+      button.hovered = false;
+      button.pressed = false;
+      return false;
+    }
+    const over =
+      mouse.x >= button.x &&
+      mouse.x <= button.x + button.width &&
+      mouse.y >= button.y &&
+      mouse.y <= button.y + button.height;
+    button.hovered = over;
+    button.pressed = over && mouse.down;
+    if (over && mouse.pressed) {
+      if (button.callback) button.callback();
+      return true;
+    }
+    return false;
+  }
+
+  function drawButton(button) {
+    if (!button.visible) return;
+    const { x, y, width, height } = button;
+    let bgColor = button.normalColor;
+    if (!button.enabled) bgColor = button.disabledColor;
+    else if (button.pressed) bgColor = button.pressedColor;
+    else if (button.hovered) bgColor = button.hoverColor;
+
+    g.rect(x, y, width, height, bgColor, true);
+
+    if (button.borderWidth > 0) {
+      const bCol = button.hovered ? button.hoverColor : button.borderColor;
+      for (let i = 0; i < button.borderWidth; i++) {
+        g.rect(x + i, y + i, width - i * 2, height - i * 2, bCol, false);
+      }
+    }
+
+    if (button.pressed)
+      g.rect(x + 2, y + 2, width - 4, height - 4, g.rgba8(255, 255, 255, 50), true);
+
+    const oldAlign = state.textAlign;
+    const oldBaseline = state.textBaseline;
+    setTextAlign('center');
+    setTextBaseline('middle');
+    const textY = button.pressed ? y + height / 2 + 1 : y + height / 2;
+    drawText(button.text, x + width / 2, textY, button.textColor, 1);
+    setTextAlign(oldAlign);
+    setTextBaseline(oldBaseline);
+  }
+
+  function updateAllButtons() {
+    let anyClicked = false;
+    buttons.forEach(b => {
+      if (updateButton(b)) anyClicked = true;
+    });
+    mouse.pressed = false; // consume click after all buttons have seen it
+    return anyClicked;
+  }
+
+  function drawAllButtons() {
+    buttons.forEach(b => drawButton(b));
+  }
+  function removeButton(b) {
+    const i = buttons.indexOf(b);
+    if (i >= 0) buttons.splice(i, 1);
+  }
+  function clearButtons() {
+    buttons.length = 0;
+  }
+
+  return {
+    createButton,
+    updateButton,
+    drawButton,
+    updateAllButtons,
+    drawAllButtons,
+    removeButton,
+    clearButtons,
+  };
+}