fix: correct slot 9 return value, enable slots 1, 9, 10, 11

Slot 9 was named is_channel_playing but actually implements
is_channel_finished: the original inverts DSBSTATUS_PLAYING via
NOT+AND (playing→0, stopped→1). Our code returned 1 for playing,
causing callers to think channels were free and immediately reuse
them — killing all sound playback.

Rename to is_channel_finished with correct semantics. Re-enable
slots 1 (update_channels), 10 (stop_channel), 11 (release_finished)
which all work correctly with the fixed descriptor layout.

17/24 DSSound vtable slots now Rust.

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

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

@@ -84,8 +84,8 @@ pub struct DSSoundVtable {
     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 9 (0x5747F0): is_channel_finished — returns 1 if stopped, 0 if playing
+    pub is_channel_finished: 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
@@ -241,19 +241,35 @@ pub unsafe extern "thiscall" fn sub_destructor(
     this
 }
 
-/// Slot 9: is_channel_playing — checks if a buffer pool entry's GetStatus succeeds.
-/// `pool_id` is 1-based (1..64). Returns 0 only for out-of-range pool_id.
-/// Original always returns 1 unless pool_id is invalid — it checks whether
-/// GetStatus succeeds (S_OK), not the actual playing status bits.
-pub unsafe extern "thiscall" fn is_channel_playing(
+/// Slot 9: is_channel_finished — checks if a buffer pool entry has stopped playing.
+/// `pool_id` is 1-based (1..64).
+///
+/// Returns:
+/// - **0** if the buffer IS playing (channel busy, don't reuse)
+/// - **1** if the buffer is NOT playing, or error, or no desc (channel free)
+/// - **0** if pool_id is out of range
+///
+/// The original inverts DSBSTATUS_PLAYING (bit 0): `NOT status; AND 1`.
+pub unsafe extern "thiscall" fn is_channel_finished(
     this: *mut DSSound, pool_id: i32,
 ) -> u8 {
     let idx = (pool_id - 1) as usize;
     if idx >= 64 {
         return 0;
     }
-    // Original returns 1 in all other cases (found or not, playing or not).
-    1
+    let snd = &*this;
+    let desc_idx = snd.buffer_pool_shadow[idx];
+    if desc_idx < 0 || desc_idx as usize >= 8 {
+        return 1; // no desc → finished/free
+    }
+    let desc = &snd.channel_descs[desc_idx as usize];
+    let Some(buf) = desc.buffer() else { return 1 };
+    match buf.GetStatus() {
+        Ok(status) => {
+            if status & 1 != 0 { 0 } else { 1 } // playing → 0, stopped → 1
+        }
+        Err(_) => 1, // error → treat as finished
+    }
 }
 
 /// Slot 10: stop_channel — stops a buffer, releases it, and returns the pool entry.

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

@@ -9,7 +9,7 @@ pub use active_sound::{ActiveSoundEntry, ActiveSoundTable};
 pub use dssound::{DSSound, DSSoundVtable, ChannelDescriptor};
 pub use dssound::{
     update_channels, release_finished,
-    is_slot_loaded, is_channel_playing, stop_channel,
+    is_slot_loaded, is_channel_finished, stop_channel,
     sub_destructor as dssound_sub_destructor, load_wav,
     noop as dssound_noop, returns_0 as dssound_returns_0, returns_1 as dssound_returns_1,
 };

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

@@ -169,7 +169,7 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
     use openwa_core::vtable::patch_vtable;
     use openwa_core::audio::{
         update_channels, release_finished,
-        is_slot_loaded, is_channel_playing, stop_channel, dssound_sub_destructor,
+        is_slot_loaded, is_channel_finished, stop_channel, dssound_sub_destructor,
         load_wav, dssound_noop, dssound_returns_0, dssound_returns_1,
     };
 
@@ -179,18 +179,17 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
         // Slot 12: load_wav — WAV file → DirectSound secondary buffer (hound + windows crate)
         *vt.add(12) = load_wav as *const () as u32;
 
-        // Slots 1, 11 disabled — update_channels/release_finished crash
-        // when iterating descriptors. Layout is confirmed correct via
-        // runtime dumps; issue is likely COM refcount handling in buffer().
-        // *vt.add(1) = update_channels as *const () as u32;
-        // *vt.add(11) = release_finished as *const () as u32;
+        // Slot 1: update_channels — release finished buffers each frame
+        *vt.add(1) = update_channels as *const () as u32;
 
-        // Slots 9, 10 disabled — slot 9's return value semantics are unclear
-        // from decompile; wrong values break sound scheduling entirely.
-        // *vt.add(9) = is_channel_playing as *const () as u32;
+        // Slot 11: release_finished — like update_channels, returns count
+        *vt.add(11) = release_finished as *const () as u32;
 
-        // Slot 10: disabled pending slot 9 fix
-        // *vt.add(10) = stop_channel as *const () as u32;
+        // Slot 9: is_channel_finished — returns 0 if playing, 1 if stopped/free
+        *vt.add(9) = is_channel_finished as *const () as u32;
+
+        // Slot 10: stop_channel — stops buffer, releases, returns to pool
+        *vt.add(10) = stop_channel as *const () as u32;
 
         // Slot 13: is_slot_loaded — channel_slots check
         *vt.add(13) = is_slot_loaded as *const () as u32;
@@ -210,6 +209,6 @@ unsafe fn patch_dssound_vtable() -> Result<(), String> {
         // Trivial returns-1 (slot 23)
         *vt.add(23) = dssound_returns_1 as *const () as u32;
 
-        let _ = log_line("[Sound]   DSSound vtable: patched 13/24 slots with Rust");
+        let _ = log_line("[Sound]   DSSound vtable: patched 17/24 slots with Rust");
     }).map_err(|e| e.to_string())
 }