@muhammedaksam/opentui-doom 0.3.0 → 0.3.6

package/src/doom-input.ts

@@ -1,6 +1,6 @@
 /**
  * DOOM Input Handler
- * 
+ *
  * Maps OpenTUI keyboard events to DOOM key codes
  */
 
@@ -9,117 +9,121 @@ import type { DoomEngine } from "./doom-engine";
 
 // DOOM key codes (from doomkeys.h)
 export const DoomKeys = {
-    KEY_RIGHTARROW: 0xae,
-    KEY_LEFTARROW: 0xac,
-    KEY_UPARROW: 0xad,
-    KEY_DOWNARROW: 0xaf,
-    KEY_STRAFE_L: 0xa0,
-    KEY_STRAFE_R: 0xa1,
-    KEY_USE: 0xa2,
-    KEY_FIRE: 0xa3,
-    KEY_ESCAPE: 27,
-    KEY_ENTER: 13,
-    KEY_TAB: 9,
-    KEY_F1: 0x80 + 0x3b,
-    KEY_F2: 0x80 + 0x3c,
-    KEY_F3: 0x80 + 0x3d,
-    KEY_F4: 0x80 + 0x3e,
-    KEY_F5: 0x80 + 0x3f,
-    KEY_F6: 0x80 + 0x40,
-    KEY_F7: 0x80 + 0x41,
-    KEY_F8: 0x80 + 0x42,
-    KEY_F9: 0x80 + 0x43,
-    KEY_F10: 0x80 + 0x44,
-    KEY_F11: 0x80 + 0x57,
-    KEY_F12: 0x80 + 0x58,
-    KEY_BACKSPACE: 127,
-    KEY_PAUSE: 0xff,
-    KEY_EQUALS: 0x3d,
-    KEY_MINUS: 0x2d,
-    KEY_RSHIFT: 0x80 + 0x36,
-    KEY_RCTRL: 0x80 + 0x1d,
-    KEY_RALT: 0x80 + 0x38,
-    KEY_LALT: 0x80 + 0x38,
-    KEY_CAPSLOCK: 0x80 + 0x3a,
-    KEY_NUMLOCK: 0x80 + 0x45,
-    KEY_SCRLCK: 0x80 + 0x46,
-    KEY_PRTSCR: 0x80 + 0x59,
-    KEY_HOME: 0x80 + 0x47,
-    KEY_END: 0x80 + 0x4f,
-    KEY_PGUP: 0x80 + 0x49,
-    KEY_PGDN: 0x80 + 0x51,
-    KEY_INS: 0x80 + 0x52,
-    KEY_DEL: 0x80 + 0x53,
+  KEY_RIGHTARROW: 0xae,
+  KEY_LEFTARROW: 0xac,
+  KEY_UPARROW: 0xad,
+  KEY_DOWNARROW: 0xaf,
+  KEY_STRAFE_L: 0xa0,
+  KEY_STRAFE_R: 0xa1,
+  KEY_USE: 0xa2,
+  KEY_FIRE: 0xa3,
+  KEY_ESCAPE: 27,
+  KEY_ENTER: 13,
+  KEY_TAB: 9,
+  KEY_F1: 0x80 + 0x3b,
+  KEY_F2: 0x80 + 0x3c,
+  KEY_F3: 0x80 + 0x3d,
+  KEY_F4: 0x80 + 0x3e,
+  KEY_F5: 0x80 + 0x3f,
+  KEY_F6: 0x80 + 0x40,
+  KEY_F7: 0x80 + 0x41,
+  KEY_F8: 0x80 + 0x42,
+  KEY_F9: 0x80 + 0x43,
+  KEY_F10: 0x80 + 0x44,
+  KEY_F11: 0x80 + 0x57,
+  KEY_F12: 0x80 + 0x58,
+  KEY_BACKSPACE: 127,
+  KEY_PAUSE: 0xff,
+  KEY_EQUALS: 0x3d,
+  KEY_MINUS: 0x2d,
+  KEY_RSHIFT: 0x80 + 0x36,
+  KEY_RCTRL: 0x80 + 0x1d,
+  KEY_RALT: 0x80 + 0x38,
+  KEY_LALT: 0x80 + 0x38,
+  KEY_CAPSLOCK: 0x80 + 0x3a,
+  KEY_NUMLOCK: 0x80 + 0x45,
+  KEY_SCRLCK: 0x80 + 0x46,
+  KEY_PRTSCR: 0x80 + 0x59,
+  KEY_HOME: 0x80 + 0x47,
+  KEY_END: 0x80 + 0x4f,
+  KEY_PGUP: 0x80 + 0x49,
+  KEY_PGDN: 0x80 + 0x51,
+  KEY_INS: 0x80 + 0x52,
+  KEY_DEL: 0x80 + 0x53,
 } as const;
 
 // Key state tracking for press/release
 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 {
-    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;
-
-    // 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;
-
-    // Fire (Ctrl) - but not Ctrl+C which should exit
-    if (key.ctrl && key.name !== "c") return DoomKeys.KEY_FIRE;
-
-    // Alt for strafe
-    if (key.meta || key.name === "alt") return DoomKeys.KEY_LALT;
-
-    // Shift for run
-    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;
-
-    // Weapon selection (1-9, 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;
-
-    // Y/N for prompts
-    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 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 - 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];
+
+  // Fire (Ctrl) - but not Ctrl+C which should exit
+  if (key.ctrl && key.name !== "c") return [DoomKeys.KEY_FIRE];
+
+  // Alt for strafe
+  if (key.meta || key.name === "alt") return [DoomKeys.KEY_LALT];
+
+  // Shift for run
+  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];
+
+  // Weapon selection (1-9, 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];
+
+  // Y/N for prompts
+  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 [];
 }
 
 /**
@@ -129,82 +133,89 @@ function mapKeyToDoom(key: KeyEvent): number | null {
 const keyTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
 export interface DoomInputOptions {
-    engine: DoomEngine;
-    onExit?: () => void;
+  engine: DoomEngine;
+  onExit?: () => void;
 }
 
 export function createDoomInputHandler(options: DoomInputOptions) {
-    const { engine, onExit } = options;
-
-    return (key: KeyEvent) => {
-        // Handle Ctrl+C for exit
-        if (key.ctrl && (key.name === "c" || key.sequence === "\x03")) {
-            if (onExit) {
-                onExit();
-            }
-            return;
-        }
+  const { engine, onExit } = options;
+
+  return (key: KeyEvent) => {
+    // Handle Ctrl+C for exit
+    if (key.ctrl && (key.name === "c" || key.sequence === "\x03")) {
+      if (onExit) {
+        onExit();
+      }
+      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() ?? "";
+    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";
+    // 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);
-        if (existingTimer) {
-            clearTimeout(existingTimer);
-            keyTimers.delete(keyId);
-        }
+    // Clear any existing release timer for this key
+    const existingTimer = keyTimers.get(keyId);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+      keyTimers.delete(keyId);
+    }
 
-        // 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;
-            }
-        }
+    // Key press - send if not already pressed, OR if it's a menu confirmation key
+    if (!wasPressed || isMenuConfirmKey) {
+      keyStates.set(keyId, true);
+      // 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 (for non-menu keys)
-        const timer = setTimeout(() => {
-            if (keyStates.get(keyId)) {
-                keyStates.set(keyId, false);
-                engine.pushKey(false, doomKey);
-                keyTimers.delete(keyId);
-            }
-        }, 300);
-        keyTimers.set(keyId, timer);
-    };
+    // Schedule key release after 300ms of no input (for non-menu keys)
+    const timer = setTimeout(() => {
+      if (keyStates.get(keyId)) {
+        keyStates.set(keyId, false);
+        for (const doomKey of doomKeys) {
+          engine.pushKey(false, doomKey);
+        }
+        keyTimers.delete(keyId);
+      }
+    }, 300);
+    keyTimers.set(keyId, timer);
+  };
 }
 
 /**
  * Get help text for controls
  */
 export function getControlsHelp(): string {
-    return [
-        "Controls:",
-        "  Movement: Arrow Keys or WASD",
-        "  Fire: Ctrl",
-        "  Use/Open: Space",
-        "  Run: Shift",
-        "  Strafe: A/D or Alt+Arrows",
-        "  Weapons: 1-7",
-        "  Menu: Escape",
-        "  Map: Tab",
-    ].join("\n");
+  return [
+    "Controls:",
+    "  Movement: Arrow Keys or WASD",
+    "  Fire: Ctrl",
+    "  Use/Open: Space",
+    "  Run: Shift",
+    "  Strafe: A/D or Alt+Arrows",
+    "  Weapons: 1-7",
+    "  Menu: Escape",
+    "  Map: Tab",
+  ].join("\n");
 }

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