feat: define DSSoundVtable (24 slots) and patch is_slot_loaded to Rust

Add typed DSSoundVtable struct with all 24 virtual method signatures,
named from decompilation analysis (update_channels, play_sound,
set_master_volume, load_wav, stop_channel, etc.).

Refine ChannelDescriptor fields from vtable method analysis: flags_a/b,
volume_num/val, ds_buffer, pool_index. Rename buffer pool fields to
reflect free-list/used-list semantics. Rename _field_bb0 to
total_bytes_loaded (incremented by load_wav).

Implement is_slot_loaded (slot 13) in Rust and patch it into WA's
DSSound vtable via patch_vtable.

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

crates/openwa-core/src/audio/dssound.rs

@@ -3,8 +3,8 @@ use crate::fixed::Fixed;
 /// DSSound — DirectSound audio subsystem.
 ///
 /// Created by DSSound__Constructor (0x573D50).
-/// Vtable: 0x66AF20
-/// Size: 0xBE0 bytes (allocated by GameEngine__InitHardware).
+/// Vtable: 0x66AF20 (24 slots).
+/// Size: 0xBE0 bytes.
 ///
 /// Manages sound playback through DirectSound.
 /// Has 8 channel descriptors, 500 sound channel slots, a 64-entry
@@ -13,23 +13,90 @@ use crate::fixed::Fixed;
 type Ptr32 = u32;
 
 /// Channel descriptor (0x18 bytes). 8 entries at DSSound+0x14.
-/// FUN_005742A0 initializes: field_00=-1, field_04=-1, field_10=0.
+///
+/// Each descriptor tracks one active DirectSound buffer being played.
+/// Fields identified from vtable methods (update_channels, set_volume, etc.).
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct ChannelDescriptor {
-    pub field_00: u32,   // init -1
-    pub field_04: u32,   // init -1
-    pub _pad_08: [u32; 2],
-    pub field_10: u32,   // init 0
-    pub _pad_14: u32,
+    /// Flags A (init -1, -1 = unused/free)
+    pub flags_a: i32,
+    /// Flags B (init -1, checked for < 0 in update_channels)
+    pub flags_b: i32,
+    /// Volume numerator (used in volume calculations, 0 = default)
+    pub volume_num: i32,
+    /// Volume value (scaled, used by set_channel_volume)
+    pub volume_val: i32,
+    /// IDirectSoundBuffer* for the active buffer on this channel (0 = empty)
+    pub ds_buffer: Ptr32,
+    /// Pool index tracking which buffer pool entry this channel uses
+    pub pool_index: u32,
 }
 
 const _: () = assert!(core::mem::size_of::<ChannelDescriptor>() == 0x18);
 
