@muhammedaksam/opentui-doom 0.2.1 → 0.3.5

package/src/doom-input.ts

@@ -56,70 +56,74 @@ export const DoomKeys = {
 const keyStates = new Map<string, boolean>();
 
 /**
- * Map an OpenTUI key event to a DOOM key code
+ * Map an OpenTUI key event to DOOM key code(s)
+ * Returns an array of key codes - for most keys this is a single code,
+ * but for WASD we return both the movement key AND the character
+ * so both gameplay movement and text input work.
  */
-function mapKeyToDoom(key: KeyEvent): number | null {
+function mapKeyToDoom(key: KeyEvent): number[] {
     const name = key.name?.toLowerCase() ?? "";
 
     // Arrow keys
-    if (name === "up" || key.sequence === "\x1b[A") return DoomKeys.KEY_UPARROW;
-    if (name === "down" || key.sequence === "\x1b[B") return DoomKeys.KEY_DOWNARROW;
-    if (name === "left" || key.sequence === "\x1b[D") return DoomKeys.KEY_LEFTARROW;
-    if (name === "right" || key.sequence === "\x1b[C") return DoomKeys.KEY_RIGHTARROW;
-
-    // WASD movement (alternative to arrows)
-    if (name === "w") return DoomKeys.KEY_UPARROW;
-    if (name === "s") return DoomKeys.KEY_DOWNARROW;
-    if (name === "a") return DoomKeys.KEY_STRAFE_L;
-    if (name === "d") return DoomKeys.KEY_STRAFE_R;
+    if (name === "up" || key.sequence === "\x1b[A") return [DoomKeys.KEY_UPARROW];
+    if (name === "down" || key.sequence === "\x1b[B") return [DoomKeys.KEY_DOWNARROW];
+    if (name === "left" || key.sequence === "\x1b[D") return [DoomKeys.KEY_LEFTARROW];
+    if (name === "right" || key.sequence === "\x1b[C") return [DoomKeys.KEY_RIGHTARROW];
+
+    // WASD movement - send BOTH movement key AND character
+    // Movement key ensures gameplay works, character ensures text input works
+    if (name === "w") return [DoomKeys.KEY_UPARROW, "w".charCodeAt(0)];
+    if (name === "s") return [DoomKeys.KEY_DOWNARROW, "s".charCodeAt(0)];
+    if (name === "a") return [DoomKeys.KEY_STRAFE_L, "a".charCodeAt(0)];
+    if (name === "d") return [DoomKeys.KEY_STRAFE_R, "d".charCodeAt(0)];
 
     // Action keys
-    if (name === "space") return " ".charCodeAt(0);  // Use
-    if (name === "return" || name === "enter") return DoomKeys.KEY_ENTER;
-    if (name === "escape") return DoomKeys.KEY_ESCAPE;
-    if (name === "tab") return DoomKeys.KEY_TAB;
-    if (name === "backspace") return DoomKeys.KEY_BACKSPACE;
+    if (name === "space") return [" ".charCodeAt(0)];  // Use
+    if (name === "return" || name === "enter") return [DoomKeys.KEY_ENTER];
+    if (name === "escape") return [DoomKeys.KEY_ESCAPE];
+    if (name === "tab") return [DoomKeys.KEY_TAB];
+    if (name === "backspace") return [DoomKeys.KEY_BACKSPACE];
 
     // Fire (Ctrl) - but not Ctrl+C which should exit
-    if (key.ctrl && key.name !== "c") return DoomKeys.KEY_FIRE;
+    if (key.ctrl && key.name !== "c") return [DoomKeys.KEY_FIRE];
 
     // Alt for strafe
-    if (key.meta || key.name === "alt") return DoomKeys.KEY_LALT;
+    if (key.meta || key.name === "alt") return [DoomKeys.KEY_LALT];
 
     // Shift for run
-    if (key.shift) return DoomKeys.KEY_RSHIFT;
+    if (key.shift) return [DoomKeys.KEY_RSHIFT];
 
     // Function keys
-    if (name === "f1") return DoomKeys.KEY_F1;
-    if (name === "f2") return DoomKeys.KEY_F2;
-    if (name === "f3") return DoomKeys.KEY_F3;
-    if (name === "f4") return DoomKeys.KEY_F4;
-    if (name === "f5") return DoomKeys.KEY_F5;
-    if (name === "f6") return DoomKeys.KEY_F6;
-    if (name === "f7") return DoomKeys.KEY_F7;
-    if (name === "f8") return DoomKeys.KEY_F8;
-    if (name === "f9") return DoomKeys.KEY_F9;
-    if (name === "f10") return DoomKeys.KEY_F10;
-    if (name === "f11") return DoomKeys.KEY_F11;
-    if (name === "f12") return DoomKeys.KEY_F12;
+    if (name === "f1") return [DoomKeys.KEY_F1];
+    if (name === "f2") return [DoomKeys.KEY_F2];
+    if (name === "f3") return [DoomKeys.KEY_F3];
+    if (name === "f4") return [DoomKeys.KEY_F4];
+    if (name === "f5") return [DoomKeys.KEY_F5];
+    if (name === "f6") return [DoomKeys.KEY_F6];
+    if (name === "f7") return [DoomKeys.KEY_F7];
+    if (name === "f8") return [DoomKeys.KEY_F8];
+    if (name === "f9") return [DoomKeys.KEY_F9];
+    if (name === "f10") return [DoomKeys.KEY_F10];
+    if (name === "f11") return [DoomKeys.KEY_F11];
+    if (name === "f12") return [DoomKeys.KEY_F12];
 
     // Weapon selection (1-9, 0)
-    if (name >= "0" && name <= "9") return name.charCodeAt(0);
+    if (name >= "0" && name <= "9") return [name.charCodeAt(0)];
 
     // Plus/minus for gamma/zoom
-    if (name === "+" || name === "=") return DoomKeys.KEY_EQUALS;
-    if (name === "-") return DoomKeys.KEY_MINUS;
+    if (name === "+" || name === "=") return [DoomKeys.KEY_EQUALS];
+    if (name === "-") return [DoomKeys.KEY_MINUS];
 
     // Y/N for prompts
-    if (name === "y") return "y".charCodeAt(0);
-    if (name === "n") return "n".charCodeAt(0);
+    if (name === "y") return ["y".charCodeAt(0)];
+    if (name === "n") return ["n".charCodeAt(0)];
 
     // Other letter keys (for cheats, etc)
     if (name.length === 1 && name >= "a" && name <= "z") {
-        return name.charCodeAt(0);
+        return [name.charCodeAt(0)];
     }
 
-    return null;
+    return [];
 }
 
 /**
@@ -145,12 +149,17 @@ export function createDoomInputHandler(options: DoomInputOptions) {
             return;
         }
 
-        const doomKey = mapKeyToDoom(key);
+        const doomKeys = mapKeyToDoom(key);
 
-        if (doomKey === null) return;
+        if (doomKeys.length === 0) return;
 
         const keyId = key.name || key.sequence || "";
         const wasPressed = keyStates.get(keyId) ?? false;
+        const keyName = key.name?.toLowerCase() ?? "";
+
+        // Menu confirmation keys (y/n) should always send keydown on every press
+        // These are used for quit dialogs and other prompts
+        const isMenuConfirmKey = keyName === "y" || keyName === "n";
 
         // Clear any existing release timer for this key
         const existingTimer = keyTimers.get(keyId);
@@ -159,17 +168,34 @@ export function createDoomInputHandler(options: DoomInputOptions) {
             keyTimers.delete(keyId);
         }
 
-        // Key press - only send if not already pressed
-        if (!wasPressed) {
+        // Key press - send if not already pressed, OR if it's a menu confirmation key
+        if (!wasPressed || isMenuConfirmKey) {
             keyStates.set(keyId, true);
-            engine.pushKey(true, doomKey);
+            // Send all mapped keys (for WASD this includes both movement and character)
+            for (const doomKey of doomKeys) {
+                engine.pushKey(true, doomKey);
+            }
+            
+            // For menu confirmation keys, immediately send release too
+            // since DOOM only cares about the keydown event
+            if (isMenuConfirmKey) {
+                setTimeout(() => {
+                    for (const doomKey of doomKeys) {
+                        engine.pushKey(false, doomKey);
+                    }
+                    keyStates.set(keyId, false);
+                }, 50);
+                return;
+            }
         }
 
-        // Schedule key release after 300ms of no input
+        // Schedule key release after 300ms of no input (for non-menu keys)
         const timer = setTimeout(() => {
             if (keyStates.get(keyId)) {
                 keyStates.set(keyId, false);
-                engine.pushKey(false, doomKey);
+                for (const doomKey of doomKeys) {
+                    engine.pushKey(false, doomKey);
+                }
                 keyTimers.delete(keyId);
             }
         }, 300);

package/src/doom-mouse.ts

@@ -0,0 +1,129 @@
+/**
+ * DOOM Mouse Input Handler
+ * 
+ * Provides mouse-based turning and firing for DOOM.
+ * Mouse horizontal movement translates to left/right turning.
+ * Left click fires the weapon.
+ */
+
+import type { DoomEngine } from "./doom-engine";
+import { DoomKeys } from "./doom-input";
+import { debugLog } from "./debug";
+
+export interface DoomMouseOptions {
+    engine: DoomEngine;
+    sensitivity?: number;  // Cells of movement before triggering turn (default: 2)
+}
+
+export interface DoomMouseHandler {
+    onMouseMove: (x: number, y: number) => void;
+    onMouseDown: (button: number) => void;
+    onMouseUp: (button: number) => void;
+    reset: () => void;
+}
+
+/**
+ * Create a mouse handler that forwards mouse events to DOOM
+ */
+export function createDoomMouseHandler(options: DoomMouseOptions): DoomMouseHandler {
+    const { engine } = options;
+    
+    let lastMouseX: number | null = null;
+    let isLeftMouseDown = false;
+    let currentTurnKey: number | null = null;
+    let releaseTimer: ReturnType<typeof setTimeout> | null = null;
+    
+    const RELEASE_DELAY = 100; // Release key 100ms after last movement
+    
+    return {
+        /**
+         * Handle mouse movement - hold turn key while moving
+         */
+        onMouseMove(x: number, _y: number): void {
+            if (lastMouseX === null) {
+                lastMouseX = x;
+                return;
+            }
+            
+            const delta = x - lastMouseX;
+            lastMouseX = x;
+            
+            if (delta === 0) return;
+            
+            const newTurnKey = delta > 0 ? DoomKeys.KEY_RIGHTARROW : DoomKeys.KEY_LEFTARROW;
+            
+            // Clear any pending release
+            if (releaseTimer) {
+                clearTimeout(releaseTimer);
+                releaseTimer = null;
+            }
+            
+            // If direction changed, release old and press new
+            if (currentTurnKey !== newTurnKey) {
+                if (currentTurnKey !== null) {
+                    engine.pushKey(false, currentTurnKey);
+                }
+                engine.pushKey(true, newTurnKey);
+                currentTurnKey = newTurnKey;
+            }
+            
+            // Schedule release after delay (will be cancelled if more movement comes)
+            releaseTimer = setTimeout(() => {
+                if (currentTurnKey !== null) {
+                    engine.pushKey(false, currentTurnKey);
+                    currentTurnKey = null;
+                }
+                releaseTimer = null;
+            }, RELEASE_DELAY);
+        },
+        
+        /**
+         * Handle mouse button press
+         */
+        onMouseDown(button: number): void {
+            // Left click (button 0) = fire
+            if (button === 0 && !isLeftMouseDown) {
+                isLeftMouseDown = true;
+                engine.pushKey(true, DoomKeys.KEY_FIRE);
+                debugLog("Mouse", "Fire pressed");
+            }
+        },
+        
+        /**
+         * Handle mouse button release
+         */
+        onMouseUp(button: number): void {
+            // Left click release = stop firing
+            if (button === 0 && isLeftMouseDown) {
+                isLeftMouseDown = false;
+                engine.pushKey(false, DoomKeys.KEY_FIRE);
+                debugLog("Mouse", "Fire released");
+            }
+        },
+        
+        /**
+         * Reset mouse state (useful when window loses focus)
+         */
+        reset(): void {
+            lastMouseX = null;
+            
+            // Clear pending release timer
+            if (releaseTimer) {
+                clearTimeout(releaseTimer);
+                releaseTimer = null;
+            }
+            
+            // Release any held turn key
+            if (currentTurnKey !== null) {
+                engine.pushKey(false, currentTurnKey);
+                currentTurnKey = null;
+            }
+            
+            // Release fire if held
+            if (isLeftMouseDown) {
+                isLeftMouseDown = false;
+                engine.pushKey(false, DoomKeys.KEY_FIRE);
+            }
+        }
+    };
+}

package/src/doom-saves.ts

@@ -0,0 +1,121 @@
+/**
+ * Save Game Manager for OpenTUI-DOOM
+ * 
+ * Handles persistence of DOOM save games to ~/.opentui-doom/
+ * DOOM uses 6 save slots (0-5) with files named doomsav{N}.dsg
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { debugLog } from "./debug";
+
+// Save game directory path
+const SAVE_DIR = join(homedir(), ".opentui-doom");
+
+// DOOM save file format: doomsav{0-5}.dsg
+const SAVE_FILE_PATTERN = /^doomsav([0-5])\.dsg$/;
+
+/**
+ * Ensure the save directory exists
+ */
+export function ensureSaveDir(): void {
+    if (!existsSync(SAVE_DIR)) {
+        mkdirSync(SAVE_DIR, { recursive: true });
+        debugLog("Saves", `Created save directory: ${SAVE_DIR}`);
+    }
+}
+
+/**
+ * Get the save game directory path
+ */
+export function getSaveGameDir(): string {
+    ensureSaveDir();
+    return SAVE_DIR;
+}
+
+/**
+ * Get the path to a save file for a given slot (0-5)
+ */
+export function getSaveFilePath(slot: number): string {
+    if (slot < 0 || slot > 5) {
+        throw new Error(`Invalid save slot: ${slot}. Must be 0-5.`);
+    }
+    return join(SAVE_DIR, `doomsav${slot}.dsg`);
+}
+
+/**
+ * Load all existing save games from disk
+ * Returns a Map of slot number to file contents (Uint8Array)
+ */
+export function loadExistingSaves(): Map<number, Uint8Array> {
+    ensureSaveDir();
+    const saves = new Map<number, Uint8Array>();
+    
+    try {
+        const files = readdirSync(SAVE_DIR);
+        for (const file of files) {
+            const match = file.match(SAVE_FILE_PATTERN);
+            if (match && match[1]) {
+                const slot = parseInt(match[1], 10);
+                const filePath = join(SAVE_DIR, file);
+                try {
+                    const data = readFileSync(filePath);
+                    saves.set(slot, new Uint8Array(data));
+                    debugLog("Saves", `Loaded save slot ${slot}: ${data.length} bytes`);
+                } catch (e) {
+                    debugLog("Saves", `Failed to read save file ${filePath}: ${e}`);
+                }
+            }
+        }
+    } catch (e) {
+        debugLog("Saves", `Failed to list save directory: ${e}`);
+    }
+    
+    debugLog("Saves", `Loaded ${saves.size} existing saves`);
+    return saves;
+}
+
+/**
+ * Write a save game to disk
+ */
+export function writeSave(slot: number, data: Uint8Array): boolean {
+    ensureSaveDir();
+    const filePath = getSaveFilePath(slot);
+    
+    try {
+        writeFileSync(filePath, data);
+        debugLog("Saves", `Wrote save slot ${slot}: ${data.length} bytes to ${filePath}`);
+        return true;
+    } catch (e) {
+        debugLog("Saves", `Failed to write save slot ${slot}: ${e}`);
+        return false;
+    }
+}
+
+/**
+ * Check if a save exists for a given slot
+ */
+export function saveExists(slot: number): boolean {
+    const filePath = getSaveFilePath(slot);
+    return existsSync(filePath);
+}
+
+/**
+ * Read a save game from disk
+ */
+export function readSave(slot: number): Uint8Array | null {
+    const filePath = getSaveFilePath(slot);
+    
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    
+    try {
+        const data = readFileSync(filePath);
+        return new Uint8Array(data);
+    } catch (e) {
+        debugLog("Saves", `Failed to read save slot ${slot}: ${e}`);
+        return null;
+    }
+}

package/src/index.ts

@@ -17,7 +17,9 @@ import {
 } from "@opentui/core";
 import { DoomEngine, DOOM_WIDTH, DOOM_HEIGHT } from "./doom-engine";
 import { createDoomInputHandler, getControlsHelp } from "./doom-input";
+import { createDoomMouseHandler, type DoomMouseHandler } from "./doom-mouse";
 import { shutdownAudio } from "./doom-audio";
+import { debugLog } from "./debug";
 import { parseArgs } from "util";
 
 // Parse command line arguments
@@ -34,6 +36,11 @@ const { values } = parseArgs({
       short: "h",
       default: false,
     },
+    mouse: {
+      type: "boolean",
+      short: "m",
+      default: true,
+    },
   },
 });
 
