@muhammedaksam/opentui-doom 0.1.2 → 0.2.0

package/src/doom-audio.ts

@@ -0,0 +1,243 @@
+/**
+ * DOOM Audio Bridge for OpenTUI
+ * 
+ * Handles audio playback using mpv with proper process management.
+ * All spawned processes are tracked and terminated on shutdown.
+ */
+
+import { spawn, ChildProcess } from "child_process";
+import { join } from "path";
+import { existsSync, appendFileSync, unlinkSync } from "fs";
+import { createConnection, Socket } from "net";
+
+// Log file for debugging
+const logFile = join(import.meta.dir, "..", "debug.log");
+
+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
+    }
+}
+
+// Track all spawned mpv processes for cleanup
+const activeProcesses = new Set<ChildProcess>();
+
+// Current music process (only one music track at a time)
+let musicProcess: ChildProcess | null = null;
+
+// Current volume (0-127, DOOM standard)
+let currentVolume = 100;
+
+// Sound directory path
+const soundDir = join(import.meta.dir, "..", "sound");
+
+// IPC socket path for music volume control
+const musicSocketPath = "/tmp/doom-music-mpv.sock";
+
+// Whether audio is initialized
+let initialized = false;
+
+// Current music state for volume changes
+let currentMusicName: string | null = null;
+let currentMusicLooping: boolean = false;
+
+/**
+ * Initialize the audio system
+ */
+export function initAudio(): void {
+    if (initialized) return;
+    initialized = true;
+    log(`Initialized, sound dir: ${soundDir}`);
+}
+
+/**
+ * Shutdown the audio system and kill ALL spawned processes
+ */
+export function shutdownAudio(): void {
+    if (!initialized) return;
+
+    // Kill music process
+    if (musicProcess) {
+        try {
+            musicProcess.kill("SIGKILL");
+        } catch (e) {
+            // Process may have already exited
+        }
+        musicProcess = null;
+    }
+
+    // Kill ALL tracked processes
+    for (const proc of activeProcesses) {
+        try {
+            proc.kill("SIGKILL");
+        } catch (e) {
+            // Process may have already exited
+        }
+    }
+    activeProcesses.clear();
+
+    initialized = false;
+    log("Shutdown complete");
+}
+
+/**
+ * Helper to spawn mpv with common options
+ */
+function spawnMpv(filePath: string, options: string[] = []): ChildProcess | null {
+    if (!existsSync(filePath)) {
+        log(`File not found: ${filePath}`);
+        return null;
+    }
+
+    const args = [
+        "--no-video",           // No video output
+        "--no-terminal",        // No terminal output
+        "--really-quiet",       // Suppress all output
+        ...options,
+        filePath
+    ];
+
+    try {
+        const proc = spawn("mpv", args, {
+            stdio: "ignore",
+            detached: false,    // Keep attached to parent process
+        });
+
+        // Track the process
+        activeProcesses.add(proc);
+
+        // Remove from tracking when process exits
+        proc.on("exit", () => {
+            activeProcesses.delete(proc);
+        });
+
+        proc.on("error", (err) => {
+            log(`mpv error: ${err.message}`);
+            activeProcesses.delete(proc);
+        });
+
+        return proc;
+    } catch (e) {
+        log(`Failed to spawn mpv: ${e}`);
+        return null;
+    }
+}
+
+/**
+ * Play a sound effect
+ * Sound files should be in sound/ds{name}.wav
+ * Volume is 0-127 (DOOM standard)
+ */
+export function playSound(name: string, volume: number = 127): void {
+    if (!initialized) {
+        log("playSound called but not initialized");
+        return;
+    }
+
+    const soundPath = join(soundDir, `ds${name.toLowerCase()}.wav`);
+
+    // Convert DOOM volume (0-127) to mpv volume (0-100)
+    const mpvVolume = Math.round((volume / 127) * 100);
+    log(`Playing sound: ${soundPath} at volume ${mpvVolume}`);
+
+    // Fire and forget - process will auto-cleanup when done
+    const proc = spawnMpv(soundPath, [`--volume=${mpvVolume}`]);
+    log(`Spawn result: ${proc ? "success" : "failed"}`);
+}
+
+/**
+ * Play music track
+ * Music files should be in sound/{name}.mp3
+ */
+export function playMusic(name: string, looping: boolean): void {
+    if (!initialized) {
+        log("playMusic called but not initialized");
+        return;
+    }
+
+    // Stop any currently playing music
+    stopMusic();
+
+    // Clean up any stale socket file
+    try {
+        if (existsSync(musicSocketPath)) {
+            unlinkSync(musicSocketPath);
+        }
+    } catch (e) {
+        // Ignore
+    }
+
+    // Store music state for volume changes
+    currentMusicName = name;
+    currentMusicLooping = looping;
+
+    const musicPath = join(soundDir, `${name.toLowerCase()}.mp3`);
+    log(`Playing music: ${musicPath}, looping: ${looping}`);
+    const options: string[] = [
+        `--input-ipc-server=${musicSocketPath}`,  // Enable IPC for volume control
+    ];
+    if (looping) {
+        options.push("--loop=inf");
+    }
+
+    // Set volume (mpv uses 0-100 scale, DOOM uses 0-127)
+    const mpvVolume = Math.round((currentVolume / 127) * 100);
+    options.push(`--volume=${mpvVolume}`);
+
+    musicProcess = spawnMpv(musicPath, options);
+}
+
+/**
+ * Stop the currently playing music
+ */
+export function stopMusic(): void {
+    if (musicProcess) {
+        try {
+            musicProcess.kill("SIGTERM");
+        } catch (e) {
+            // Process may have already exited
+        }
+        activeProcesses.delete(musicProcess);
+        musicProcess = null;
+    }
+    currentMusicName = null;
+}
+
+/**
+ * Set music volume (0-127)
+ * Uses IPC socket to change volume without restarting music
+ */
+export function setMusicVolume(volume: number): void {
+    const newVolume = Math.max(0, Math.min(127, volume));
+    currentVolume = newVolume;
+
+    // If no music is playing, just save the volume for next play
+    if (!musicProcess || !currentMusicName) {
+        return;
+    }
+
+    // Convert to mpv volume (0-100)
+    const mpvVolume = Math.round((newVolume / 127) * 100);
+    log(`Setting music volume to ${mpvVolume} via IPC`);
+
+    // Send volume command via IPC socket
+    try {
+        const socket = createConnection(musicSocketPath);
+
+        socket.on("connect", () => {
+            const cmd = JSON.stringify({ command: ["set_property", "volume", mpvVolume] }) + "\n";
+            socket.write(cmd);
+            socket.end();
+        });
+
+        socket.on("error", (err) => {
+            log(`IPC socket error: ${err.message}`);
+        });
+    } catch (e) {
+        log(`Failed to send IPC command: ${e}`);
+    }
+}

