@muhammedaksam/opentui-doom 0.2.0 → 0.3.0

package/src/doom-engine.ts

@@ -7,6 +7,8 @@
 
 import { readFile } from "fs/promises";
 import { join, resolve } from "path";
+import { debugLog } from "./debug";
+import { loadExistingSaves, writeSave } from "./doom-saves";
 
 // DOOM screen dimensions
 export const DOOM_WIDTH = 1280;
@@ -35,6 +37,12 @@ export interface DoomModule {
         canRead: boolean,
         canWrite: boolean
     ) => string;
+    FS?: {
+        readFile: (path: string, opts?: { encoding?: string }) => Uint8Array;
+        readdir: (path: string) => string[];
+        stat: (path: string) => { mode: number };
+        isDir: (mode: number) => boolean;
+    };
     ccall: (name: string, returnType: string | null, argTypes: string[], args: any[]) => any;
     cwrap: (name: string, returnType: string | null, argTypes: string[]) => (...args: any[]) => any;
     setValue: (ptr: number, value: number, type: string) => void;
@@ -45,6 +53,7 @@ export interface DoomEngineOptions {
     wadPath: string;
     print?: (text: string) => void;
     printErr?: (text: string) => void;
+    onQuit?: () => void;
 }
 
 export class DoomEngine {
@@ -54,6 +63,8 @@ export class DoomEngine {
     private wadPath: string;
     private print: (text: string) => void;
     private printErr: (text: string) => void;
+    private onQuit: (() => void) | null = null;
+    private emscriptenFS: any = null;  // FS reference captured from Emscripten
 
     constructor(optionsOrPath: string | DoomEngineOptions) {
         if (typeof optionsOrPath === "string") {
@@ -64,6 +75,7 @@ export class DoomEngine {
             this.wadPath = resolve(optionsOrPath.wadPath);
             this.print = optionsOrPath.print || ((text: string) => console.log('[DOOM]', text));
             this.printErr = optionsOrPath.printErr || ((text: string) => console.error('[DOOM]', text));
+            this.onQuit = optionsOrPath.onQuit || null;
         }
     }
 
@@ -101,13 +113,39 @@ export class DoomEngine {
             stopMusic: () => audio.stopMusic(),
             setMusicVolume: (volume: number) => audio.setMusicVolume(volume),
 
+            // Game lifecycle callbacks - called from C via EM_ASM
+            quitGame: () => {
+                debugLog('Engine', 'quitGame callback called from WASM');
+                debugLog('Engine', `this.onQuit is: ${this.onQuit ? 'defined' : 'undefined'}`);
+                if (this.onQuit) {
+                    debugLog('Engine', 'calling this.onQuit()');
+                    this.onQuit();
+                    debugLog('Engine', 'this.onQuit() returned');
+                }
+            },
+
             // preRun receives Module as first argument  
             preRun: [
-                function (module: DoomModule) {
-                    // Create /doom directory
+                (module: any) => {
+                    // Create /doom directory for WAD
                     module.FS_createPath("/", "doom", true, true);
                     // Write WAD file to virtual filesystem
                     module.FS_createDataFile("/doom", "doom1.wad", wadArray, true, false);
+                    
+                    // Create .savegame directory for saves (DOOM looks here by default)
+                    module.FS_createPath("/", ".savegame", true, true);
+                    
+                    // Load existing saves from ~/.opentui-doom/ into virtual filesystem
+                    const existingSaves = loadExistingSaves();
+                    for (const [slot, data] of existingSaves) {
+                        const filename = `doomsav${slot}.dsg`;
+                        try {
+                            module.FS_createDataFile("/.savegame", filename, Array.from(data), true, true);
+                            debugLog("Engine", `Pre-loaded save slot ${slot} to virtual FS`);
+                        } catch (e) {
+                            debugLog("Engine", `Failed to pre-load save slot ${slot}: ${e}`);
+                        }
+                    }
                 }
             ],
         };
@@ -117,6 +155,18 @@ export class DoomEngine {
         if (!this.module) {
             throw new Error("Failed to initialize DOOM module");
         }
+        
+        // Capture FS reference after module is fully loaded
+        // Try different methods to access Emscripten's FS
+        if ((this.module as any).FS) {
+            this.emscriptenFS = (this.module as any).FS;
+            debugLog("Engine", "Captured FS from module.FS");
+        } else if (typeof (globalThis as any).FS !== 'undefined') {
+            this.emscriptenFS = (globalThis as any).FS;
+            debugLog("Engine", "Captured FS from globalThis.FS");
+        } else {
+            debugLog("Engine", "Warning: Could not find Emscripten FS object");
+        }
 
         // Initialize DOOM
         this.initDoom();
@@ -215,4 +265,72 @@ export class DoomEngine {
     isInitialized(): boolean {
         return this.initialized;
     }
+
+    /**
+     * Sync save games from the virtual filesystem to disk (~/.opentui-doom/)
+     * Call this periodically or after save operations to persist saves
+     */
+    syncSaves(): void {
+        if (!this.module || !this.emscriptenFS) {
+            debugLog("Engine", "syncSaves: module or FS not available");
+            return;
+        }
+        
+        // DOOM can save to different paths depending on configuration
+        // Try multiple possible locations
+        const savePaths = [
+            "/",              // Root
+            "/.savegame",     // Default when configdir is "."
+            ".savegame",      // Relative path (CWD)
+            "/doom",          // Our custom path  
+            "/tmp",           // Temp directory
+        ];
+        
+        const FS = this.emscriptenFS;
+        
+        // List root directory to see what exists
+        try {
+            const rootEntries = FS.readdir("/");
+            debugLog("Engine", `VFS root contents: ${rootEntries.join(", ")}`);
+            
+            // Check each directory at root
+            for (const entry of rootEntries) {
+                if (entry === "." || entry === "..") continue;
+                try {
+                    const stat = FS.stat(`/${entry}`);
+                    if (FS.isDir(stat.mode)) {
+                        const subEntries = FS.readdir(`/${entry}`);
+                        const dsgFiles = subEntries.filter((e: string) => e.endsWith(".dsg"));
+                        if (dsgFiles.length > 0) {
+                            debugLog("Engine", `Found .dsg files in /${entry}: ${dsgFiles.join(", ")}`);
+                        }
+                    }
+                } catch (e) {
+                    // Not a directory or can't read
+                }
+            }
+        } catch (e) {
+            debugLog("Engine", `Failed to list VFS root: ${e}`);
+        }
+        
+        for (let slot = 0; slot <= 5; slot++) {
+            const filename = `doomsav${slot}.dsg`;
+            
+            for (const basePath of savePaths) {
+                const vfsPath = basePath === "/" ? `/${filename}` : `${basePath}/${filename}`;
+                
+                try {
+                    // Try to read the file from virtual FS
+                    const data = FS.readFile(vfsPath);
+                    if (data && data.length > 0) {
+                        debugLog("Engine", `Found save at ${vfsPath}, syncing slot ${slot} (${data.length} bytes)`);
+                        writeSave(slot, data);
+                        break; // Found this slot, move to next
+                    }
+                } catch (e) {
+                    // File doesn't exist at this path, try next
+                }
+            }
+        }
+    }
 }

package/src/doom-input.ts

@@ -151,6 +151,11 @@ export function createDoomInputHandler(options: DoomInputOptions) {
 
         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,13 +164,23 @@ 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);
+            
+            // For menu confirmation keys, immediately send release too
+            // since DOOM only cares about the keydown event
+            if (isMenuConfirmKey) {
+                setTimeout(() => {
+                    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);

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

@@ -18,6 +18,7 @@ import {
 import { DoomEngine, DOOM_WIDTH, DOOM_HEIGHT } from "./doom-engine";
 import { createDoomInputHandler, getControlsHelp } from "./doom-input";
 import { shutdownAudio } from "./doom-audio";
+import { debugLog } from "./debug";
 import { parseArgs } from "util";
 
 // Parse command line arguments
@@ -60,12 +61,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 +127,18 @@ 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
 
 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
@@ -172,10 +209,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();