+/// DSSound vtable layout (24 slots at 0x66AF20).
+///
+/// Methods operate on the 8 channel descriptors and 64-entry buffer pool.
+/// Trivial slots (stubs, noops, return-constant) are marked.
+#[repr(C)]
+pub struct DSSoundVtable {
+    /// Slot 0 (0x573DB0): destructor — thiscall(this, flags)
+    pub destructor: unsafe extern "thiscall" fn(*mut DSSound, u8) -> *mut DSSound,
+    /// Slot 1 (0x574400): update_channels — iterates 8 descs, releases finished buffers
+    pub update_channels: unsafe extern "thiscall" fn(*mut DSSound),
+    /// Slot 2 (0x574460): set_volume_params — sets status_1/2, adjusts channel volumes
+    pub set_volume_params: unsafe extern "thiscall" fn(*mut DSSound, u32, i32),
+    /// Slot 3 (0x574730): play_sound — wrapper around core play, returns bool
+    pub play_sound: unsafe extern "thiscall" fn(*mut DSSound, u32, u32, u32, u32) -> bool,
+    /// Slot 4 (0x574770): play_sound_pooled — allocates from buffer pool, plays
+    pub play_sound_pooled: unsafe extern "thiscall" fn(*mut DSSound, u32, u32, u32, u32, u32) -> i32,
+    /// Slot 5 (0x574900): set_pan — sets pan on channel (dB lookup)
+    pub set_pan: unsafe extern "thiscall" fn(*mut DSSound, u32, u32) -> u32,
+    /// Slot 6 (0x505430): **stub** — returns 0
+    pub stub_6: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 7 (0x574A10): set_master_volume — sets volume, adjusts all channels
+    pub set_master_volume: unsafe extern "thiscall" fn(*mut DSSound, i32) -> u32,
+    /// Slot 8 (0x574980): set_channel_volume — volume on specific channel
+    pub set_channel_volume: unsafe extern "thiscall" fn(*mut DSSound, i32, i32) -> u32,
+    /// Slot 9 (0x5747F0): is_channel_playing — checks buffer status
+    pub is_channel_playing: unsafe extern "thiscall" fn(*mut DSSound, i32) -> u8,
+    /// Slot 10 (0x574840): stop_channel — stops + releases buffer, returns to pool
+    pub stop_channel: unsafe extern "thiscall" fn(*mut DSSound, i32) -> u32,
+    /// Slot 11 (0x574AB0): release_finished — releases finished buffers, returns count
+    pub release_finished: unsafe extern "thiscall" fn(*mut DSSound) -> i32,
+    /// Slot 12 (0x573FF0): load_wav — opens WAV file, parses RIFF, creates buffer
+    pub load_wav: unsafe extern "thiscall" fn(*mut DSSound, i32, *const u8) -> u32,
+    /// Slot 13 (0x573FD0): is_slot_loaded — returns channel_slots[idx] != 0
+    pub is_slot_loaded: unsafe extern "thiscall" fn(*mut DSSound, i32) -> bool,
+    /// Slot 14 (0x573D30): sub_destructor — sets secondary vtable
+    pub sub_destructor: unsafe extern "thiscall" fn(*mut DSSound, u8) -> *mut DSSound,
+    /// Slot 15 (0x4AA060): **noop** — returns void
+    pub noop_15: unsafe extern "thiscall" fn(*mut DSSound),
+    /// Slot 16 (0x5931C0): **noop** — returns void
+    pub noop_16: unsafe extern "thiscall" fn(*mut DSSound),
+    /// Slot 17 (0x573D20): **returns_0**
+    pub returns_0_17: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 18 (0x573D20): **returns_0** (same as 17)
+    pub returns_0_18: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 19 (0x505430): **stub** — returns 0
+    pub stub_19: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 20 (0x505430): **stub** — returns 0
+    pub stub_20: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 21 (0x571AF0): **returns_0**
+    pub returns_0_21: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 22 (0x505430): **stub** — returns 0
+    pub stub_22: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+    /// Slot 23 (0x4260E0): **returns_1**
+    pub returns_1_23: unsafe extern "thiscall" fn(*mut DSSound) -> u32,
+}
+
+const _: () = assert!(core::mem::size_of::<DSSoundVtable>() == 24 * 4);
+
 #[repr(C)]
 pub struct DSSound {
     /// 0x000: Vtable pointer (0x66AF20)
-    pub vtable: Ptr32,
+    pub vtable: *const DSSoundVtable,
     /// 0x004: HWND (set after construction)
     pub hwnd: Ptr32,
     /// 0x008: IDirectSound* (from DirectSoundCreate)
@@ -40,25 +107,30 @@ pub struct DSSound {
     pub primary_buffer: Ptr32,
     /// 0x014-0xD3: 8 channel descriptors (0x18 bytes each = 0xC0 total)
     pub channel_descs: [ChannelDescriptor; 8],
-    /// 0x0D4-0x8A3: 500 channel slot indices (zeroed by constructor)
+    /// 0x0D4-0x8A3: 500 channel slot indices (zeroed by constructor).
+    /// Each slot holds a pointer to an IDirectSoundBuffer for that sound effect.
+    /// Index is 1-based (slot 0 unused). slot[i] != 0 means sound i is loaded.
     pub channel_slots: [u32; 500],
     /// 0x8A4: Master volume (Fixed, init 0x10000 = 1.0)
     pub volume: Fixed,
-    /// 0x8A8-0x9A7: 64 buffer pool shadow entries (init all -1 by FUN_00574260)
-    pub buffer_pool_shadow: [u32; 64],
-    /// 0x9A8-0xAA7: 64 buffer pool indices (init 0..63 by FUN_00574260)
-    pub buffer_pool: [u32; 64],
-    /// 0xAA8: Buffer pool count (init 0x40 = 64)
-    pub buffer_pool_count: u32,
-    /// 0xAAC-0xBAB: Unknown (0x100 bytes)
-    pub _unknown_aac: [u8; 0x100],
-    /// 0xBAC: Buffer pool state (init 0 by FUN_00574260)
-    pub buffer_pool_state: u32,
-    /// 0xBB0: Unknown field (zeroed by constructor)
-    pub _field_bb0: u32,
-    /// 0xBB4: Status flag 1 (init 1)
+    /// 0x8A8-0x9A7: 64 buffer pool shadow entries (init all -1 by FUN_00574260).
+    /// Maps pool index → channel descriptor index (-1 = free).
+    pub buffer_pool_shadow: [i32; 64],
+    /// 0x9A8-0xAA7: 64 buffer pool indices (init 0..63 by FUN_00574260).
+    /// Free-list stack of available pool indices.
+    pub buffer_pool_free: [u32; 64],
+    /// 0xAA8: Number of free entries in buffer_pool_free (init 0x40 = 64).
+    pub buffer_pool_free_count: u32,
+    /// 0xAAC-0xBAB: Used pool tracking (0x100 bytes = 64 u32 entries).
+    /// Tracks which pool indices are in use.
+    pub buffer_pool_used: [u32; 64],
+    /// 0xBAC: Number of used entries in buffer_pool_used (init 0).
+    pub buffer_pool_used_count: u32,
+    /// 0xBB0: Total bytes loaded (incremented by load_wav)
+    pub total_bytes_loaded: u32,
+    /// 0xBB4: Status flag 1 (init 1, used by set_volume_params)
     pub status_1: u32,
-    /// 0xBB8: Status flag 2 (init 1)
+    /// 0xBB8: Status flag 2 (init 1, used by set_volume_params)
     pub status_2: u32,
     /// 0xBBC: Init success flag — set to 1 when DirectSoundCreate +
     /// init_buffers + IDirectSoundBuffer::Play all succeed.
@@ -69,6 +141,16 @@ pub struct DSSound {
 
 const _: () = assert!(core::mem::size_of::<DSSound>() == 0xBE0);
 
+// ── Trivial vtable method implementations ─────────────────────────────────
+
+/// Slot 13: is_slot_loaded — returns whether sound at `slot_idx` has a buffer loaded.
+/// One-liner: `channel_slots[slot_idx] != 0`.
+pub unsafe extern "thiscall" fn is_slot_loaded(this: *mut DSSound, slot_idx: i32) -> bool {
+    (*this).channel_slots.get((slot_idx - 1) as usize).copied().unwrap_or(0) != 0
+}
+
+// ── Construction ──────────────────────────────────────────────────────────
+
 impl DSSound {
     /// Construct a DSSound with all fields initialized, matching the
     /// original constructor (0x573D50) + helpers FUN_005742A0/FUN_00574260.
@@ -84,7 +166,7 @@ impl DSSound {
         let mut snd: Self = core::mem::zeroed();
 
         // Vtable (WA's .rdata, identity-checked)
-        snd.vtable = rb(va::DS_SOUND_VTABLE);
+        snd.vtable = rb(va::DS_SOUND_VTABLE) as *const DSSoundVtable;
 
         // HWND
         snd.hwnd = hwnd;
@@ -92,23 +174,23 @@ impl DSSound {
         // Volume = 1.0 (16.16 fixed-point)
         snd.volume = Fixed(0x10000);
 
-        // 8 channel descriptors: field_00=-1, field_04=-1, field_10=0
+        // 8 channel descriptors: flags_a=-1, flags_b=-1
         // (rest is zero from mem::zeroed)
         for desc in &mut snd.channel_descs {
-            desc.field_00 = 0xFFFF_FFFF;
-            desc.field_04 = 0xFFFF_FFFF;
+            desc.flags_a = -1;
+            desc.flags_b = -1;
         }
 
         // 500 channel slots: already zeroed
 
-        // Buffer pool: shadow entries all -1, indices 0..63
-        for (i, slot) in snd.buffer_pool.iter_mut().enumerate() {
+        // Buffer pool: shadow all -1, free list 0..63
+        for (i, slot) in snd.buffer_pool_free.iter_mut().enumerate() {
             *slot = i as u32;
         }
         for entry in &mut snd.buffer_pool_shadow {
-            *entry = 0xFFFF_FFFF;
+            *entry = -1;
         }
-        snd.buffer_pool_count = 64;
+        snd.buffer_pool_free_count = 64;
 
         // Status flags
         snd.status_1 = 1;

crates/openwa-core/src/audio/mod.rs

@@ -6,7 +6,7 @@ pub mod speech;
 pub mod streaming;
 
 pub use active_sound::{ActiveSoundEntry, ActiveSoundTable};
-pub use dssound::DSSound;
+pub use dssound::{DSSound, DSSoundVtable, ChannelDescriptor, is_slot_loaded};
 pub use music::Music;
 pub use sound::SoundId;
 pub use speech::{SpeechLineId, SpeechLineTableEntry, SpeechSlotTable, SPEECH_LINE_TABLE_COUNT};

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

@@ -155,7 +155,31 @@ pub fn install() -> Result<(), String> {
             va::PLAY_SOUND_LOCAL,
             trampoline_play_sound_local as *const (),
         )?;
+
+        // Patch DSSound vtable: replace trivial slots with Rust implementations.
+        patch_dssound_vtable()?;
     }
 
     Ok(())
 }
+
+/// Patch DSSound vtable (0x66AF20) to replace trivial methods with Rust.
+unsafe fn patch_dssound_vtable() -> Result<(), String> {
+    use openwa_core::rebase::rb;
+    use openwa_core::vtable::patch_vtable;
+    use openwa_core::audio::is_slot_loaded;
+
+    let vtable = rb(va::DS_SOUND_VTABLE) as *mut u32;
+
+    patch_vtable(vtable, 24, |vt| {
+        let mut patched = 0u32;
+
+        // Slot 13: is_slot_loaded — one-liner channel_slots check
+        *vt.add(13) = is_slot_loaded as *const () as u32;
+        patched += 1;
+
+        let _ = log_line(&format!(
+            "[Sound]   DSSound vtable: patched {patched}/24 slots with Rust"
+        ));
+    }).map_err(|e| e.to_string())
+}