@muhammedaksam/opentui-doom 0.2.1 → 0.3.0

package/doom/i_system.c

@@ -0,0 +1,345 @@
+//
+// Copyright(C) 1993-1996 Id Software, Inc.
+// Copyright(C) 2005-2014 Simon Howard
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// DESCRIPTION:
+//     OpenTUI-modified i_system.c - System-specific interface functions
+//     Modified to support proper exit handling in WebAssembly builds.
+//
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+// Include DOOM headers BEFORE emscripten to avoid true/false macro conflicts
+#include "config.h"
+#include "deh_str.h"
+#include "doomtype.h"
+#include "i_joystick.h"
+#include "i_sound.h"
+#include "i_system.h"
+#include "i_timer.h"
+#include "i_video.h"
+#include "m_argv.h"
+#include "m_config.h"
+#include "m_misc.h"
+#include "w_wad.h"
+#include "z_zone.h"
+
+// Include emscripten AFTER doom headers to avoid true/false conflicts
+#include <emscripten.h>
+
+#define DEFAULT_RAM 6 /* MiB */
+#define MIN_RAM 6     /* MiB */
+
+typedef struct atexit_listentry_s atexit_listentry_t;
+
+struct atexit_listentry_s {
+  atexit_func_t func;
+  boolean run_on_error;
+  atexit_listentry_t *next;
+};
+
+static atexit_listentry_t *exit_funcs = NULL;
+
+void I_AtExit(atexit_func_t func, boolean run_on_error) {
+  atexit_listentry_t *entry;
+
+  entry = malloc(sizeof(*entry));
+
+  entry->func = func;
+  entry->run_on_error = run_on_error;
+  entry->next = exit_funcs;
+  exit_funcs = entry;
+}
+
+// Tactile feedback function, probably used for the Logitech Cyberman
+
+void I_Tactile(int on, int off, int total) {}
+
+// Zone memory auto-allocation function that allocates the zone size
+// by trying progressively smaller zone sizes until one is found that
+// works.
+
+static byte *AutoAllocMemory(int *size, int default_ram, int min_ram) {
+  byte *zonemem;
+
+  // Allocate the zone memory.  This loop tries progressively smaller
+  // zone sizes until a size is found that can be allocated.
+  // If we used the -mb command line parameter, only the parameter
+  // provided is accepted.
+
+  zonemem = NULL;
+
+  while (zonemem == NULL) {
+    // We need a reasonable minimum amount of RAM to start.
+
+    if (default_ram < min_ram) {
+      I_Error("Unable to allocate %i MiB of RAM for zone", default_ram);
+    }
+
+    // Try to allocate the zone memory.
+
+    *size = default_ram * 1024 * 1024;
+
+    zonemem = malloc(*size);
+
+    // Failed to allocate?  Reduce zone size until we reach a size
+    // that is acceptable.
+
+    if (zonemem == NULL) {
+      default_ram -= 1;
+    }
+  }
+
+  return zonemem;
+}
+
+byte *I_ZoneBase(int *size) {
+  byte *zonemem;
+  int min_ram, default_ram;
+  int p;
+
+  //!
+  // @arg <mb>
+  //
+  // Specify the heap size, in MiB (default 16).
+  //
+
+  p = M_CheckParmWithArgs("-mb", 1);
+
+  if (p > 0) {
+    default_ram = atoi(myargv[p + 1]);
+    min_ram = default_ram;
+  } else {
+    default_ram = DEFAULT_RAM;
+    min_ram = MIN_RAM;
+  }
+
+  zonemem = AutoAllocMemory(size, default_ram, min_ram);
+
+  printf("zone memory: %p, %x allocated for zone\n", zonemem, *size);
+
+  return zonemem;
+}
+
+void I_PrintBanner(char *msg) {
+  int i;
+  int spaces = 35 - (strlen(msg) / 2);
+
+  for (i = 0; i < spaces; ++i)
+    putchar(' ');
+
+  puts(msg);
+}
+
+void I_PrintDivider(void) {
+  int i;
+
+  for (i = 0; i < 75; ++i) {
+    putchar('=');
+  }
+
+  putchar('\n');
+}
+
+void I_PrintStartupBanner(char *gamedescription) {
+  I_PrintDivider();
+  I_PrintBanner(gamedescription);
+  I_PrintDivider();
+
+  printf(" " PACKAGE_NAME
+         " is free software, covered by the GNU General Public\n"
+         " License.  There is NO warranty; not even for MERCHANTABILITY or "
+         "FITNESS\n"
+         " FOR A PARTICULAR PURPOSE. You are welcome to change and distribute\n"
+         " copies under certain conditions. See the source for more "
+         "information.\n");
+
+  I_PrintDivider();
+}
+
+//
+// I_ConsoleStdout
+//
+// Returns true if stdout is a real console, false if it is a file
+//
+
+boolean I_ConsoleStdout(void) {
+  // In WASM environment, always return 0
+  return 0;
+}
+
+//
+// I_Quit
+//
+// Modified for OpenTUI: Call JavaScript to properly exit the application
+//
+
+void I_Quit(void) {
+  atexit_listentry_t *entry;
+
+  // Signal JavaScript to exit the application FIRST
+  // This must happen before atexit handlers because they may prevent
+  // this code from being reached (e.g., by calling exit() or longjmp)
+  EM_ASM({
+    if (typeof Module.quitGame === 'function') {
+      Module.quitGame();
+    }
+  });
+
+  // Run through all exit functions
+  entry = exit_funcs;
+
+  while (entry != NULL) {
+    entry->func();
+    entry = entry->next;
+  }
+}
+
+//
+// I_Error
+//
+
+static boolean already_quitting = false;
+
+void I_Error(char *error, ...) {
+  char msgbuf[512];
+  va_list argptr;
+  atexit_listentry_t *entry;
+
+  if (already_quitting) {
+    fprintf(stderr, "Warning: recursive call to I_Error detected.\n");
+    return;
+  } else {
+    already_quitting = true;
+  }
+
+  // Message first.
+  va_start(argptr, error);
+  vfprintf(stderr, error, argptr);
+  fprintf(stderr, "\n\n");
+  va_end(argptr);
+  fflush(stderr);
+
+  // Write a copy of the message into buffer.
+  va_start(argptr, error);
+  memset(msgbuf, 0, sizeof(msgbuf));
+  M_vsnprintf(msgbuf, sizeof(msgbuf), error, argptr);
+  va_end(argptr);
+
+  // Shutdown. Here might be other errors.
+  entry = exit_funcs;
+
+  while (entry != NULL) {
+    if (entry->run_on_error) {
+      entry->func();
+    }
+
+    entry = entry->next;
+  }
+
+  // In WASM, we can't really exit, but we signal an error
+  EM_ASM(
+      {
+        var msg = UTF8ToString($0);
+        console.error("DOOM Error: " + msg);
+        if (typeof Module.quitGame === 'function') {
+          Module.quitGame();
+        }
+      },
+      msgbuf);
+}
+
+//
+// Read Access Violation emulation.
+//
+// From PrBoom+, by entryway.
+//
+
+#define DOS_MEM_DUMP_SIZE 10
+
+static const unsigned char mem_dump_dos622[DOS_MEM_DUMP_SIZE] = {
+    0x57, 0x92, 0x19, 0x00, 0xF4, 0x06, 0x70, 0x00, 0x16, 0x00};
+static const unsigned char mem_dump_win98[DOS_MEM_DUMP_SIZE] = {
+    0x9E, 0x0F, 0xC9, 0x00, 0x65, 0x04, 0x70, 0x00, 0x16, 0x00};
+static const unsigned char mem_dump_dosbox[DOS_MEM_DUMP_SIZE] = {
+    0x00, 0x00, 0x00, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00};
+static unsigned char mem_dump_custom[DOS_MEM_DUMP_SIZE];
+
+static const unsigned char *dos_mem_dump = mem_dump_dos622;
+
+boolean I_GetMemoryValue(unsigned int offset, void *value, int size) {
+  static boolean firsttime = true;
+
+  if (firsttime) {
+    int p, i, val;
+
+    firsttime = false;
+    i = 0;
+
+    //!
+    // @category compat
+    // @arg <version>
+    //
+    // Specify DOS version to emulate for NULL pointer dereference
+    // emulation.  Supported versions are: dos622, dos71, dosbox.
+    // The default is to emulate DOS 7.1 (Windows 98).
+    //
+
+    p = M_CheckParmWithArgs("-setmem", 1);
+
+    if (p > 0) {
+      if (!strcasecmp(myargv[p + 1], "dos622")) {
+        dos_mem_dump = mem_dump_dos622;
+      }
+      if (!strcasecmp(myargv[p + 1], "dos71")) {
+        dos_mem_dump = mem_dump_win98;
+      } else if (!strcasecmp(myargv[p + 1], "dosbox")) {
+        dos_mem_dump = mem_dump_dosbox;
+      } else {
+        for (i = 0; i < DOS_MEM_DUMP_SIZE; ++i) {
+          ++p;
+
+          if (p >= myargc || myargv[p][0] == '-') {
+            break;
+          }
+
+          M_StrToInt(myargv[p], &val);
+          mem_dump_custom[i++] = (unsigned char)val;
+        }
+
+        dos_mem_dump = mem_dump_custom;
+      }
+    }
+  }
+
+  switch (size) {
+  case 1:
+    *((unsigned char *)value) = dos_mem_dump[offset];
+    return true;
+  case 2:
+    *((unsigned short *)value) =
+        dos_mem_dump[offset] | (dos_mem_dump[offset + 1] << 8);
+    return true;
+  case 4:
+    *((unsigned int *)value) =
+        dos_mem_dump[offset] | (dos_mem_dump[offset + 1] << 8) |
+        (dos_mem_dump[offset + 2] << 16) | (dos_mem_dump[offset + 3] << 24);
+    return true;
+  }
+
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/opentui-doom",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Play DOOM in your terminal using OpenTUI's framebuffer rendering and doomgeneric WASM",
   "module": "src/index.ts",
   "type": "module",
@@ -13,6 +13,7 @@
     "doom/doomgeneric_opentui.c",
     "doom/doom_js_sound_bridge.c",
     "doom/i_sound.c",
+    "doom/i_system.c",
     "doom/s_sound.c",
     "sound",
     "scripts"
@@ -43,7 +44,10 @@
   ],
   "scripts": {
     "dev": "bun run --watch src/index.ts",
+    "dev:debug": "DOOM_DEBUG=1 bun run --watch src/index.ts",
     "build:doom": "bash ./scripts/build-doom.sh",
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "typecheck": "bun x tsc --noEmit",
     "start": "bun run src/index.ts",
     "prepublishOnly": "bun run build:doom"
   },

