feat: replace WormKit injection with custom launcher (openwa-launcher)

New binary crate `openwa-launcher` creates WA.exe in a suspended state,
injects openwa_wormkit.dll via CreateRemoteThread(LoadLibraryA), waits for
DllMain to complete (all hooks installed), then resumes the main thread.
This guarantees hooks are in place before a single WA instruction runs and
requires zero modifications to the game folder.

- WA.exe location: CLI arg > OPENWA_WA_PATH env var > Steam registry
- DLL location: always next to the launcher executable
- Forwards all CLI args (replay file etc.) to WA.exe
- Supports --minimized flag (used by replay-test.ps1)
- Remove deploy.ps1 / deploy-debug.ps1 (no longer needed)
- Update replay-test.ps1 to build + run via launcher; removes DLL copy step
- Update start-debug.ps1 to invoke launcher directly

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -1433,6 +1433,13 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "openwa-launcher"
+version = "0.1.0"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "openwa-wormkit"
 version = "0.1.0"

crates/openwa-launcher/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "openwa-launcher"
+version = "0.1.0"
+edition = "2021"
+description = "Launcher that injects openwa_wormkit.dll into WA.exe before its main thread runs"
+
+[[bin]]
+name = "openwa-launcher"
+path = "src/main.rs"
+
+[dependencies]
+windows-sys = { version = "0.59", features = [
+    "Win32_Foundation",
+    "Win32_System_Threading",
+    "Win32_System_Memory",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Registry",
+    "Win32_System_Diagnostics_Debug",
+] }

crates/openwa-launcher/src/inject.rs

