feat: replace LoadSpeechBank and LoadAllSpeechBanks with full Rust implementations

Convert DSSound_LoadSpeechBank from passthrough to full replacement that
iterates the speech line table, builds WAV paths, calls LoadSpeechWAV,
and handles fallback to default speech directory. Add new
DSSound_LoadAllSpeechBanks hook that clears the speech slot table and
iterates teams. Introduce DDGameWrapperHandle typed wrapper in openwa-lib
and add speech_team_count field to GameInfo struct.

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

crates/openwa-lib/src/wa/ddgame.rs

@@ -0,0 +1,43 @@
+//! Typed handle for DDGameWrapper — the main game engine wrapper object.
+
+use openwa_types::ddgame::DDGame;
+use openwa_types::game_info::GameInfo;
+
+/// Zero-cost handle to a DDGameWrapper instance (raw pointer as u32).
+///
+/// DDGameWrapper is the top-level game engine object (~28KB). It holds
+/// the DDGame pointer, graphics handlers, landscape, and display state.
+///
+/// Pointer chain: DDGameWrapper → DDGame (+0x488) → GameInfo (+0x24).
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct DDGameWrapperHandle(pub u32);
+
+impl DDGameWrapperHandle {
+    /// Wrap a raw DDGameWrapper pointer.
+    pub unsafe fn from_raw(ptr: u32) -> Self {
+        Self(ptr)
+    }
+
+    /// Read the DDGame pointer from DDGameWrapper+0x488.
+    pub unsafe fn ddgame(self) -> *mut DDGame {
+        *((self.0 + 0x488) as *const *mut DDGame)
+    }
+
+    /// Follow DDGameWrapper → DDGame(+0x488) → GameInfo(+0x24).
+    ///
+    /// GameInfo holds team configuration, speech paths, replay state, etc.
+    /// Some fields are mapped in the struct; others require offset constants
+    /// from `game_info_offsets`.
+    pub unsafe fn game_info(self) -> *mut GameInfo {
+        let ddgame = self.ddgame() as u32;
+        *((ddgame + 0x24) as *const *mut GameInfo)
+    }
+
+    /// Pointer to the speech slot table (DDGame+0x77E4, 0x5A0 bytes).
+    ///
+    /// Maps (team_index, speech_line_id) → DSSound buffer index.
+    pub unsafe fn speech_slot_table(self) -> *mut u8 {
+        (self.ddgame() as u32 + 0x77E4) as *mut u8
+    }
+}

crates/openwa-lib/src/wa/mod.rs

@@ -1,5 +1,6 @@
 //! Typed wrappers for calling WA.exe and library functions.
 
+pub mod ddgame;
 pub mod frontend;
 pub mod mfc;
 pub mod registry;

crates/openwa-types/src/address.rs