@@ -47,7 +54,7 @@ Options:
   -w, --wad    Path to DOOM WAD file (default: doom1.wad)
   -h, --help   Show this help message
 
-${getControlsHelp()}
+${getControlsHelp()}${values.mouse ? '\n  Mouse=Aim/Fire' : ''}
 `);
   process.exit(0);
 }
@@ -60,12 +67,42 @@ const renderer = await createCliRenderer({
 
 // Handle graceful shutdown
 const cleanup = (signal?: string) => {
+  debugLog('Exit', `cleanup called with signal: ${signal}`);
+  
+  // Set flag to stop the game loop FIRST - this is critical
+  isExiting = true;
+  debugLog('Exit', 'isExiting set to true');
+  
+  // Sync saves before exiting
+  if (doomEngine) {
+    try {
+      doomEngine.syncSaves();
+      debugLog('Exit', 'saves synced to disk');
+    } catch (e) {
+      debugLog('Exit', `failed to sync saves: ${e}`);
+    }
+  }
+  
+  // Clear the frame callback to stop DOOM from ticking
+  try {
+    renderer.setFrameCallback(null as any);
+    debugLog('Exit', 'frame callback cleared');
+  } catch (e) {
+    debugLog('Exit', `failed to clear frame callback: ${e}`);
+  }
+  
   shutdownAudio();
+  debugLog('Exit', 'shutdownAudio completed');
+  
   try {
     renderer.stop();
+    debugLog('Exit', 'renderer.stop completed');
   } catch (e) {
-    // Ignore error if renderer already stopped
+    debugLog('Exit', `renderer.stop error: ${e}`);
   }
+  
+  // Exit the process
+  debugLog('Exit', 'calling process.exit(0)');
   process.exit(0);
 };
 
@@ -96,12 +133,19 @@ container.add(loadingText);
 // Try to initialize DOOM engine
 let doomEngine: DoomEngine | null = null;
 let framebufferRenderable: FrameBufferRenderable | null = null;
+let isExiting = false; // Flag to stop the game loop when exiting
+let lastSaveSyncTime = 0; // Track when we last synced saves
+const SAVE_SYNC_INTERVAL = 5000; // Sync saves every 5 seconds
+let mouseHandler: DoomMouseHandler | null = null;
 
 async function initDoom() {
   try {
     loadingText.content = `Loading DOOM from: ${values.wad}`;
 
-    doomEngine = new DoomEngine(values.wad!);
+    doomEngine = new DoomEngine({
+      wadPath: values.wad!,
+      onQuit: cleanup,
+    });
     await doomEngine.init();
 
     // Remove loading text
@@ -120,9 +164,12 @@ async function initDoom() {
     renderer.root.add(framebufferRenderable);
 
     // Add controls overlay
+    const controlsContent = values.mouse 
+      ? "DOOM | Ctrl+C to exit | WASD=Move Mouse=Aim Click=Fire"
+      : "DOOM | Ctrl+C to exit | Arrow/WASD=Move Space=Use Ctrl=Fire";
     const controlsText = new TextRenderable(renderer, {
       id: "controls",
-      content: "DOOM | Ctrl+C to exit | Arrow/WASD=Move Space=Use Ctrl=Fire",
+      content: controlsContent,
       position: "absolute",
       left: 1,
       top: 0,
@@ -139,6 +186,30 @@ async function initDoom() {
     });
     renderer.keyInput.on("keypress", inputHandler);
 
+    // Set up mouse handler if enabled
+    if (values.mouse) {
+      mouseHandler = createDoomMouseHandler({
+        engine: doomEngine,
+        sensitivity: 2,  // Adjust for terminal cell size
+      });
+      
+      // Attach mouse events to framebuffer
+      framebufferRenderable.onMouseMove = (event) => {
+        mouseHandler?.onMouseMove(event.x, event.y);
+      };
+      framebufferRenderable.onMouseDrag = (event) => {
+        mouseHandler?.onMouseMove(event.x, event.y);
+      };
+      framebufferRenderable.onMouseDown = (event) => {
+        mouseHandler?.onMouseDown(event.button);
+      };
+      framebufferRenderable.onMouseUp = (event) => {
+        mouseHandler?.onMouseUp(event.button);
+      };
+      
+      debugLog("Input", "Mouse look enabled");
+    }
+
     // Start game loop
     renderer.setFrameCallback(gameLoop);
 
@@ -172,10 +243,20 @@ async function initDoom() {
 }
 
 async function gameLoop(deltaMs: number) {
+  // Bail out immediately if we're exiting
+  if (isExiting) return;
+  
   if (!doomEngine || !framebufferRenderable) return;
 
   // Run DOOM tick
   doomEngine.tick();
+  
+  // Periodic save sync (every 5 seconds)
+  const now = Date.now();
+  if (now - lastSaveSyncTime > SAVE_SYNC_INTERVAL) {
+    doomEngine.syncSaves();
+    lastSaveSyncTime = now;
+  }
 
   // Get framebuffer from DOOM
   const pixels = doomEngine.getFrameBuffer();