@muhammedaksam/opentui-doom 0.3.0 → 0.3.6

package/src/doom-saves.ts

@@ -1,6 +1,6 @@
 /**
  * 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
  */
@@ -20,28 +20,28 @@ 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}`);
-    }
+  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;
+  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`);
+  if (slot < 0 || slot > 5) {
+    throw new Error(`Invalid save slot: ${slot}. Must be 0-5.`);
+  }
+  return join(SAVE_DIR, `doomsav${slot}.dsg`);
 }
 
 /**
@@ -49,73 +49,73 @@ export function getSaveFilePath(slot: number): string {
  * 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}`);
-                }
-            }
+  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;
+  } 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;
-    }
+  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);
+  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;
-    }
+  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

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 /**
  * DOOM for OpenTUI
- * 
+ *
  * Plays DOOM in your terminal using OpenTUI's framebuffer rendering.
- * 
+ *
  * Usage: bun run dev -- --wad /path/to/doom1.wad
  */
 
@@ -17,6 +17,7 @@ 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";
@@ -35,6 +36,11 @@ const { values } = parseArgs({
       short: "h",
       default: false,
     },
+    mouse: {
+      type: "boolean",
+      short: "m",
+      default: true,
+    },
   },
 });
 
@@ -48,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);
 }
@@ -61,42 +67,42 @@ const renderer = await createCliRenderer({
 
 // Handle graceful shutdown
 const cleanup = (signal?: string) => {
-  debugLog('Exit', `cleanup called with signal: ${signal}`);
-  
+  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');
-  
+  debugLog("Exit", "isExiting set to true");
+
   // Sync saves before exiting
   if (doomEngine) {
     try {
       doomEngine.syncSaves();
-      debugLog('Exit', 'saves synced to disk');
+      debugLog("Exit", "saves synced to disk");
     } catch (e) {
-      debugLog('Exit', `failed to sync saves: ${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');
+    debugLog("Exit", "frame callback cleared");
   } catch (e) {
-    debugLog('Exit', `failed to clear frame callback: ${e}`);
+    debugLog("Exit", `failed to clear frame callback: ${e}`);
   }
-  
+
   shutdownAudio();
-  debugLog('Exit', 'shutdownAudio completed');
-  
+  debugLog("Exit", "shutdownAudio completed");
+
   try {
     renderer.stop();
-    debugLog('Exit', 'renderer.stop completed');
+    debugLog("Exit", "renderer.stop completed");
   } catch (e) {
-    debugLog('Exit', `renderer.stop error: ${e}`);
+    debugLog("Exit", `renderer.stop error: ${e}`);
   }
-  
+
   // Exit the process
-  debugLog('Exit', 'calling process.exit(0)');
+  debugLog("Exit", "calling process.exit(0)");
   process.exit(0);
 };
 
@@ -130,6 +136,7 @@ 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 {
@@ -157,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,
@@ -176,9 +186,32 @@ 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);
-
   } catch (error) {
     loadingText.content = `Error: ${error}`;
     loadingText.fg = RGBA.fromInts(255, 100, 100);
@@ -208,15 +241,15 @@ async function initDoom() {
   }
 }
 
-async function gameLoop(deltaMs: number) {
+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) {
@@ -236,7 +269,7 @@ async function gameLoop(deltaMs: number) {
   // Render to OpenTUI framebuffer using half-block characters
   // The upper half-block character (▀) uses foreground for top pixel, background for bottom
   for (let y = 0; y < fb.height; y++) {
-    const srcY1 = Math.floor(y * 2 * scaleY);     // Top pixel row
+    const srcY1 = Math.floor(y * 2 * scaleY); // Top pixel row
     const srcY2 = Math.floor((y * 2 + 1) * scaleY); // Bottom pixel row
 
     for (let x = 0; x < fb.width; x++) {