emoemu 0.1.0

package/src/cli/runEmulator/index.ts

@@ -0,0 +1,406 @@
+import { existsSync, readFileSync } from 'fs';
+import { basename, extname, join } from 'path';
+import { Emulator } from '../../Emulator';
+import {
+  getSupportedExtensions,
+  getCoreFactory,
+  findMatchingCores,
+} from '../../frontend/coreRegistry';
+import type { CoreFactory } from '../../frontend/coreRegistry';
+import { getCoresDirectory } from '../../frontend/config';
+import { getPreferredCoreId, setPreferredCoreId } from '../../frontend/corePreferences';
+import { getSaveStateService } from '../../frontend/serviceProvider';
+import { SettingsManager } from '../../frontend/SettingsManager';
+import {
+  selectCore,
+  showSaveStateDialog,
+  showCorruptedStateDialog,
+  showNetplayDisconnectedDialog,
+} from '../../ui';
+import type { SaveStateInfo, SaveStateChoice, CorruptedStateInfo, NetplayOptions } from '../../ui';
+import { STDIN_SETTLE_DELAY_MS } from '../../ui';
+import { logger } from '../../utils/logger';
+import { getErrorMessage } from '../../utils/getErrorMessage';
+import {
+  DEFAULT_TERMINAL_WIDTH_WIDE,
+  DEFAULT_TERMINAL_HEIGHT_TALL,
+  CHAR_ASPECT_RATIO_4_3,
+} from '../../rendering';
+import { fitToTerminal } from '../../rendering/shared/fitToTerminal';
+import { registerLibretroCore } from '../../cores/libretro/loader';
+import type { CliOptions } from '../parseArgs';
+import type { RunEmulatorResult } from './types';
+
+export * from './types';
+
+/**
+ * Validate a state file exists and is readable
+ * @returns true if file exists and can be read, false otherwise
+ */
+const validateStateFile = (statePath: string): boolean => {
+  if (!existsSync(statePath)) {
+    return false;
+  }
+
+  try {
+    const data = readFileSync(statePath);
+    // For JSON files, try to parse to validate
+    // For binary files (libretro), just check the file is not empty
+    if (data.length === 0) {
+      return false;
+    }
+
+    // Try to parse as JSON (native cores) - if it fails, assume it's binary (libretro)
+    const str = data.toString("utf-8");
+    if (str.startsWith("{")) {
+      JSON.parse(str); // Validate JSON is parseable
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Analyze a corrupted state file and determine if it can be loaded.
+ * All cores use raw binary state format.
+ */
+const analyzeCorruptedState = (statePath: string, romName: string): CorruptedStateInfo => {
+  const info: CorruptedStateInfo = {
+    path: statePath,
+    romName,
+    fileReadable: false,
+    isBinary: true,
+    validJson: false,
+    canAttemptLoad: false,
+    errorReason: 'Unknown error',
+  };
+
+  // Try to read the file
+  let data: Buffer;
+  try {
+    data = readFileSync(statePath);
+    info.fileReadable = true;
+  } catch (err) {
+    info.errorReason = `Cannot read file: ${getErrorMessage(err)}`;
+    return info;
+  }
+
+  if (data.length > 0) {
+    info.canAttemptLoad = true;
+    info.errorReason = 'Binary state file may be corrupted';
+  } else {
+    info.errorReason = 'File is empty';
+  }
+
+  return info;
+};
+
+// Calculate display size to fit terminal while maintaining aspect ratio
+const calculateDisplaySize = (requestedWidth?: number, requestedHeight?: number): { width: number; height: number } => {
+  const termCols = process.stdout.columns || DEFAULT_TERMINAL_WIDTH_WIDE;
+  const termRows = process.stdout.rows || DEFAULT_TERMINAL_HEIGHT_TALL;
+
+  // Reserve 1 row for status line
+  const availableRows = termRows - 1;
+
+  return fitToTerminal({
+    availableCols: termCols,
+    availableRows,
+    aspectRatio: CHAR_ASPECT_RATIO_4_3,
+    requestedWidth,
+    requestedHeight,
+  });
+};
+
+/**
+ * Run the emulator for a given ROM
+ * @param resumeGame If true, skip save state dialog and resume directly
+ * @param resumeCoreId If provided, use this core (bypasses core selector when resuming)
+ * @param netplay If provided, netplay options from the UI (overrides CLI options)
+ * @returns Result indicating whether to continue and if the game was played
+ */
+export const runEmulator = async (romPath: string, options: CliOptions, resumeGame?: boolean, resumeCoreId?: string, netplay?: NetplayOptions): Promise<RunEmulatorResult> => {
+  // Check if joining netplay (used for skipping dialogs)
+  // netplayConnect can be empty string for LAN discovery, so check !== undefined
+  const isJoiningNetplay = netplay?.mode === 'join' || options.netplayConnect !== undefined;
+
+  // Detect or validate core for the ROM
+  let coreFactory: CoreFactory | undefined;
+
+  if (options.core) {
+    // User specified a core explicitly via --core flag
+    let factory = getCoreFactory(options.core);
+
+    // If core not found, try lazy loading (for cores skipped during startup scan)
+    // mupen64plus is skipped during startup due to macOS loading issues
+    if (!factory && options.core.includes('mupen64plus')) {
+      const coresDir = getCoresDirectory();
+      const ext = process.platform === 'darwin' ? '.dylib' : process.platform === 'win32' ? '.dll' : '.so';
+      const corePath = join(coresDir, `${options.core}_libretro${ext}`);
+      if (existsSync(corePath)) {
+        const coreId = registerLibretroCore(corePath);
+        if (coreId) {
+          factory = getCoreFactory(coreId);
+        }
+      }
+    }
+
+    if (!factory) {
+      const errorMsg = `Unknown core '${options.core}'`;
+      console.error(`Error: ${errorMsg}`);
+      console.error("Use --list-cores to see available cores.");
+      logger.error(errorMsg, 'Core');
+      return { shouldContinue: false, gameWasPlayed: false };
+    }
+    coreFactory = factory;
+  } else if (resumeCoreId) {
+    // Resuming a game - use the same core that was used before
+    const factory = getCoreFactory(resumeCoreId);
+    if (!factory) {
+      // Core no longer available - fall back to normal selection
+      const warnMsg = `Core '${resumeCoreId}' no longer available, selecting alternative.`;
+      console.error(`Warning: ${warnMsg}`);
+      logger.warn(warnMsg, 'Core');
+    } else {
+      coreFactory = factory;
+    }
+  }
+
+  // If coreFactory not yet set, do normal core detection
+  if (!coreFactory) {
+    // Find all cores that support this file extension
+    const matchingCores = findMatchingCores(romPath);
+
+    if (matchingCores.length === 0) {
+      const supportedExts = getSupportedExtensions().join(", ");
+      const errorMsg = `Unsupported ROM format for '${romPath}'`;
+      console.error(`Error: ${errorMsg}`);
+      console.error(`Supported formats: ${supportedExts}`);
+      console.error("Use --list-cores to see available cores.");
+      logger.error(`${errorMsg}. Supported: ${supportedExts}`, 'Core');
+      return { shouldContinue: true, gameWasPlayed: false }; // Return to browser instead of exiting
+    } else if (matchingCores.length === 1) {
+      // Only one core matches - use it directly
+      coreFactory = matchingCores[0].factory;
+    } else if (isJoiningNetplay) {
+      // Netplay join mode - auto-select first matching core to skip dialog
+      // The netplay protocol will validate CRC anyway
+      coreFactory = matchingCores[0].factory;
+    } else {
+      // Check for a saved core preference for this extension
+      const ext = extname(romPath).toLowerCase();
+      const preferredId = getPreferredCoreId(ext);
+      const preferred = preferredId
+        ? matchingCores.find(c => c.id === preferredId)
+        : undefined;
+
+      if (preferred) {
+        coreFactory = preferred.factory;
+      } else {
+        // Multiple cores match and no saved preference - show selection dialog
+        const selection = await selectCore(matchingCores, basename(romPath), {
+          nativeMode: options.config.video_driver === 'native',
+          scaleFactor: options.config.menu_scale_factor,
+        });
+        if (!selection) {
+          // User cancelled - return to browser
+          return { shouldContinue: true, gameWasPlayed: false };
+        }
+        coreFactory = selection.factory;
+        if (selection.remember) {
+          setPreferredCoreId(ext, selection.id);
+        }
+      }
+    }
+  }
+
+  // Calculate display size (auto-fit to terminal if not specified) - for terminal mode
+  const displaySize = calculateDisplaySize(options.width, options.height);
+
+  const systemInfo = coreFactory.getSystemInfo();
+
+  // Check for saved state (unless disabled or joining netplay session)
+  // When joining netplay, the client receives state from the host
+  let shouldRestore = false;
+  let statePathToLoad: string | null = null;
+
+  if (options.enableSaveState && !isJoiningNetplay) {
+    const saveStateService = getSaveStateService();
+
+    // Find any existing save state (checks .state.auto first, then legacy formats)
+    const foundStatePath = saveStateService.findExistingStatePath(romPath);
+    const stateFileExists = foundStatePath !== null;
+    const isValidState = stateFileExists && validateStateFile(foundStatePath);
+
+    // If resumeGame is true and there's a valid state, skip dialogs and resume directly
+    if (resumeGame && isValidState) {
+      shouldRestore = true;
+      statePathToLoad = foundStatePath;
+    } else if (stateFileExists && !isValidState) {
+      // Corrupted save state - analyze and show detailed dialog
+      const corruptedInfo = analyzeCorruptedState(foundStatePath, basename(romPath));
+      const choice = await showCorruptedStateDialog(corruptedInfo, {
+        nativeMode: options.config.video_driver === 'native',
+        scaleFactor: options.config.menu_scale_factor,
+      });
+      if (choice === 'cancel') {
+        return { shouldContinue: true, gameWasPlayed: false };
+      } else if (choice === 'try_load') {
+        // User wants to try loading anyway - attempt it
+        shouldRestore = true;
+        statePathToLoad = foundStatePath;
+      }
+      // If 'continue', will start fresh and overwrite on save
+    } else if (isValidState) {
+      // Show save state dialog
+      const saveStateInfo: SaveStateInfo = {
+        path: foundStatePath,
+        romName: basename(romPath),
+        coreName: systemInfo.name,
+      };
+
+      // Reset stdin for the dialog
+      process.stdin.removeAllListeners();
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      await new Promise(resolve => setTimeout(resolve, STDIN_SETTLE_DELAY_MS));
+
+      const choice: SaveStateChoice = await showSaveStateDialog(saveStateInfo, {
+        nativeMode: options.config.video_driver === 'native',
+        scaleFactor: options.config.menu_scale_factor,
+      });
+
+      if (choice === 'cancel') {
+        return { shouldContinue: true, gameWasPlayed: false };
+      } else if (choice === 'delete') {
+        // Delete the save state file
+        saveStateService.deleteState(romPath);
+      } else {
+        // Resume
+        shouldRestore = true;
+        statePathToLoad = foundStatePath;
+      }
+    }
+  }
+
+  try {
+    // Only pass explicit dimensions if user specified them (enables auto-resize otherwise)
+    const explicitDimensions =
+      options.width !== undefined || options.height !== undefined;
+
+    // Create SettingsManager for centralized settings sync
+    const settingsManager = new SettingsManager(options.config, options.configPath);
+
+    const emulator = new Emulator({
+      romPath: romPath,
+      coreFactory: coreFactory,
+      width: explicitDimensions ? displaySize.width : undefined,
+      height: explicitDimensions ? displaySize.height : undefined,
+      colorEnabled: options.colorEnabled,
+      renderMode: options.renderMode,
+      scale: options.scale,
+      enableGamepad: options.enableGamepad,
+      enableAudio: options.enableAudio,
+      startMuted: options.startMuted,
+      enableSaveState: options.enableSaveState,
+      enableBatterySave: options.enableBatterySave,
+      showStatusBar: options.showStatusBar,
+      fpsLimit: options.fpsLimit,
+      enableDiffRendering: options.enableDiffRendering,
+      noRender: options.noRender,
+      frameLimit: options.frameLimit,
+      pngCompressionLevel: options.pngCompressionLevel,
+      gamma: options.gamma,
+      scanlines: options.scanlines,
+      saturation: options.saturation,
+      brightness: options.brightness,
+      contrast: options.contrast,
+      vignette: options.vignette,
+      bloom: options.bloom,
+      bloomThreshold: options.bloomThreshold,
+      ntsc: options.ntsc,
+      curvature: options.curvature,
+      chromaticAberration: options.chromaticAberration,
+      hasUserEffects: options.hasUserEffects,
+      config: options.config,
+      configPath: options.configPath,
+      settingsManager,
+      // Netplay options - UI options override CLI options
+      netplayHost: netplay?.mode === 'host' ? true : options.netplayHost,
+      netplayConnect: netplay?.mode === 'join' ? netplay.host : options.netplayConnect,
+      netplayPort: netplay?.port ?? options.netplayPort,
+      netplayPassword: netplay?.password ?? options.netplayPassword,
+      netplaySpectate: netplay?.spectate ?? options.netplaySpectate,
+      netplayNickname: netplay?.nickname ?? options.netplayNickname,
+      netplayInputDelay: netplay?.inputDelay ?? options.netplayInputDelay,
+    });
+
+    let stateLoaded = false;
+    if (shouldRestore && statePathToLoad) {
+      stateLoaded = await emulator.loadState(statePathToLoad);
+    }
+
+    // Set up signal handlers for graceful shutdown
+    const signalHandler = () => {
+      emulator.stop();
+    };
+    process.on('SIGINT', signalHandler);
+    process.on('SIGTERM', signalHandler);
+
+    try {
+      await emulator.run(stateLoaded);
+    } finally {
+      // Clean up signal handlers
+      process.removeListener('SIGINT', signalHandler);
+      process.removeListener('SIGTERM', signalHandler);
+    }
+    const sessionSeconds = emulator.getSessionSeconds();
+
+    // If netplay disconnected unexpectedly (not by user choice), show dialog and offer reconnection
+    if (emulator.wasNetplayDisconnected() && !emulator.wasIntentionalDisconnect()) {
+      const disconnectInfo = emulator.getNetplayDisconnectInfo();
+      const choice = await showNetplayDisconnectedDialog(
+        {
+          reason: disconnectInfo.reason,
+          host: disconnectInfo.host || undefined,
+          port: disconnectInfo.port || undefined,
+        },
+        {
+          nativeMode: options.config.video_driver === 'native',
+          scaleFactor: options.config.menu_scale_factor,
+        }
+      );
+
+      if (choice === 'reconnect') {
+        // Recursively call runEmulator to try reconnecting
+        return runEmulator(romPath, options, resumeGame, resumeCoreId, netplay);
+      }
+
+      if (choice === 'exit') {
+        // User pressed CTRL-C - exit the app entirely
+        return { shouldContinue: false, gameWasPlayed: true, coreId: systemInfo.id, sessionSeconds };
+      }
+
+      // User chose menu - return to browser with netplay panel
+      return { shouldContinue: true, gameWasPlayed: true, coreId: systemInfo.id, sessionSeconds, showNetplayOnReturn: true };
+    }
+
+    // If user intentionally disconnected from netplay, return to browser without disconnect dialog
+    if (emulator.wasIntentionalDisconnect()) {
+      return { shouldContinue: true, gameWasPlayed: true, coreId: systemInfo.id, sessionSeconds };
+    }
+
+    return { shouldContinue: true, gameWasPlayed: true, coreId: systemInfo.id, sessionSeconds };
+  } catch (error) {
+    const errorMsg = getErrorMessage(error);
+    console.error("Error:", errorMsg);
+    logger.error(errorMsg, 'Emulator');
+    // If netplay was requested and failed, show netplay panel on return to browser
+    const netplayWasRequested = isJoiningNetplay || options.netplayHost || !!netplay;
+    return { shouldContinue: true, gameWasPlayed: false, showNetplayOnReturn: netplayWasRequested };
+  }
+};

package/src/cli/runEmulator/types.ts

@@ -0,0 +1,7 @@
+export interface RunEmulatorResult {
+  shouldContinue: boolean;  // true = return to browser, false = exit app
+  gameWasPlayed: boolean;   // true = emulator ran, false = cancelled before running
+  coreId?: string;          // Core ID that was used (for resume game feature)
+  sessionSeconds?: number;  // Estimated runtime in seconds based on frame count
+  showNetplayOnReturn?: boolean;  // true = show netplay panel when returning to browser
+}

package/src/consts.ts

@@ -0,0 +1,19 @@
+/**
+ * Application-wide constants
+ */
+
+declare const __APP_VERSION__: string;
+declare const __BUILD_DATE__: string;
+
+/** Application version (e.g., "0.1.0") */
+export const VERSION =
+  typeof __APP_VERSION__ !== 'undefined' ? __APP_VERSION__ : '0.0.0';
+
+/** Build date in YYYYMMDD format (e.g., "20260121") */
+export const BUILD_DATE =
+  typeof __BUILD_DATE__ !== 'undefined' ? __BUILD_DATE__ : '';
+
+/** Application version with build date (e.g., "0.1.0 (20260121)") */
+export const VERSION_WITH_DATE = BUILD_DATE
+  ? `${VERSION} (${BUILD_DATE})`
+  : VERSION;

package/src/core/button/consts.ts

@@ -0,0 +1,35 @@
+import { StandardButton } from '.';
+
+/**
+ * Default keyboard mappings for standard buttons.
+ * These are the keys that map to each standard button.
+ */
+export const DEFAULT_KEYBOARD_MAP: Map<string, StandardButton> = new Map([
+  // Face buttons - primary mappings
+  ['k', StandardButton.A],
+  ['z', StandardButton.A],
+  ['j', StandardButton.B],
+  ['x', StandardButton.B],
+  ['i', StandardButton.X],
+  ['u', StandardButton.Y],
+
+  // Shoulder buttons
+  ['q', StandardButton.L],
+  ['e', StandardButton.R],
+
+  // Control buttons
+  ['Enter', StandardButton.Start],
+  [' ', StandardButton.Select],
+
+  // D-pad - WASD
+  ['w', StandardButton.Up],
+  ['s', StandardButton.Down],
+  ['a', StandardButton.Left],
+  ['d', StandardButton.Right],
+
+  // D-pad - Arrow keys
+  ['ArrowUp', StandardButton.Up],
+  ['ArrowDown', StandardButton.Down],
+  ['ArrowLeft', StandardButton.Left],
+  ['ArrowRight', StandardButton.Right],
+]);

package/src/core/button/index.ts

@@ -0,0 +1,123 @@
+/**
+ * Standard Button Definitions
+ *
+ * These are the "physical" buttons that the frontend maps from keyboard/gamepad input.
+ * The InputMapper translates these to core-specific button IDs based on button names.
+ *
+ * This enum covers the superset of buttons across supported systems:
+ * - NES: A, B, Select, Start, D-pad (8 buttons)
+ * - GBA: A, B, L, R, Select, Start, D-pad (10 buttons)
+ * - SNES: A, B, X, Y, L, R, Select, Start, D-pad (12 buttons)
+ */
+
+export enum StandardButton {
+  // Face buttons (right side of controller)
+  A = 0,
+  B = 1,
+  X = 2,
+  Y = 3,
+
+  // Shoulder buttons
+  L = 4,
+  R = 5,
+  L2 = 6,
+  R2 = 7,
+
+  // Control buttons (center)
+  Start = 8,
+  Select = 9,
+
+  // D-pad
+  Up = 10,
+  Down = 11,
+  Left = 12,
+  Right = 13,
+
+  // Analog sticks (for future use)
+  LeftStickUp = 14,
+  LeftStickDown = 15,
+  LeftStickLeft = 16,
+  LeftStickRight = 17,
+  RightStickUp = 18,
+  RightStickDown = 19,
+  RightStickLeft = 20,
+  RightStickRight = 21,
+  L3 = 22, // Left stick click
+  R3 = 23, // Right stick click
+
+  // System buttons
+  Guide = 24, // Xbox button / PlayStation button / Home button
+}
+
+/**
+ * Get the display name for a standard button
+ */
+export const getButtonName = (button: StandardButton): string => {
+  switch (button) {
+    case StandardButton.A:
+      return 'A';
+    case StandardButton.B:
+      return 'B';
+    case StandardButton.X:
+      return 'X';
+    case StandardButton.Y:
+      return 'Y';
+    case StandardButton.L:
+      return 'L';
+    case StandardButton.R:
+      return 'R';
+    case StandardButton.L2:
+      return 'L2';
+    case StandardButton.R2:
+      return 'R2';
+    case StandardButton.Start:
+      return 'Start';
+    case StandardButton.Select:
+      return 'Select';
+    case StandardButton.Up:
+      return 'Up';
+    case StandardButton.Down:
+      return 'Down';
+    case StandardButton.Left:
+      return 'Left';
+    case StandardButton.Right:
+      return 'Right';
+    case StandardButton.LeftStickUp:
+      return 'LS Up';
+    case StandardButton.LeftStickDown:
+      return 'LS Down';
+    case StandardButton.LeftStickLeft:
+      return 'LS Left';
+    case StandardButton.LeftStickRight:
+      return 'LS Right';
+    case StandardButton.RightStickUp:
+      return 'RS Up';
+    case StandardButton.RightStickDown:
+      return 'RS Down';
+    case StandardButton.RightStickLeft:
+      return 'RS Left';
+    case StandardButton.RightStickRight:
+      return 'RS Right';
+    case StandardButton.L3:
+      return 'L3';
+    case StandardButton.R3:
+      return 'R3';
+    case StandardButton.Guide:
+      return 'Guide';
+    default:
+      return `Button ${button}`;
+  }
+};
+
+
+/**
+ * Check if two D-pad directions are opposite (for preventing simultaneous press)
+ */
+export const areOppositeDirections = (a: StandardButton, b: StandardButton): boolean => (a === StandardButton.Up && b === StandardButton.Down) ||
+    (a === StandardButton.Down && b === StandardButton.Up) ||
+    (a === StandardButton.Left && b === StandardButton.Right) ||
+    (a === StandardButton.Right && b === StandardButton.Left);
+
+// Re-export consts after enum definition to avoid circular dependency
+// (consts.ts references StandardButton values)
+export * from './consts';