retroemu 0.1.0

package/src/core/SaveManager.js

@@ -0,0 +1,115 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { RETRO_MEMORY_SAVE_RAM } from '../constants/libretro.js';
+
+export class SaveManager {
+  constructor(saveDir) {
+    this.saveDir = saveDir;
+  }
+
+  async saveSRAM(core, romPath, silent = false) {
+    const dataPtr = core._retro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
+    const size = core._retro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
+    if (!dataPtr || !size) {
+      if (!silent) process.stderr.write(`SRAM save skipped: ptr=${dataPtr}, size=${size}\n`);
+      return;
+    }
+
+    // Debug: write to file since terminal alternate buffer hides output
+    const debugLog = (msg) => fs.appendFile('/tmp/sram-debug.log', msg + '\n').catch(() => {});
+    if (!silent) {
+      await debugLog(`SRAM debug at save time: ptr=${dataPtr}, size=${size}`);
+      // Check entire buffer for any non-zero data
+      let nonZeroRanges = [];
+      let inNonZero = false;
+      let rangeStart = 0;
+      for (let i = 0; i < size; i++) {
+        const val = core.HEAPU8[dataPtr + i];
+        if (val !== 0 && !inNonZero) {
+          inNonZero = true;
+          rangeStart = i;
+        } else if (val === 0 && inNonZero) {
+          inNonZero = false;
+          nonZeroRanges.push(`0x${rangeStart.toString(16)}-0x${(i-1).toString(16)}`);
+        }
+      }
+      if (inNonZero) nonZeroRanges.push(`0x${rangeStart.toString(16)}-0x${(size-1).toString(16)}`);
+      await debugLog(`Non-zero ranges in SRAM: ${nonZeroRanges.length ? nonZeroRanges.join(', ') : 'NONE - all zeros'}`);
+    }
+
+    // Copy the data (not just a view) since WASM memory may change during async write
+    const data = Buffer.from(core.HEAPU8.slice(dataPtr, dataPtr + size));
+    const savePath = this._sramPath(romPath);
+    await fs.mkdir(path.dirname(savePath), { recursive: true });
+    await fs.writeFile(savePath, data);
+
+    // Debug: show first 32 bytes of saved data
+    const preview = Array.from(data.slice(0, 32)).map(b => b.toString(16).padStart(2, '0')).join(' ');
+    if (!silent) await debugLog(`SRAM saved: ${savePath} (${size} bytes)\nSaved data: ${preview}`);
+  }
+
+  async loadSRAM(core, romPath) {
+    const savePath = this._sramPath(romPath);
+    const dataPtr = core._retro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
+    const size = core._retro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
+
+    if (!dataPtr || !size) return;
+
+    try {
+      const data = await fs.readFile(savePath);
+      if (data.length === size) {
+        core.HEAPU8.set(data, dataPtr);
+        process.stderr.write(`SRAM loaded: ${savePath} (${size} bytes)\n`);
+      } else {
+        process.stderr.write(`SRAM size mismatch: file=${data.length}, expected=${size}\n`);
+      }
+    } catch {
+      // No save file - core already initialized SRAM during retro_load_game()
+      process.stderr.write(`SRAM: no existing save, using core defaults\n`);
+    }
+  }
+
+  async saveState(core, romPath, slot = 0) {
+    const size = core._retro_serialize_size();
+    if (!size) return;
+
+    const ptr = core._malloc(size);
+    try {
+      const ok = core._retro_serialize(ptr, size);
+      if (ok) {
+        const data = Buffer.from(core.HEAPU8.buffer, ptr, size);
+        const statePath = this._statePath(romPath, slot);
+        await fs.mkdir(path.dirname(statePath), { recursive: true });
+        await fs.writeFile(statePath, data);
+      }
+    } finally {
+      core._free(ptr);
+    }
+  }
+
+  async loadState(core, romPath, slot = 0) {
+    const statePath = this._statePath(romPath, slot);
+    try {
+      const data = await fs.readFile(statePath);
+      const ptr = core._malloc(data.length);
+      try {
+        core.HEAPU8.set(data, ptr);
+        core._retro_unserialize(ptr, data.length);
+      } finally {
+        core._free(ptr);
+      }
+    } catch {
+      // No state file exists
+    }
+  }
+
+  _sramPath(romPath) {
+    const name = path.basename(romPath, path.extname(romPath));
+    return path.join(this.saveDir, `${name}.srm`);
+  }
+
+  _statePath(romPath, slot) {
+    const name = path.basename(romPath, path.extname(romPath));
+    return path.join(this.saveDir, `${name}.state${slot}`);
+  }
+}