package/scripts/build-doom.sh

@@ -34,11 +34,12 @@ fi
 # Create build directory
 mkdir -p "$BUILD_DIR"
 
-# Copy our platform file, sound bridge, and custom sound files
+# Copy our platform file, sound bridge, and custom files
 cp "$DOOM_DIR/doomgeneric_opentui.c" "$DOOM_DIR/doomgeneric/doomgeneric/"
 cp "$DOOM_DIR/doom_js_sound_bridge.c" "$DOOM_DIR/doomgeneric/doomgeneric/"
 cp "$DOOM_DIR/i_sound.c" "$DOOM_DIR/doomgeneric/doomgeneric/"
 cp "$DOOM_DIR/s_sound.c" "$DOOM_DIR/doomgeneric/doomgeneric/"
+cp "$DOOM_DIR/i_system.c" "$DOOM_DIR/doomgeneric/doomgeneric/"
 
 echo "Compiling DOOM to WebAssembly..."
 cd "$DOOM_DIR/doomgeneric/doomgeneric"
@@ -48,7 +49,7 @@ emcc -O2 \
     -s WASM=1 \
     -s USE_SDL=2 \
     -s EXPORTED_FUNCTIONS="['_doomgeneric_Create','_doomgeneric_Tick','_DG_GetFrameBuffer','_DG_PushKeyEvent','_malloc','_free']" \