@@ -0,0 +1,107 @@
+use std::ffi::CString;
+use std::mem;
+use std::ptr;
+
+// Declare only what we need directly, avoiding windows-sys feature-flag issues.
+#[allow(non_camel_case_types)]
+type HANDLE = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)]
+type LPVOID = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)]
+type LPCVOID = *const core::ffi::c_void;
+#[allow(non_camel_case_types)]
+type SIZE_T = usize;
+#[allow(non_camel_case_types)]
+type DWORD = u32;
+#[allow(non_camel_case_types)]
+type BOOL = i32;
+type FARPROC = unsafe extern "system" fn() -> isize;
+
+extern "system" {
+    fn VirtualAllocEx(
+        hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T,
+        flAllocationType: DWORD, flProtect: DWORD,
+    ) -> LPVOID;
+    fn VirtualFreeEx(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL;
+    fn WriteProcessMemory(
+        hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID,
+        nSize: SIZE_T, lpNumberOfBytesWritten: *mut SIZE_T,
+    ) -> BOOL;
+    fn GetModuleHandleA(lpModuleName: *const u8) -> HANDLE;
+    fn GetProcAddress(hModule: HANDLE, lpProcName: *const u8) -> Option<FARPROC>;
+    fn CreateRemoteThread(
+        hProcess: HANDLE, lpThreadAttributes: LPVOID, dwStackSize: SIZE_T,
+        lpStartAddress: unsafe extern "system" fn(LPVOID) -> DWORD,
+        lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: *mut DWORD,
+    ) -> HANDLE;
+    fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
+    fn CloseHandle(hObject: HANDLE) -> BOOL;
+}
+
+const MEM_COMMIT: DWORD  = 0x1000;
+const MEM_RESERVE: DWORD = 0x2000;
+const MEM_RELEASE: DWORD = 0x8000;
+const PAGE_READWRITE: DWORD = 0x04;
+const INFINITE: DWORD = 0xFFFF_FFFF;
+
+/// Inject `dll_path` into `process` by creating a remote thread that calls `LoadLibraryA`.
+///
+/// Blocks until `DllMain` returns (i.e. all hooks are installed) before returning,
+/// so the caller can safely resume the main thread.
+pub unsafe fn inject_dll(process: HANDLE, dll_path: &str) -> Result<(), String> {
+    let path_cstr = CString::new(dll_path)
+        .map_err(|e| format!("bad DLL path: {e}"))?;
+    let path_bytes = path_cstr.as_bytes_with_nul();
+
+    // Allocate memory in the target process for the DLL path string.
+    let remote_buf = VirtualAllocEx(
+        process, ptr::null_mut(), path_bytes.len(),
+        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE,
+    );
+    if remote_buf.is_null() {
+        return Err("VirtualAllocEx failed".to_string());
+    }
+
+    // Write the path into the target process.
+    let ok = WriteProcessMemory(
+        process, remote_buf,
+        path_bytes.as_ptr().cast(), path_bytes.len(),
+        ptr::null_mut(),
+    );
+    if ok == 0 {
+        VirtualFreeEx(process, remote_buf, 0, MEM_RELEASE);
+        return Err("WriteProcessMemory failed".to_string());
+    }
+
+    // LoadLibraryA lives at the same address in every process (kernel32 is always mapped
+    // at the same base across all processes on the same OS session due to ASLR sharing).
+    let k32 = GetModuleHandleA(b"kernel32.dll\0".as_ptr());
+    if k32.is_null() {
+        VirtualFreeEx(process, remote_buf, 0, MEM_RELEASE);
+        return Err("GetModuleHandleA(kernel32) failed".to_string());
+    }
+    let load_library = GetProcAddress(k32, b"LoadLibraryA\0".as_ptr());
+    let Some(load_library) = load_library else {
+        VirtualFreeEx(process, remote_buf, 0, MEM_RELEASE);
+        return Err("GetProcAddress(LoadLibraryA) failed".to_string());
+    };
+
+    // Spin up a remote thread that calls LoadLibraryA(dll_path).
+    // This triggers DllMain(DLL_PROCESS_ATTACH) which installs all our hooks.
+    let thread = CreateRemoteThread(
+        process, ptr::null_mut(), 0,
+        mem::transmute(load_library),
+        remote_buf, 0, ptr::null_mut(),
+    );
+    if thread.is_null() {
+        VirtualFreeEx(process, remote_buf, 0, MEM_RELEASE);
+        return Err("CreateRemoteThread failed".to_string());
+    }
+
+    // Wait for DllMain to finish — hooks are installed when this returns.
+    WaitForSingleObject(thread, INFINITE);
+    CloseHandle(thread);
+    VirtualFreeEx(process, remote_buf, 0, MEM_RELEASE);
+
+    Ok(())
+}

crates/openwa-launcher/src/main.rs

@@ -0,0 +1,302 @@
+mod inject;
+
+use std::ffi::CString;
+use std::mem;
+use std::path::{Path, PathBuf};
+use std::ptr;
+
+// Declare Win32 types and functions directly to avoid windows-sys feature-flag issues.
+#[allow(non_camel_case_types)] type HANDLE  = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)] type HKEY    = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)] type HMODULE = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)] type DWORD   = u32;
+#[allow(non_camel_case_types)] type BOOL    = i32;
+#[allow(non_camel_case_types)] type LONG    = i32;
+#[allow(non_camel_case_types)] type LPVOID  = *mut core::ffi::c_void;
+#[allow(non_camel_case_types)] type LPDWORD = *mut u32;
+
+#[repr(C)]
+#[allow(non_snake_case)]
+struct STARTUPINFOA {
+    cb: DWORD, lpReserved: *mut u8, lpDesktop: *mut u8, lpTitle: *mut u8,
+    dwX: DWORD, dwY: DWORD, dwXSize: DWORD, dwYSize: DWORD,
+    dwXCountChars: DWORD, dwYCountChars: DWORD, dwFillAttribute: DWORD,
+    dwFlags: DWORD, wShowWindow: u16, cbReserved2: u16,
+    lpReserved2: *mut u8, hStdInput: HANDLE, hStdOutput: HANDLE, hStdError: HANDLE,
+}
+
+#[repr(C)]
+#[allow(non_snake_case)]
+struct PROCESS_INFORMATION {
+    hProcess: HANDLE, hThread: HANDLE, dwProcessId: DWORD, dwThreadId: DWORD,
+}
+
+const CREATE_SUSPENDED: DWORD          = 0x0000_0004;
+const STARTF_USESHOWWINDOW: DWORD      = 0x0000_0001;
+const SW_SHOWMINIMIZED: u16            = 2;
+const INFINITE: DWORD                  = 0xFFFF_FFFF;
+const HKEY_LOCAL_MACHINE: HKEY         = -2isize as HKEY;
+const HKEY_CURRENT_USER: HKEY          = -1isize as HKEY;
+const KEY_READ: DWORD                  = 0x2_0019;
+const REG_SZ: DWORD                    = 1;
+
+#[link(name = "kernel32")]
+extern "system" {
+    fn CreateProcessA(
+        lpApplicationName: *const u8, lpCommandLine: *mut u8,
+        lpProcessAttributes: LPVOID, lpThreadAttributes: LPVOID,
+        bInheritHandles: BOOL, dwCreationFlags: DWORD,
+        lpEnvironment: LPVOID, lpCurrentDirectory: *const u8,
+        lpStartupInfo: *const STARTUPINFOA,
+        lpProcessInformation: *mut PROCESS_INFORMATION,
+    ) -> BOOL;
+    fn ResumeThread(hThread: HANDLE) -> DWORD;
+    fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
+    fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
+    fn TerminateProcess(hProcess: HANDLE, uExitCode: u32) -> BOOL;
+    fn CloseHandle(hObject: HANDLE) -> BOOL;
+    fn GetModuleFileNameA(hModule: HMODULE, lpFilename: *mut u8, nSize: DWORD) -> DWORD;
+}
+
+#[link(name = "advapi32")]
+extern "system" {
+    fn RegOpenKeyExA(
+        hKey: HKEY, lpSubKey: *const u8, ulOptions: DWORD,
+        samDesired: DWORD, phkResult: *mut HKEY,
+    ) -> LONG;
+    fn RegQueryValueExA(
+        hKey: HKEY, lpValueName: *const u8, lpReserved: *const DWORD,
+        lpType: *mut DWORD, lpData: *mut u8, lpcbData: *mut DWORD,
+    ) -> LONG;
+    fn RegCloseKey(hKey: HKEY) -> LONG;
+}
+
+fn main() {
+    if let Err(e) = run() {
+        eprintln!("openwa-launcher: error: {e}");
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), String> {
+    let args: Vec<String> = std::env::args().collect();
+
+    // Parse --minimized flag; collect remaining args as WA.exe args.
+    let mut minimized = false;
+    let mut wa_path_arg: Option<String> = None;
+    let mut wa_args: Vec<String> = Vec::new();
+
+    for arg in args.iter().skip(1) {
+        match arg.as_str() {
+            "--minimized" => minimized = true,
+            s if wa_path_arg.is_none() && !s.starts_with("--") => {
+                wa_path_arg = Some(s.to_string());
+            }
+            s => wa_args.push(s.to_string()),
+        }
+    }
+
+    // Locate WA.exe: explicit arg > env var > Steam registry.
+    let wa_exe = if let Some(p) = wa_path_arg {
+        PathBuf::from(p)
+    } else if let Ok(p) = std::env::var("OPENWA_WA_PATH") {
+        PathBuf::from(p)
+    } else {
+        find_wa_via_steam()
+            .ok_or("WA.exe not found. Set OPENWA_WA_PATH or pass the path as an argument.")?
+    };
+
+    if !wa_exe.exists() {
+        return Err(format!("WA.exe not found at: {}", wa_exe.display()));
+    }
+
+    // Locate the DLL: same directory as the launcher executable.
+    let dll_path = launcher_dir()?.join("openwa_wormkit.dll");
+    if !dll_path.exists() {
+        return Err(format!(
+            "openwa_wormkit.dll not found at: {}\nBuild with: cargo build --release -p openwa-wormkit",
+            dll_path.display()
+        ));
+    }
+
+    // WA.exe must run with its own folder as the working directory (relative paths for data/logs).
+    let wa_dir = wa_exe
+        .parent()
+        .ok_or("WA.exe path has no parent directory")?;
+
+    let cmdline = build_cmdline(&wa_exe, &wa_args);
+
+    println!(
+        "openwa-launcher: {} + {}",
+        wa_exe.display(),
+        dll_path.display()
+    );
+
+    unsafe { launch(&wa_exe, &cmdline, wa_dir, &dll_path, minimized) }
+}
+
+unsafe fn launch(
+    wa_exe: &Path,
+    cmdline: &str,
+    working_dir: &Path,
+    dll_path: &Path,
+    minimized: bool,
+) -> Result<(), String> {
+    let exe_cstr = path_to_cstring(wa_exe)?;
+    let mut cmdline_buf: Vec<u8> = cmdline.bytes().chain(std::iter::once(0u8)).collect();
+    let wd_cstr = path_to_cstring(working_dir)?;
+
+    let mut si: STARTUPINFOA = mem::zeroed();
+    si.cb = mem::size_of::<STARTUPINFOA>() as DWORD;
+    if minimized {
+        si.dwFlags |= STARTF_USESHOWWINDOW;
+        si.wShowWindow = SW_SHOWMINIMIZED;
+    }
+
+    let mut pi: PROCESS_INFORMATION = mem::zeroed();
+
+    let ok = CreateProcessA(
+        exe_cstr.as_ptr().cast(),
+        cmdline_buf.as_mut_ptr(),
+        ptr::null_mut(), ptr::null_mut(),
+        0, // bInheritHandles = FALSE
+        CREATE_SUSPENDED,
+        ptr::null_mut(), // inherit environment
+        wd_cstr.as_ptr().cast(),
+        &si,
+        &mut pi,
+    );
+
+    if ok == 0 {
+        return Err("CreateProcessA failed — is WA.exe path correct?".to_string());
+    }
+
+    let dll_str = dll_path
+        .to_str()
+        .ok_or("DLL path is not valid UTF-8")?;
+
+    if let Err(e) = inject::inject_dll(pi.hProcess, dll_str) {
+        TerminateProcess(pi.hProcess, 1);
+        CloseHandle(pi.hProcess);
+        CloseHandle(pi.hThread);
+        return Err(format!("DLL injection failed: {e}"));
+    }
+
+    // All hooks installed — let WA.exe run.
+    ResumeThread(pi.hThread);
+    CloseHandle(pi.hThread);
+
+    // Wait for WA.exe to exit, then propagate its exit code.
+    WaitForSingleObject(pi.hProcess, INFINITE);
+    let mut exit_code: DWORD = 0;
+    GetExitCodeProcess(pi.hProcess, &mut exit_code);
+    CloseHandle(pi.hProcess);
+
+    std::process::exit(exit_code as i32);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn launcher_dir() -> Result<PathBuf, String> {
+    let mut buf = vec![0u8; 32768];
+    let len = unsafe {
+        GetModuleFileNameA(ptr::null_mut(), buf.as_mut_ptr(), buf.len() as DWORD)
+    };
+    if len == 0 {
+        return Err("GetModuleFileNameA failed".to_string());
+    }
+    let path = PathBuf::from(
+        std::str::from_utf8(&buf[..len as usize])
+            .map_err(|e| format!("launcher path not UTF-8: {e}"))?,
+    );
+    path.parent()
+        .map(|p| p.to_path_buf())
+        .ok_or_else(|| "launcher path has no parent".to_string())
+}
+
+fn build_cmdline(exe: &Path, extra: &[String]) -> String {
+    let mut s = format!("\"{}\"", exe.display());
+    for arg in extra {
+        s.push(' ');
+        if arg.contains(' ') {
+            s.push('"');
+            s.push_str(arg);
+            s.push('"');
+        } else {
+            s.push_str(arg);
+        }
+    }
+    s
+}
+
+fn path_to_cstring(p: &Path) -> Result<CString, String> {
+    CString::new(
+        p.to_str()
+            .ok_or_else(|| format!("path not valid UTF-8: {}", p.display()))?,
+    )
+    .map_err(|e| format!("path contains nul byte: {e}"))
+}
+
+/// Try to find WA.exe via the Steam app registry entry (App ID 217200).
+fn find_wa_via_steam() -> Option<PathBuf> {
+    let candidates: &[(HKEY, &[u8])] = &[
+        (
+            HKEY_LOCAL_MACHINE,
+            b"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 217200\0",
+        ),
+        (
+            HKEY_LOCAL_MACHINE,
+            b"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 217200\0",
+        ),
+        (
+            HKEY_CURRENT_USER,
+            b"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 217200\0",
+        ),
+    ];
+
+    for &(hive, subkey) in candidates {
+        if let Some(install_dir) = read_reg_sz(hive, subkey, b"InstallLocation\0") {
+            let wa = PathBuf::from(&install_dir).join("WA.exe");
+            if wa.exists() {
+                return Some(wa);
+            }
+        }
+    }
+    None
+}
+
+fn read_reg_sz(hive: HKEY, subkey: &[u8], value: &[u8]) -> Option<String> {
+    unsafe {
+        let mut hkey: HKEY = ptr::null_mut();
+        let ret = RegOpenKeyExA(hive, subkey.as_ptr(), 0, KEY_READ, &mut hkey);
+        if ret != 0 {
+            return None;
+        }
+
+        let mut buf = vec![0u8; 4096];
+        let mut buf_len = buf.len() as DWORD;
+        let mut reg_type: DWORD = 0;
+
+        let ret = RegQueryValueExA(
+            hkey,
+            value.as_ptr(),
+            ptr::null(),
+            &mut reg_type,
+            buf.as_mut_ptr(),
+            &mut buf_len,
+        );
+        RegCloseKey(hkey);
+
+        if ret != 0 || reg_type != REG_SZ {
+            return None;
+        }
+
+        let s = std::str::from_utf8(&buf[..buf_len as usize])
+            .ok()?
+            .trim_end_matches('\0')
+            .to_string();
+        Some(s)
+    }
+}

deploy-debug.ps1

@@ -1,13 +0,0 @@
-$dest = "I:\games\SteamLibrary\steamapps\common\Worms Armageddon"
-
-cargo build --release -p openwa-wormkit --features debug-ui
-if ($LASTEXITCODE -ne 0) { exit 1 }
-
-$src = "target\i686-pc-windows-msvc\release"
-Copy-Item "$src\openwa_wormkit.dll" "$dest\wkOpenWA.dll"
-
-Write-Host "Deployed debug-ui build to $dest"
-Write-Host "Launch WA.exe with OPENWA_DEBUG_UI=1 to show the debug window."
-Write-Host ""
-Write-Host "Example:"
-Write-Host '  $env:OPENWA_DEBUG_UI=1; & "I:\games\SteamLibrary\steamapps\common\Worms Armageddon\WA.exe"'

deploy.ps1

@@ -1,9 +0,0 @@
-$dest = "I:\games\SteamLibrary\steamapps\common\Worms Armageddon"
-
-cargo build --release -p openwa-wormkit
-if ($LASTEXITCODE -ne 0) { exit 1 }
-
-$src = "target\i686-pc-windows-msvc\release"
-Copy-Item "$src\openwa_wormkit.dll" "$dest\wkOpenWA.dll"
-
-Write-Host "Deployed to $dest"

replay-test.ps1

@@ -7,10 +7,10 @@ param(
 
 $ErrorActionPreference = "Stop"
 
-$gameDir = "I:\games\SteamLibrary\steamapps\common\Worms Armageddon"
-$waExe = "$gameDir\WA.exe"
-$src = "target\i686-pc-windows-msvc\release"
-$logDir = "testdata\logs"
+$waExe   = if ($env:OPENWA_WA_PATH) { $env:OPENWA_WA_PATH } else { "I:\games\SteamLibrary\steamapps\common\Worms Armageddon\WA.exe" }
+$gameDir = Split-Path $waExe
+$src     = "target\i686-pc-windows-msvc\release"
+$logDir  = "testdata\logs"
 
 # Resolve replay file to absolute path
 if (-not [System.IO.Path]::IsPathRooted($ReplayFile)) {
@@ -22,43 +22,49 @@ if (-not (Test-Path $ReplayFile)) {
     exit 1
 }
 
-# 1. Build (single unified DLL)
+# 1. Build launcher + DLL
 Write-Host "Building..." -ForegroundColor Cyan
-cargo build --release -p openwa-wormkit
+cargo build --release -p openwa-launcher -p openwa-wormkit
 if ($LASTEXITCODE -ne 0) { exit 1 }
 
-# 2. Deploy
-Write-Host "Deploying to $gameDir..." -ForegroundColor Cyan
-Copy-Item "$src\openwa_wormkit.dll" "$gameDir\wkOpenWA.dll"
+$launcher = "$src\openwa-launcher.exe"
 
-# Remove old validator DLL if present (now unified)
+# 2. Clear old logs
+Remove-Item "$gameDir\OpenWA.log"            -ErrorAction SilentlyContinue
+Remove-Item "$gameDir\OpenWA_validation.log" -ErrorAction SilentlyContinue
+
+# Remove old WormKit DLL if present from a previous deployment
+if (Test-Path "$gameDir\wkOpenWA.dll") {
+    Write-Host "Note: removing legacy $gameDir\wkOpenWA.dll" -ForegroundColor Yellow
+    Remove-Item "$gameDir\wkOpenWA.dll"
+}
 if (Test-Path "$gameDir\wkOpenWAValidator.dll") {
     Remove-Item "$gameDir\wkOpenWAValidator.dll"
 }
 
-# 3. Clear old logs
-Remove-Item "$gameDir\OpenWA.log" -ErrorAction SilentlyContinue
-Remove-Item "$gameDir\OpenWA_validation.log" -ErrorAction SilentlyContinue
-
-# 4. Launch WA.exe with replay, env vars set
+# 3. Launch via launcher with replay, env vars set
 Write-Host "Launching WA.exe with replay: $ReplayFile" -ForegroundColor Cyan
 Write-Host "  (Fast-forward mode: replay will be auto-advanced, game exits when done)" -ForegroundColor Yellow
 
-$env:OPENWA_VALIDATE = "1"
+$env:OPENWA_VALIDATE    = "1"
 $env:OPENWA_REPLAY_TEST = "1"
-$proc = Start-Process -FilePath $waExe -ArgumentList "`"$ReplayFile`"" -WindowStyle Minimized -PassThru
-$timeout = 150  # seconds - replay fast-forward + safety margin
+$env:OPENWA_WA_PATH     = $waExe
+
+# The launcher blocks until WA.exe exits, so run it as a background job for timeout support.
+$proc = Start-Process -FilePath $launcher -ArgumentList "--minimized `"$ReplayFile`"" -PassThru
+$timeout = 150  # seconds
 if (-not $proc.WaitForExit($timeout * 1000)) {
-    Write-Host "WARNING: WA.exe did not exit within ${timeout}s, killing..." -ForegroundColor Red
+    Write-Host "WARNING: launcher did not exit within ${timeout}s, killing..." -ForegroundColor Red
     $proc.Kill()
     $proc.WaitForExit(5000)
 }
-$env:OPENWA_VALIDATE = $null
+$env:OPENWA_VALIDATE    = $null
 $env:OPENWA_REPLAY_TEST = $null
+$env:OPENWA_WA_PATH     = $null
 
-Write-Host "WA.exe exited with code $($proc.ExitCode)" -ForegroundColor Cyan
+Write-Host "Launcher exited with code $($proc.ExitCode)" -ForegroundColor Cyan
 
-# 5. Copy logs back
+# 4. Copy logs back
 if (-not (Test-Path $logDir)) {
     New-Item -ItemType Directory -Path $logDir | Out-Null
 }
@@ -79,13 +85,13 @@ if (Test-Path "$gameDir\OpenWA.log") {
     Write-Host "OpenWA log copied." -ForegroundColor Green
 }
 
-# 6. Print summary
+# 5. Print summary
 Write-Host ""
 Write-Host "=== Validation Summary ===" -ForegroundColor Cyan
 if (Test-Path "$logDir\validation_latest.log") {
     $content = Get-Content "$logDir\validation_latest.log" -Raw
     $passes = ([regex]::Matches($content, "\[PASS\]")).Count
-    $fails = ([regex]::Matches($content, "\[FAIL\]")).Count
+    $fails  = ([regex]::Matches($content, "\[FAIL\]")).Count
     Write-Host "  PASS: $passes" -ForegroundColor Green
     Write-Host "  FAIL: $fails" -ForegroundColor $(if ($fails -gt 0) { "Red" } else { "Green" })
 

start-debug.ps1

@@ -1,4 +1,2 @@
-$wa = "I:\games\SteamLibrary\steamapps\common\Worms Armageddon\WA.exe"
-
 $env:OPENWA_DEBUG_UI = "1"
-& $wa
+& "target\i686-pc-windows-msvc\release\openwa-launcher.exe"