package/src/core/SystemDetector.js

@@ -0,0 +1,122 @@
+import path from 'path';
+
+const EXTENSION_MAP = {
+  // NES
+  '.nes': { system: 'nes', core: 'fceumm' },
+  '.fds': { system: 'nes', core: 'fceumm' },
+  '.unf': { system: 'nes', core: 'fceumm' },
+  '.unif': { system: 'nes', core: 'fceumm' },
+  // SNES
+  '.sfc': { system: 'snes', core: 'snes9x' },
+  '.smc': { system: 'snes', core: 'snes9x' },
+  // GBA
+  '.gba': { system: 'gba', core: 'mgba' },
+  // Game Boy
+  '.gb': { system: 'gb', core: 'gambatte' },
+  // Game Boy Color
+  '.gbc': { system: 'gbc', core: 'gambatte' },
+  // Genesis / Mega Drive
+  '.md': { system: 'genesis', core: 'genesis_plus_gx' },
+  '.gen': { system: 'genesis', core: 'genesis_plus_gx' },
+  '.smd': { system: 'genesis', core: 'genesis_plus_gx' },
+  '.bin': { system: 'genesis', core: 'genesis_plus_gx' },
+  // Sega Master System
+  '.sms': { system: 'sms', core: 'genesis_plus_gx' },
+  // Sega Game Gear
+  '.gg': { system: 'gg', core: 'genesis_plus_gx' },
+  // Sega SG-1000
+  '.sg': { system: 'sg1000', core: 'genesis_plus_gx' },
+  // Atari 2600
+  '.a26': { system: 'atari2600', core: 'stella2014' },
+  // Atari 5200
+  '.a52': { system: 'atari5200', core: 'atari800' },
+  // Atari 8-bit computers (400/800/XL/XE)
+  '.xex': { system: 'atari800', core: 'atari800' },
+  '.atr': { system: 'atari800', core: 'atari800' },
+  '.atx': { system: 'atari800', core: 'atari800' },
+  '.bas': { system: 'atari800', core: 'atari800' },
+  '.car': { system: 'atari800', core: 'atari800' },
+  '.xfd': { system: 'atari800', core: 'atari800' },
+  // Atari 7800
+  '.a78': { system: 'atari7800', core: 'prosystem' },
+  // Atari Lynx
+  '.lnx': { system: 'lynx', core: 'handy' },
+  '.o': { system: 'lynx', core: 'handy' },
+  // TurboGrafx-16 / PC Engine
+  '.pce': { system: 'pce', core: 'beetle_pce_fast' },
+  '.cue': { system: 'pce', core: 'beetle_pce_fast' },
+  '.ccd': { system: 'pce', core: 'beetle_pce_fast' },
+  '.chd': { system: 'pce', core: 'beetle_pce_fast' },
+  // Neo Geo Pocket / Color
+  '.ngp': { system: 'ngp', core: 'mednafen_ngp' },
+  '.ngc': { system: 'ngpc', core: 'mednafen_ngp' },
+  // WonderSwan / Color
+  '.ws': { system: 'wswan', core: 'mednafen_wswan' },
+  '.wsc': { system: 'wswanc', core: 'mednafen_wswan' },
+  // ColecoVision
+  '.col': { system: 'coleco', core: 'gearcoleco' },
+  // Vectrex
+  '.vec': { system: 'vectrex', core: 'vecx' },
+  // ZX Spectrum
+  '.tzx': { system: 'spectrum', core: 'fuse' },
+  '.z80': { system: 'spectrum', core: 'fuse' },
+  '.sna': { system: 'spectrum', core: 'fuse' },
+  // MSX / MSX2
+  '.mx1': { system: 'msx', core: 'fmsx' },
+  '.mx2': { system: 'msx', core: 'fmsx' },
+  '.rom': { system: 'msx', core: 'fmsx' },
+  '.dsk': { system: 'msx', core: 'fmsx' },
+  '.cas': { system: 'msx', core: 'fmsx' },
+  // PlayStation 1
+  '.iso': { system: 'psx', core: 'pcsx_rearmed' },
+  '.pbp': { system: 'psx', core: 'pcsx_rearmed' },
+  '.m3u': { system: 'psx', core: 'pcsx_rearmed' },
+};
+
+const SYSTEM_NAMES = {
+  nes: 'Nintendo Entertainment System',
+  snes: 'Super Nintendo',
+  gba: 'Game Boy Advance',
+  gb: 'Game Boy',
+  gbc: 'Game Boy Color',
+  genesis: 'Sega Genesis / Mega Drive',
+  sms: 'Sega Master System',
+  gg: 'Sega Game Gear',
+  sg1000: 'Sega SG-1000',
+  atari2600: 'Atari 2600',
+  atari5200: 'Atari 5200',
+  atari7800: 'Atari 7800',
+  atari800: 'Atari 800/XL/XE',
+  lynx: 'Atari Lynx',
+  pce: 'TurboGrafx-16 / PC Engine',
+  ngp: 'Neo Geo Pocket',
+  ngpc: 'Neo Geo Pocket Color',
+  wswan: 'WonderSwan',
+  wswanc: 'WonderSwan Color',
+  coleco: 'ColecoVision',
+  vectrex: 'Vectrex',
+  spectrum: 'ZX Spectrum',
+  msx: 'MSX / MSX2',
+  psx: 'PlayStation',
+};
+
+export function detectSystem(romPath) {
+  const ext = path.extname(romPath).toLowerCase();
+  const entry = EXTENSION_MAP[ext];
+  if (!entry) {
+    return null;
+  }
+  return {
+    ...entry,
+    systemName: SYSTEM_NAMES[entry.system],
+    extension: ext,
+  };
+}
+
+export function getSupportedExtensions() {
+  return Object.keys(EXTENSION_MAP);
+}
+
+export function getSystemName(systemId) {
+  return SYSTEM_NAMES[systemId] || systemId;
+}

