@muhammedaksam/opentui-doom 0.3.0 → 0.3.5

package/README.md

@@ -6,6 +6,7 @@
 
 - **Full DOOM gameplay** in your terminal
 - **High-resolution rendering** using half-block characters (▀) for 2x vertical resolution
+- **Mouse aiming** - Turn and fire with your mouse (enabled by default)
 - **Keyboard input support** with WASD and arrow keys
 - **Save/Load game** support - saves persist to `~/.opentui-doom/`
 - **Sound effects and music** via mpv
@@ -68,20 +69,34 @@ Place the WAD file in the project root.
 bun run dev -- --wad ./doom1.wad
 ```
 
+To disable mouse aiming:
+
+```bash
+bun run dev -- --wad ./doom1.wad --mouse false
+```
+
+### Debug Mode
+
+To run with debug logging enabled (outputs to `debug.log`):
+
+```bash
+bun run dev:debug -- --wad ./doom1.wad
+```
+
 ## 🎮 Controls
 
-| Action            | Keys           |
-| ----------------- | -------------- |
-| Move Forward/Back | W / S or ↑ / ↓ |
-| Turn Left/Right   | ← / →          |
-| Strafe            | A / D          |
-| Fire              | Ctrl           |
-| Use/Open          | Space          |
-| Run               | Shift          |
-| Weapons           | 1-7            |
-| Menu              | Escape         |
-| Map               | Tab            |
-| Quit              | Ctrl+C         |
+| Action            | Keys               |
+| ----------------- | ------------------ |
+| Move Forward/Back | W / S or ↑ / ↓     |
+| Turn Left/Right   | Mouse or ← / →     |
+| Strafe            | A / D              |
+| Fire              | Left Click or Ctrl |
+| Use/Open          | Space              |
+| Run               | Shift              |
+| Weapons           | 1-7                |
+| Menu              | Escape             |
+| Map               | Tab                |
+| Quit              | Ctrl+C             |
 
 ## 💾 Save Games
 
@@ -148,7 +163,8 @@ opentui-doom/
 ├── src/
 │   ├── index.ts          # Main entry point
 │   ├── doom-engine.ts    # WASM module wrapper
-│   └── doom-input.ts     # Keyboard input mapping
+│   ├── doom-input.ts     # Keyboard input mapping
+│   └── doom-mouse.ts     # Mouse input handling
 ├── doom/
 │   ├── doomgeneric_opentui.c  # Platform implementation
 │   ├── doomgeneric/           # doomgeneric source (cloned during build)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/opentui-doom",
-  "version": "0.3.0",
+  "version": "0.3.5",
   "description": "Play DOOM in your terminal using OpenTUI's framebuffer rendering and doomgeneric WASM",
   "module": "src/index.ts",
   "type": "module",
@@ -58,7 +58,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@opentui/core": "^0.1.57"
+    "@opentui/core": "^0.1.59"
   },
   "engines": {
     "node": ">=18",

package/src/doom-engine.ts

@@ -135,6 +135,23 @@ export class DoomEngine {
                     // Create .savegame directory for saves (DOOM looks here by default)
                     module.FS_createPath("/", ".savegame", true, true);
                     
+                    // Create default.cfg with WASD key bindings
+                    // This is needed because we send character codes for WASD (to allow typing in save dialogs)
+                    // Key codes: w=119, a=97, s=115, d=100
+                    const defaultConfig = [
+                        "key_up 119",           // 'w' for forward
+                        "key_down 115",         // 's' for backward  
+                        "key_strafeleft 97",    // 'a' for strafe left
+                        "key_straferight 100",  // 'd' for strafe right
+                    ].join("\n") + "\n";
+                    const configArray = Array.from(new TextEncoder().encode(defaultConfig));
+                    try {
+                        module.FS_createDataFile("/", "default.cfg", configArray, true, false);
+                        debugLog("Engine", "Created default.cfg with WASD key bindings");
+                    } catch (e) {
+                        debugLog("Engine", `Failed to create default.cfg: ${e}`);
+                    }
+                    
                     // Load existing saves from ~/.opentui-doom/ into virtual filesystem
                     const existingSaves = loadExistingSaves();
                     for (const [slot, data] of existingSaves) {

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,9 +149,9 @@ 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;
@@ -167,13 +171,18 @@ export function createDoomInputHandler(options: DoomInputOptions) {
         // 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(() => {
-                    engine.pushKey(false, doomKey);
+                    for (const doomKey of doomKeys) {
+                        engine.pushKey(false, doomKey);
+                    }
                     keyStates.set(keyId, false);
                 }, 50);
                 return;
@@ -184,7 +193,9 @@ export function createDoomInputHandler(options: DoomInputOptions) {
         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/index.ts

@@ -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);
 }
@@ -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,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);