package/src/doom-engine.ts

@@ -41,15 +41,30 @@ export interface DoomModule {
     getValue: (ptr: number, type: string) => number;
 }
 
+export interface DoomEngineOptions {
+    wadPath: string;
+    print?: (text: string) => void;
+    printErr?: (text: string) => void;
+}
+
 export class DoomEngine {
     private module: DoomModule | null = null;
     private frameBufferPtr: number = 0;
     private initialized: boolean = false;
     private wadPath: string;
-
-    constructor(wadPath: string) {
-        // Resolve to absolute path
-        this.wadPath = resolve(wadPath);
+    private print: (text: string) => void;
+    private printErr: (text: string) => void;
+
+    constructor(optionsOrPath: string | DoomEngineOptions) {
+        if (typeof optionsOrPath === "string") {
+            this.wadPath = resolve(optionsOrPath);
+            this.print = (text: string) => console.log('[DOOM]', text);
+            this.printErr = (text: string) => console.error('[DOOM]', text);
+        } else {
+            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));
+        }
     }
 
     async init(): Promise<void> {
@@ -64,6 +79,9 @@ export class DoomEngine {
         // Dynamic import of the compiled DOOM module
         const createDoomModule = require(doomJsPath);
 
+        // Import audio system
+        const audio = await import("./doom-audio");
+
         // Create module with proper callbacks
         const moduleConfig: any = {
             locateFile: (path: string) => {
@@ -72,8 +90,16 @@ export class DoomEngine {
                 }
                 return path;
             },
-            print: (text: string) => console.log('[DOOM]', text),
-            printErr: (text: string) => console.error('[DOOM]', text),
+            print: (text: string) => this.print(text),
+            printErr: (text: string) => this.printErr(text),
+
+            // Audio callbacks - called from C via EM_ASM
+            initAudio: () => audio.initAudio(),
+            shutdownAudio: () => audio.shutdownAudio(),
+            playSound: (name: string, volume: number) => audio.playSound(name, volume),
+            playMusic: (name: string, looping: boolean) => audio.playMusic(name, looping),
+            stopMusic: () => audio.stopMusic(),
+            setMusicVolume: (volume: number) => audio.setMusicVolume(volume),
 
             // preRun receives Module as first argument  
             preRun: [

package/src/doom-input.ts

@@ -80,8 +80,8 @@ function mapKeyToDoom(key: KeyEvent): number | null {
     if (name === "tab") return DoomKeys.KEY_TAB;
     if (name === "backspace") return DoomKeys.KEY_BACKSPACE;
 
-    // Fire (Ctrl)
-    if (key.ctrl) return DoomKeys.KEY_FIRE;
+    // 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;
@@ -128,8 +128,23 @@ function mapKeyToDoom(key: KeyEvent): number | null {
 // Track release timers for each key
 const keyTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
-export function createDoomInputHandler(engine: DoomEngine) {
+export interface DoomInputOptions {
+    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 doomKey = mapKeyToDoom(key);
 
         if (doomKey === null) return;

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 { shutdownAudio } from "./doom-audio";
 import { parseArgs } from "util";
 
 // Parse command line arguments
@@ -53,10 +54,25 @@ ${getControlsHelp()}
 
 // Initialize renderer
 const renderer = await createCliRenderer({
-  exitOnCtrlC: true,
+  exitOnCtrlC: false, // We handle exit manually to cleanup audio
   targetFps: 35, // DOOM's native framerate
 });
 
+// Handle graceful shutdown
+const cleanup = (signal?: string) => {
+  shutdownAudio();
+  try {
+    renderer.stop();
+  } catch (e) {
+    // Ignore error if renderer already stopped
+  }
+  process.exit(0);
+};
+
+process.on("SIGINT", () => cleanup("SIGINT"));
+process.on("SIGTERM", () => cleanup("SIGTERM"));
+process.on("exit", () => shutdownAudio());
+
 renderer.start();
 
 // Create UI container
@@ -117,7 +133,10 @@ async function initDoom() {
     renderer.root.add(controlsText);
 
     // Set up input handler
-    const inputHandler = createDoomInputHandler(doomEngine);
+    const inputHandler = createDoomInputHandler({
+      engine: doomEngine,
+      onExit: cleanup,
+    });
     renderer.keyInput.on("keypress", inputHandler);
 
     // Start game loop