-    -s EXPORTED_RUNTIME_METHODS="['ccall','cwrap','getValue','setValue']" \
+    -s EXPORTED_RUNTIME_METHODS="['ccall','cwrap','getValue','setValue','FS']" \
     -s ALLOW_MEMORY_GROWTH=1 \
     -s INITIAL_MEMORY=33554432 \
     -s MODULARIZE=1 \

package/src/debug.ts

@@ -0,0 +1,27 @@
+/**
+ * Debug logging utility for OpenTUI-DOOM
+ * 
+ * Only logs when DOOM_DEBUG environment variable is set.
+ * Usage: DOOM_DEBUG=1 bun run dev
+ */
+
+import { appendFileSync } from "fs";
+import { join } from "path";
+
+const DEBUG_ENABLED = process.env.DOOM_DEBUG === "1" || process.env.DOOM_DEBUG === "true";
+const logFile = join(import.meta.dir, "..", "debug.log");
+
+/**
+ * Log a debug message to debug.log file if DOOM_DEBUG is enabled
+ */
+export function debugLog(category: string, message: string): void {
+  if (!DEBUG_ENABLED) return;
+  
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] [${category}] ${message}\n`;
+  try {
+    appendFileSync(logFile, line);
+  } catch (e) {
+    // Ignore logging errors
+  }
+}

package/src/doom-audio.ts

@@ -7,20 +7,13 @@
 
 import { spawn, ChildProcess } from "child_process";
 import { join } from "path";
-import { existsSync, appendFileSync, unlinkSync } from "fs";
+import { existsSync, unlinkSync } from "fs";
 import { createConnection, Socket } from "net";
+import { debugLog } from "./debug";
 
-// Log file for debugging
-const logFile = join(import.meta.dir, "..", "debug.log");
-
+// Local helper to log with Audio category
 function log(message: string): void {
-    const timestamp = new Date().toISOString();
-    const line = `[${timestamp}] [Audio] ${message}\n`;
-    try {
-        appendFileSync(logFile, line);
-    } catch (e) {
-        // Ignore logging errors
-    }
+    debugLog('Audio', message);
 }
 
 // Track all spawned mpv processes for cleanup

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);