@@ -294,16 +294,18 @@ pub mod va {
     /// 61 entries + null terminator. Maps speech line IDs to WAV filenames.
     pub const SPEECH_LINE_TABLE: u32 = 0x006A_F770;
 
-    /// Iterates teams, calls LoadSpeechBank for each. Clears DDGame+0x77E4
-    /// speech slot table. usercall(ESI=DDGame), plain RET.
+    /// Iterates teams, calls LoadSpeechBank for each. Clears DDGameWrapper+0x488→DDGame+0x77E4
+    /// speech slot table. usercall(ESI=DDGameWrapper), plain RET.
     pub const DSSOUND_LOAD_ALL_SPEECH_BANKS: u32 = 0x0057_1A70;
 
     /// Iterates speech line table, calls LoadSpeechWAV per entry.
-    /// usercall(EAX=DDGame) + 3 stack params, RET 0xC.
+    /// usercall(EAX=DDGameWrapper) + 3 stack(team_index, speech_base_path, speech_dir), RET 0xC.
     pub const DSSOUND_LOAD_SPEECH_BANK: u32 = 0x0057_1660;
 
     /// Loads a single speech WAV into DSSound buffer pool.
-    /// usercall(ESI=DDGame, EBX=DDGame) + 4 stack params, RET 0x10.
+    /// Searches/allocates buffer slot, calls DSSound vtable to load WAV file.
+    /// usercall(ESI=DDGameWrapper) + 4 stack(team_index, line_id, wav_path, full_path), RET 0x10.
+    /// Returns 1 on success, 0 on failure.
     pub const DSSOUND_LOAD_SPEECH_WAV: u32 = 0x0057_1530;
 
     /// Loads all 126 SFX WAVs from data\wav\Effects\.
@@ -657,6 +659,25 @@ pub mod va {
     // "game_state" in some code). Access pattern: *(DDGame+0x24) + offset.
 
     pub mod game_info_offsets {
+        // === Speech configuration ===
+
+        /// Number of teams with speech enabled (byte). Used by LoadAllSpeechBanks.
+        pub const SPEECH_TEAM_COUNT: u32 = 0x44C;
+        /// Per-team speech config stride (0xC2 = 0x81 base path + 0x41 dir name).
+        pub const SPEECH_TEAM_STRIDE: u32 = 0xC2;
+        /// Offset to per-team speech base path (char[0x81]).
+        /// Access: GameInfo + SPEECH_BASE_PATH + team_index * SPEECH_TEAM_STRIDE.
+        pub const SPEECH_BASE_PATH: u32 = 0xF486;
+        /// Offset to per-team speech directory name (char[0x41]).
+        /// Access: GameInfo + SPEECH_DIR + team_index * SPEECH_TEAM_STRIDE.
+        pub const SPEECH_DIR: u32 = 0xF507;
+        /// Default speech base path (for fallback when team-specific WAV not found).
+        pub const DEFAULT_SPEECH_BASE_PATH: u32 = 0xF3C4;
+        /// Default speech directory name (for fallback).
+        pub const DEFAULT_SPEECH_DIR: u32 = 0xF445;
+
+        // === Replay configuration ===
+
         /// Replay state flag A — checked by TurnGame_HurryHandler and FrameFinish.
         /// Both DB08 and DB0A must be non-zero for replay-mode hurry path.
         pub const REPLAY_STATE_FLAG_A: u32 = 0xDB08;

crates/openwa-types/src/game_info.rs

@@ -8,8 +8,17 @@
 /// The actual struct is likely larger. Conservative size 0xF500.
 #[repr(C)]
 pub struct GameInfo {
-    /// 0x0000-0xDAE7: Unknown
-    pub _unknown_0000: [u8; 0xDAE8],
+    /// 0x0000-0x044B: Unknown
+    pub _unknown_0000: [u8; 0x44C],
+
+    // --- Speech configuration ---
+
+    /// 0x044C: Number of teams with speech banks loaded (byte).
+    /// Used by DSSound_LoadAllSpeechBanks to iterate teams.
+    pub speech_team_count: u8,
+
+    /// 0x044D-0xDAE7: Unknown
+    pub _unknown_044d: [u8; 0xDAE8 - 0x44D],
 
     // --- Cluster 1: data paths ---
 

crates/openwa-wormkit/src/replacements/speech.rs

@@ -4,7 +4,8 @@
 //! - PlayFeSfx (0x4D7960): stdcall(sfx_name), RET 0x4 — REPLACED
 //! - PlayFanfare_Default (0x4D7500): stdcall(team_type), RET 0x4 — REPLACED
 //! - PlayFanfare_CurrentTeam (0x4D78E0): usercall(EAX=index), plain RET — passthrough
-//! - DSSound_LoadSpeechBank (0x571660): usercall(EAX=DDGame) + 3 stack, RET 0xC — passthrough
+//! - DSSound_LoadSpeechBank (0x571660): usercall(EAX=DDGameWrapper) + 3 stack, RET 0xC — REPLACED
+//! - DSSound_LoadAllSpeechBanks (0x571A70): usercall(ESI=DDGameWrapper), plain RET — REPLACED
 
 use std::ffi::{c_char, CStr};
 use std::sync::atomic::{AtomicU32, Ordering};
@@ -12,7 +13,9 @@ use std::sync::atomic::{AtomicU32, Ordering};
 use heapless::CString;
 
 use openwa_lib::rebase::rb;
-use openwa_types::address::va;
+use openwa_lib::wa::ddgame::DDGameWrapperHandle;
+use openwa_types::address::va::{self, game_info_offsets};
+use openwa_types::speech::SpeechLineTableEntry;
 
 use crate::hook::{self, usercall_trampoline};
 use crate::log_line;
@@ -235,55 +238,210 @@ unsafe extern "cdecl" fn play_fanfare_current_team_impl(index: u32) -> u32 {
 }
 
 // ============================================================
-// DSSound_LoadSpeechBank passthrough (0x571660)
+// DSSound_LoadSpeechWAV wrapper (0x571530)
 // ============================================================
-// usercall(EAX=DDGame) + 3 stack params (team_index, speech_path, speech_dir)
-// RET 0xC
+// usercall(ESI=DDGameWrapper) + 4 stack(team_index, line_id, wav_path, full_path), RET 0x10.
+// Returns 1 on success, 0 on failure.
+
+/// cdecl(ddgw, team_index, line_id, wav_path, full_path, func_addr) -> u32
+/// Sets ESI=ddgw, pushes 4 stack params in order, calls func (RET 0x10 cleans them).
+#[unsafe(naked)]
+unsafe extern "cdecl" fn load_speech_wav_raw(
+    _ddgw: u32,
+    _team_index: u32,
+    _line_id: u32,
+    _wav_path: *const u8,
+    _full_path: *const u8,
+    _func: u32,
+) -> u32 {
+    // After push esi: ESP+0=saved_esi, +4=retaddr, +8=ddgw, +12=team,
+    //   +16=line_id, +20=wav_path, +24=full_path, +28=func
+    core::arch::naked_asm!(
+        "push esi",
+        "mov esi, [esp + 8]",          // ESI = ddgw
+        "push dword ptr [esp + 24]",   // full_path  (+4 shift each push)
+        "push dword ptr [esp + 24]",   // wav_path
+        "push dword ptr [esp + 24]",   // line_id
+        "push dword ptr [esp + 24]",   // team_index
+        "call dword ptr [esp + 44]",   // func (offset = 28 + 16 from 4 pushes)
+        // RET 0x10 cleans the 4 params; ESP back to after push esi
+        "pop esi",
+        "ret",
+    );
+}
+
+/// Call DSSound_LoadSpeechWAV with the given parameters.
+unsafe fn call_load_speech_wav(
+    ddgw: u32,
+    team_index: u32,
+    line_id: u32,
+    wav_path: *const c_char,
+    full_path: *const c_char,
+) -> u32 {
+    load_speech_wav_raw(
+        ddgw,
+        team_index,
+        line_id,
+        wav_path as *const u8,
+        full_path as *const u8,
+        rb(va::DSSOUND_LOAD_SPEECH_WAV),
+    )
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+/// Extract bytes from a null-terminated C string pointer.
+unsafe fn cstr_bytes<'a>(ptr: *const u8) -> &'a [u8] {
+    if ptr.is_null() {
+        return &[];
+    }
+    CStr::from_ptr(ptr as *const i8).to_bytes()
+}
 
-static ORIG_LOAD_SPEECH_BANK: AtomicU32 = AtomicU32::new(0);
+// ============================================================
+// DSSound_LoadSpeechBank replacement (0x571660)
+// ============================================================
+// usercall(EAX=DDGameWrapper) + 3 stack params (team_index, speech_base_path, speech_dir)
+// RET 0xC
+//
+// Iterates the speech line table at 0x6AF770. For each entry, builds WAV paths
+// and calls LoadSpeechWAV. Falls back to default speech dir on failure.
+// Skips remaining filename alternates when one succeeds.
 
 usercall_trampoline!(fn trampoline_load_speech_bank; impl_fn = load_speech_bank_impl;
     reg = eax; stack_params = 3; ret_bytes = "0xC");
 
 unsafe extern "cdecl" fn load_speech_bank_impl(
-    ddgame: u32,
+    ddgw: DDGameWrapperHandle,
     team_index: u32,
-    speech_path: *const u8,
+    speech_base_path: *const u8,
     speech_dir: *const u8,
 ) {
-    let path_str = if !speech_path.is_null() {
-        CStr::from_ptr(speech_path as *const i8)
-            .to_str()
-            .unwrap_or("?")
-    } else {
-        "(null)"
-    };
-    let dir_str = if !speech_dir.is_null() {
-        CStr::from_ptr(speech_dir as *const i8)
-            .to_str()
-            .unwrap_or("?")
-    } else {
-        "(null)"
-    };
+    let path_str = CStr::from_ptr(speech_base_path as *const i8)
+        .to_str()
+        .unwrap_or("?");
+    let dir_str = CStr::from_ptr(speech_dir as *const i8)
+        .to_str()
+        .unwrap_or("?");
     let _ = log_line(&format!(
-        "[Speech] LoadSpeechBank: team={} path=\"{}\" dir=\"{}\" ddgame=0x{:08X}",
-        team_index, path_str, dir_str, ddgame
+        "[Speech] LoadSpeechBank: team={} path=\"{}\" dir=\"{}\" ddgw=0x{:08X}",
+        team_index, path_str, dir_str, ddgw.0
     ));
 
-    // Call original via trampoline — must restore EAX and push stack params
-    let orig = ORIG_LOAD_SPEECH_BANK.load(Ordering::Relaxed);
-    core::arch::asm!(
-        "push {dir}",
-        "push {path}",
-        "push {team}",
-        "call {orig}",
-        team = in(reg) team_index,
-        path = in(reg) speech_path,
-        dir = in(reg) speech_dir,
-        orig = in(reg) orig,
-        in("eax") ddgame,
-        clobber_abi("C"),
-    );
+    let table_base = rb(va::SPEECH_LINE_TABLE) as *const SpeechLineTableEntry;
+    let mut i: usize = 0;
+
+    loop {
+        let entry = &*table_base.add(i);
+
+        // Null name_ptr = end of table
+        if entry.name_ptr.is_null() {
+            return;
+        }
+
+        let name_bytes = cstr_bytes(entry.name_ptr);
+
+        // Build wav_path: "<speech_dir>\<name>.wav"
+        let mut wav_path = CString::<MAX_PATH>::new();
+        let _ = wav_path.extend_from_bytes(cstr_bytes(speech_dir));
+        let _ = wav_path.extend_from_bytes(b"\\");
+        let _ = wav_path.extend_from_bytes(name_bytes);
+        let _ = wav_path.extend_from_bytes(b".wav");
+
+        // Build full_path: "<speech_base_path>\<wav_path>"
+        let mut full_path = CString::<MAX_PATH>::new();
+        let _ = full_path.extend_from_bytes(cstr_bytes(speech_base_path));
+        let _ = full_path.extend_from_bytes(b"\\");
+        let _ = full_path.extend_from_bytes(wav_path.as_bytes());
+
+        let result = call_load_speech_wav(
+            ddgw.0,
+            team_index,
+            entry.id,
+            wav_path.as_ptr(),
+            full_path.as_ptr(),
+        );
+
+        if result == 0 {
+            // Failed — try fallback with default speech dir if no more alternates
+            let next_entry = &*table_base.add(i + 1);
+            if next_entry.name_ptr.is_null() || next_entry.id != entry.id {
+                let game_info = ddgw.game_info() as *const u8;
+                let default_dir =
+                    game_info.add(game_info_offsets::DEFAULT_SPEECH_DIR as usize);
+                let default_base =
+                    game_info.add(game_info_offsets::DEFAULT_SPEECH_BASE_PATH as usize);
+
+                let mut wav_path2 = CString::<MAX_PATH>::new();
+                let _ = wav_path2.extend_from_bytes(cstr_bytes(default_dir));
+                let _ = wav_path2.extend_from_bytes(b"\\");
+                let _ = wav_path2.extend_from_bytes(name_bytes);
+                let _ = wav_path2.extend_from_bytes(b".wav");
+
+                let mut full_path2 = CString::<MAX_PATH>::new();
+                let _ = full_path2.extend_from_bytes(cstr_bytes(default_base));
+                let _ = full_path2.extend_from_bytes(b"\\");
+                let _ = full_path2.extend_from_bytes(wav_path2.as_bytes());
+
+                call_load_speech_wav(
+                    ddgw.0,
+                    team_index,
+                    entry.id,
+                    wav_path2.as_ptr(),
+                    full_path2.as_ptr(),
+                );
+            }
+        } else {
+            // Success — skip remaining filename alternates for this ID
+            let current_id = entry.id;
+            while {
+                let next = &*table_base.add(i + 1);
+                !next.name_ptr.is_null() && next.id == current_id
+            } {
+                i += 1;
+            }
+        }
+
+        i += 1;
+    }
+}
+
+// ============================================================
+// DSSound_LoadAllSpeechBanks replacement (0x571A70)
+// ============================================================
+// usercall(ESI=DDGameWrapper), plain RET.
+// Clears the speech slot table, then iterates teams and calls LoadSpeechBank.
+
+usercall_trampoline!(fn trampoline_load_all_speech_banks;
+    impl_fn = load_all_speech_banks_impl; reg = esi);
+
+unsafe extern "cdecl" fn load_all_speech_banks_impl(ddgw: DDGameWrapperHandle) {
+    // Clear speech slot table: DDGame+0x77E4, 0x5A0 bytes
+    core::ptr::write_bytes(ddgw.speech_slot_table(), 0, 0x5A0);
+
+    // Read team count from GameInfo
+    let game_info = ddgw.game_info();
+    let team_count = (*game_info).speech_team_count as u32;
+
+    let _ = log_line(&format!(
+        "[Speech] LoadAllSpeechBanks: ddgw=0x{:08X} teams={}",
+        ddgw.0, team_count
+    ));
+
+    // Load speech bank for each team
+    let gi = game_info as *const u8;
+    for i in 0..team_count {
+        let team_offset = (i * game_info_offsets::SPEECH_TEAM_STRIDE) as usize;
+        let base_path =
+            gi.add(game_info_offsets::SPEECH_BASE_PATH as usize + team_offset);
+        let dir =
+            gi.add(game_info_offsets::SPEECH_DIR as usize + team_offset);
+
+        // Call our Rust impl directly (bypasses the hook trampoline)
+        load_speech_bank_impl(ddgw, i, base_path, dir);
+    }
 }
 
 // ============================================================
@@ -311,12 +469,19 @@ pub fn install() -> Result<(), String> {
         )?;
         ORIG_PLAY_FANFARE_CURRENT_TEAM.store(trampoline as u32, Ordering::Relaxed);
 
-        let trampoline = hook::install(
+        // Full replacement — no trampoline needed
+        hook::install(
             "DSSound_LoadSpeechBank",
             va::DSSOUND_LOAD_SPEECH_BANK,
             trampoline_load_speech_bank as *const (),
         )?;
-        ORIG_LOAD_SPEECH_BANK.store(trampoline as u32, Ordering::Relaxed);
+
+        // Full replacement — no trampoline needed
+        hook::install(
+            "DSSound_LoadAllSpeechBanks",
+            va::DSSOUND_LOAD_ALL_SPEECH_BANKS,
+            trampoline_load_all_speech_banks as *const (),
+        )?;
     }
 
     Ok(())

deploy.ps1

@@ -1,10 +1,9 @@
 $dest = "I:\games\SteamLibrary\steamapps\common\Worms Armageddon"
 
-cargo build --release -p openwa-wormkit -p openwa-validator
+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"
-Copy-Item "$src\openwa_validator.dll" "$dest\wkOpenWAValidator.dll"
 
 Write-Host "Deployed to $dest"