feat: pure Rust DDGameWrapper__LoadSpeechWAV, typed struct fields

Replace the naked asm bridge to DDGameWrapper__LoadSpeechWAV (0x571530)
with a pure Rust implementation that uses typed struct field access.

Add speech_name_table (360 x 0x40-byte entries at +0x14E8) and
speech_name_count (+0x6EE8) fields to DDGameWrapper, eliminating all
pointer arithmetic from the speech WAV loading path.

Rename address constant DSSOUND_LOAD_SPEECH_WAV to
DDGAMEWRAPPER_LOAD_SPEECH_WAV and update Ghidra label to match
(function operates on DDGameWrapper, not DSSound).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/openwa-core/src/address.rs

@@ -402,11 +402,12 @@ pub mod va {
     /// 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.
-    /// Searches/allocates buffer slot, calls DSSound vtable to load WAV file.
+    /// DDGameWrapper__LoadSpeechWAV — loads a single speech WAV.
+    /// Searches DDGameWrapper's name table for existing buffer, reuses if found.
+    /// Otherwise calls DSSound vtable slot 12 (load_wav) to create new buffer.
     /// 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;
+    pub const DDGAMEWRAPPER_LOAD_SPEECH_WAV: u32 = 0x0057_1530;
 
     /// Loads all 126 SFX WAVs from data\wav\Effects\.
     /// stdcall(DDGame), RET 0x4.

crates/openwa-core/src/engine/ddgame.rs

@@ -251,7 +251,7 @@ pub struct DDGame {
     pub _unknown_77cc: [u8; 0x77E4 - 0x77CC],
 
     /// 0x77E4: Speech slot table. Maps (team, speech_line_id) → DSSound buffer index.
-    /// Cleared by DSSound_LoadAllSpeechBanks (0x571A70), filled by DSSound_LoadSpeechWAV (0x571530).
+    /// Cleared by DSSound_LoadAllSpeechBanks (0x571A70), filled by DDGameWrapper__LoadSpeechWAV (0x571530).
     pub speech_slot_table: SpeechSlotTable,
 
     /// 0x7D84-0x7E9F: Unknown

crates/openwa-core/src/engine/ddgame_wrapper.rs

@@ -3,6 +3,11 @@ use crate::engine::ddgame::DDGame;
 use crate::audio::dssound::DSSound;
 use crate::render::landscape::PCLandscape;
 
+/// Speech name table entry size (0x40 = 64 bytes, null-terminated C string).
+pub const SPEECH_NAME_ENTRY_SIZE: usize = 0x40;
+/// Maximum number of speech name entries.
+pub const SPEECH_NAME_TABLE_LEN: usize = 360;
+
 /// DDGameWrapper — large wrapper around DDGame.
 ///
 /// Created by DDGameWrapper__Constructor (0x56DEF0).
@@ -13,11 +18,7 @@ use crate::render::landscape::PCLandscape;
 /// Note: Ghidra shows DWORD-indexed offsets (param_2[0x122] etc.).
 /// Byte offset = dword_index * 4.
 ///
-/// The constructor accesses at least up to DWORD index 0x1BBA (byte offset 0x6EE8),
-/// making this object at least ~28KB. Total size is not yet determined.
-///
-/// PARTIAL: Only confirmed fields are defined. The repr(C) struct uses
-/// a conservative size that covers known fields. The actual object is larger.
+/// PARTIAL: Only confirmed fields are defined.
 #[repr(C)]
 pub struct DDGameWrapper {
     /// 0x000: Vtable pointer (0x66A30C)
@@ -48,13 +49,17 @@ pub struct DDGameWrapper {
     pub _field_4dc: u32,
     /// 0x4E0: Init -100 / 0xFFFFFF9C (DWORD index 0x138)
     pub _field_4e0: u32,
-    /// 0x4E4-0x6EEB: Unknown fields (extends to at least DWORD 0x1BBA)
-    pub _unknown_4e4: [u8; 0x6A08],
+    /// 0x4E4-0x14E7: Unknown fields
+    pub _unknown_4e4: [u8; 0x14E8 - 0x4E4],
+    /// 0x14E8: Speech name table — 360 entries of 0x40-byte C strings.
+    /// Used by DDGameWrapper__LoadSpeechWAV to deduplicate loaded WAVs.
+    pub speech_name_table: [[u8; SPEECH_NAME_ENTRY_SIZE]; SPEECH_NAME_TABLE_LEN],
+    /// 0x6EE8: Number of entries used in speech_name_table.
+    pub speech_name_count: u32,
     /// 0x6EEC: Init 0 (DWORD index 0x1BBA)
     pub _field_6eec: u32,
     /// 0x6EF0-end: Unknown trailing fields
     pub _unknown_6ef0: [u8; 0x10],
 }
 
-// This is a minimum estimate. The actual object is likely larger.
 const _: () = assert!(core::mem::size_of::<DDGameWrapper>() == 0x6F00);

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

@@ -238,39 +238,17 @@ unsafe extern "cdecl" fn play_fanfare_current_team_impl(index: u32) -> u32 {
 }
 
 // ============================================================
-// DSSound_LoadSpeechWAV wrapper (0x571530)
+// DDGameWrapper__LoadSpeechWAV — pure Rust (replaces 0x571530)
 // ============================================================
-// usercall(ESI=DDGameWrapper) + 4 stack(team_index, line_id, wav_path, full_path), RET 0x10.
-// Returns 1 on success, 0 on failure.
+// Searches DDGameWrapper's speech name table for existing WAV, reuses slot if found.
+// Otherwise calls DSSound vtable load_wav to load new WAV into a buffer.
+// Stores the buffer slot index in the SpeechSlotTable.
 
-/// 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.
+/// Pure Rust replacement for DDGameWrapper__LoadSpeechWAV (0x571530).
+///
+/// Searches the name table for `wav_path`. If found, reuses the existing
+/// buffer slot. Otherwise calls DSSound::load_wav to create a new buffer.
+/// Returns 1 on success, 0 on failure.
 unsafe fn call_load_speech_wav(
     ddgw: u32,
     team_index: u32,
@@ -278,14 +256,55 @@ unsafe fn call_load_speech_wav(
     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),
-    )
+    use openwa_core::audio::SpeechSlotTable;
+    use openwa_core::engine::DDGameWrapper;
+    use openwa_core::engine::ddgame_wrapper::SPEECH_NAME_ENTRY_SIZE;
+
+    let wrapper = &mut *(ddgw as *mut DDGameWrapper);
+    let count = wrapper.speech_name_count as usize;
+    let search_name = core::ffi::CStr::from_ptr(wav_path).to_bytes();
+
+    // Search name table for existing entry matching wav_path.
+    let mut found_idx: Option<usize> = None;
+    for i in 0..count {
+        let entry = &wrapper.speech_name_table[i];
+        // Compare up to the null terminator.
+        let entry_len = entry.iter().position(|&b| b == 0).unwrap_or(entry.len());
+        if entry[..entry_len] == *search_name {
+            found_idx = Some(i);
+            break;
+        }
+    }
+
+    let ddgame = &mut *wrapper.ddgame;
+    let slot_table = &mut ddgame.speech_slot_table;
+
+    if let Some(idx) = found_idx {
+        // Found existing — reuse the buffer slot.
+        slot_table.set(team_index as usize, line_id, idx as u32 + SpeechSlotTable::BUFFER_OFFSET);
+        return 1;
+    }
+
+    // Not found — load new WAV via DSSound vtable slot 12 (load_wav).
+    let slot_idx = count as u32 + SpeechSlotTable::BUFFER_OFFSET;
+    let vtable = (*wrapper.sound).vtable;
+    let result = ((*vtable).load_wav)(wrapper.sound, slot_idx as i32, full_path as *const u8);
+
+    if result != 0 {
+        // Success — store slot, copy name into table, increment count.
+        slot_table.set(team_index as usize, line_id, slot_idx);
+
+        // Copy wav_path into name table entry.
+        let dest = &mut wrapper.speech_name_table[count];
+        let copy_len = search_name.len().min(SPEECH_NAME_ENTRY_SIZE - 1);
+        dest[..copy_len].copy_from_slice(&search_name[..copy_len]);
+        dest[copy_len] = 0;
+
+        wrapper.speech_name_count = (count + 1) as u32;
+        return 1;
+    }
+
+    0 // failure
 }
 
 // ============================================================