package/src/input/InputManager.js

@@ -0,0 +1,222 @@
+import { installNavigatorShim } from 'gamepad-node';
+import { appendFileSync } from 'fs';
+import { LIBRETRO_TO_W3C, axisToLibretro } from './InputMap.js';
+import {
+  RETRO_DEVICE_JOYPAD,
+  RETRO_DEVICE_ANALOG,
+  RETRO_DEVICE_INDEX_ANALOG_LEFT,
+  RETRO_DEVICE_INDEX_ANALOG_RIGHT,
+  RETRO_DEVICE_ID_ANALOG_X,
+  RETRO_DEVICE_ID_ANALOG_Y,
+  JOYPAD_MASK,
+} from '../constants/libretro.js';
+
+export class InputManager {
+  constructor(options = {}) {
+    this.disableGamepad = options.disableGamepad || false;
+    this.debugInput = options.debugInput || false;
+    this.manager = this.disableGamepad ? null : installNavigatorShim();
+    this.currentGamepads = [];
+    this._debugLoggedButtons = new Set(); // Avoid spam
+    this._exitComboHeld = 0; // Frames Start+Select held together
+
+    // Keyboard state for players without controllers
+    // Maps button id -> frame number when last pressed
+    this._keyLastPressed = new Map();
+    this._currentFrame = 0;
+    this._keyHoldFrames = 15; // Hold key for 15 frames (~250ms at 60fps)
+    this._setupKeyboard();
+  }
+
+  poll() {
+    this._currentFrame++;
+    if (!this.disableGamepad) {
+      const gamepads = navigator.getGamepads().filter((gp) => gp !== null);
+
+      // Log gamepad info once
+      if (this.debugInput && gamepads.length > 0 && !this._loggedGamepadInfo) {
+        this._loggedGamepadInfo = true;
+        const gp = gamepads[0];
+        appendFileSync('/tmp/emu-input.log', `\n=== Gamepad: ${gp.id} ===\n`);
+        appendFileSync('/tmp/emu-input.log', `Buttons: ${gp.buttons.length}, Axes: ${gp.axes.length}\n`);
+        gp.buttons.forEach((btn, i) => {
+          if (btn.pressed || btn.value > 0.1) {
+            appendFileSync('/tmp/emu-input.log', `  btn[${i}] pressed=${btn.pressed} value=${btn.value}\n`);
+          }
+        });
+        gp.axes.forEach((val, i) => {
+          if (Math.abs(val) > 0.1) {
+            appendFileSync('/tmp/emu-input.log', `  axis[${i}] = ${val}\n`);
+          }
+        });
+      }
+
+      this.currentGamepads = gamepads;
+
+      // Check for Start+Select exit combo (buttons 8 and 9)
+      if (gamepads.length > 0) {
+        const gp = gamepads[0];
+        const startPressed = gp.buttons[9]?.pressed;
+        const selectPressed = gp.buttons[8]?.pressed;
+        if (startPressed && selectPressed) {
+          this._exitComboHeld++;
+          // Exit after ~0.5 seconds (30 frames at 60fps)
+          if (this._exitComboHeld >= 30) {
+            process.emit('SIGINT');
+          }
+        } else {
+          this._exitComboHeld = 0;
+        }
+      }
+    }
+  }
+
+  getState(port, device, index, id) {
+    // Try gamepad first, fall back to keyboard for port 0
+    const gamepad = this.currentGamepads[port];
+
+    if (device === RETRO_DEVICE_JOYPAD) {
+      // Handle bitmask query (all buttons at once)
+      if (id === JOYPAD_MASK) {
+        let mask = 0;
+        for (let btnId = 0; btnId < 16; btnId++) {
+          if (this._getButtonState(gamepad, port, btnId)) {
+            mask |= (1 << btnId);
+          }
+        }
+        return mask;
+      }
+
+      if (id < 0 || id >= 16) return 0;
+      return this._getButtonState(gamepad, port, id) ? 1 : 0;
+    }
+
+    if (device === RETRO_DEVICE_ANALOG && gamepad) {
+      // Analog stick input
+      // index: LEFT=0, RIGHT=1
+      // id: X=0, Y=1
+      let axisIndex;
+      if (index === RETRO_DEVICE_INDEX_ANALOG_LEFT) {
+        axisIndex = id === RETRO_DEVICE_ID_ANALOG_X ? 0 : 1;
+      } else if (index === RETRO_DEVICE_INDEX_ANALOG_RIGHT) {
+        axisIndex = id === RETRO_DEVICE_ID_ANALOG_X ? 2 : 3;
+      } else {
+        return 0;
+      }
+
+      if (axisIndex < gamepad.axes.length) {
+        return axisToLibretro(gamepad.axes[axisIndex]);
+      }
+    }
+
+    return 0;
+  }
+
+  _getButtonState(gamepad, port, id) {
+    // Gamepad input
+    if (gamepad) {
+      const w3cIndex = LIBRETRO_TO_W3C[id];
+      if (w3cIndex >= 0 && w3cIndex < gamepad.buttons.length) {
+        const btn = gamepad.buttons[w3cIndex];
+        if (btn?.pressed) {
+          if (this.debugInput && !this._debugLoggedButtons.has(id)) {
+            appendFileSync('/tmp/emu-input.log', `Button: libretro=${id} w3c=${w3cIndex} value=${btn.value}\n`);
+            this._debugLoggedButtons.add(id);
+          }
+          return true;
+        } else {
+          this._debugLoggedButtons.delete(id);
+        }
+      }
+    }
+
+    // Keyboard fallback for port 0
+    if (port === 0) {
+      const lastPressed = this._keyLastPressed.get(id);
+      if (lastPressed !== undefined && (this._currentFrame - lastPressed) < this._keyHoldFrames) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  _setupKeyboard() {
+    // Default keyboard mapping for port 0 (arrow keys + Z/X/A/S + Enter/Shift)
+    // Maps keyboard key names to libretro joypad IDs
+    const keyMap = {
+      up: 4,       // JOYPAD_UP
+      down: 5,     // JOYPAD_DOWN
+      left: 6,     // JOYPAD_LEFT
+      right: 7,    // JOYPAD_RIGHT
+      z: 0,        // JOYPAD_B (action button)
+      x: 8,        // JOYPAD_A
+      a: 1,        // JOYPAD_Y
+      s: 9,        // JOYPAD_X
+      return: 3,   // JOYPAD_START
+      shift: 2,    // JOYPAD_SELECT
+      q: 10,       // JOYPAD_L
+      w: 11,       // JOYPAD_R
+    };
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+
+      process.stdin.on('data', (key) => {
+        // Ctrl+C to exit
+        if (key === '\u0003') {
+          process.emit('SIGINT');
+          return;
+        }
+
+        // Handle arrow keys (escape sequences)
+        if (key === '\u001b[A') {
+          this._pressKey('up');
+        } else if (key === '\u001b[B') {
+          this._pressKey('down');
+        } else if (key === '\u001b[C') {
+          this._pressKey('right');
+        } else if (key === '\u001b[D') {
+          this._pressKey('left');
+        } else if (key === '\r' || key === '\n') {
+          this._pressKey('return');
+        } else {
+          const lower = key.toLowerCase();
+          if (keyMap[lower] !== undefined) {
+            this._pressKey(lower);
+          }
+        }
+      });
+
+      // Store the key map for lookups
+      this._keyMap = keyMap;
+    }
+  }
+
+  _pressKey(keyName) {
+    const id = this._keyMap[keyName];
+    if (id === undefined) return;
+
+    // Record the frame when this key was pressed
+    // Key will be considered "held" for _keyHoldFrames frames
+    this._keyLastPressed.set(id, this._currentFrame);
+  }
+
+  destroy() {
+    // Clean up gamepad manager
+    if (this.manager && this.manager.destroy) {
+      try {
+        this.manager.destroy();
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+  }
+}

package/src/input/InputMap.js

@@ -0,0 +1,47 @@
+import * as LR from '../constants/libretro.js';
+
+// W3C Standard Gamepad button index → libretro RETRO_DEVICE_ID_JOYPAD_*
+//
+// W3C standard mapping:
+//   0=South(A), 1=East(B), 2=West(X), 3=North(Y),
+//   4=L1, 5=R1, 6=L2, 7=R2,
+//   8=Select, 9=Start, 10=L3, 11=R3,
+//   12=DPad Up, 13=DPad Down, 14=DPad Left, 15=DPad Right, 16=Guide
+//
+// gamepad-node uses positional mapping: South=A, East=B, West=X, North=Y
+// libretro SNES layout: B=South, A=East, Y=West, X=North
+
+export const W3C_TO_LIBRETRO = new Int8Array(17);
+W3C_TO_LIBRETRO[0]  = LR.JOYPAD_B;       // W3C South  → libretro B (south)
+W3C_TO_LIBRETRO[1]  = LR.JOYPAD_A;       // W3C East   → libretro A (east)
+W3C_TO_LIBRETRO[2]  = LR.JOYPAD_Y;       // W3C West   → libretro Y (west)
+W3C_TO_LIBRETRO[3]  = LR.JOYPAD_X;       // W3C North  → libretro X (north)
+W3C_TO_LIBRETRO[4]  = LR.JOYPAD_L;       // W3C L1     → libretro L
+W3C_TO_LIBRETRO[5]  = LR.JOYPAD_R;       // W3C R1     → libretro R
+W3C_TO_LIBRETRO[6]  = LR.JOYPAD_L2;      // W3C L2     → libretro L2
+W3C_TO_LIBRETRO[7]  = LR.JOYPAD_R2;      // W3C R2     → libretro R2
+W3C_TO_LIBRETRO[8]  = LR.JOYPAD_SELECT;  // W3C Select → libretro Select
+W3C_TO_LIBRETRO[9]  = LR.JOYPAD_START;   // W3C Start  → libretro Start
+W3C_TO_LIBRETRO[10] = LR.JOYPAD_L3;      // W3C L3     → libretro L3
+W3C_TO_LIBRETRO[11] = LR.JOYPAD_R3;      // W3C R3     → libretro R3
+W3C_TO_LIBRETRO[12] = LR.JOYPAD_UP;      // W3C DUp    → libretro Up
+W3C_TO_LIBRETRO[13] = LR.JOYPAD_DOWN;    // W3C DDown  → libretro Down
+W3C_TO_LIBRETRO[14] = LR.JOYPAD_LEFT;    // W3C DLeft  → libretro Left
+W3C_TO_LIBRETRO[15] = LR.JOYPAD_RIGHT;   // W3C DRight → libretro Right
+W3C_TO_LIBRETRO[16] = -1;                // W3C Guide  → unmapped
+
+// Reverse map: libretro joypad ID → W3C button index
+export const LIBRETRO_TO_W3C = new Int8Array(16);
+for (let w3c = 0; w3c < 16; w3c++) {
+  const lr = W3C_TO_LIBRETRO[w3c];
+  if (lr >= 0 && lr < 16) {
+    LIBRETRO_TO_W3C[lr] = w3c;
+  }
+}
+
+// W3C analog axes: 0=leftX, 1=leftY, 2=rightX, 3=rightY
+// Libretro analog: index=LEFT/RIGHT, id=X/Y
+// Convert W3C axis float (-1..1) to libretro int16 (-32768..32767)
+export function axisToLibretro(value) {
+  return Math.round(Math.max(-1, Math.min(1, value)) * 32767);
+}