feat: port worm sound functions to Rust

Port PlayWormSound (0x5150D0) and StopWormSound (0x515180) from naked
asm bridges to typed Rust functions in the sound module:

- ActiveSoundTable::stop_sound() — ports FUN_00546490, stops a streaming
sound by handle (slot lookup + DSSound::stop_channel + emitter release)
- sound::stop_worm_sound() — reads handle from CTaskWorm.sound_handle,
dispatches to DSSound::stop_channel or ActiveSoundTable::stop_sound
based on the 0x40000000 streaming flag bit, then clears the handle
- sound::play_worm_sound() — stops current sound, then starts new via
bridge to FUN_00546c20 (streaming load-and-play), stores new handle

Removes call_play_worm_sound and call_stop_worm_sound naked asm bridges
from weapon_release.rs. One bridge remains for FUN_00546c20 (streaming
audio start) in sound.rs using addr-as-param pattern.

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

crates/openwa-core/src/address.rs

@@ -510,6 +510,9 @@ pub mod va {
         fn/Fastcall DISPATCH_GLOBAL_SOUND = 0x0052_6270;
         /// RecordActiveSound
         fn/Usercall RECORD_ACTIVE_SOUND = 0x0054_6260;
+        /// LoadAndPlayStreaming: usercall(EAX=worm, ESI=&sound_emitter) + stack(sound_id, 3, volume).
+        /// Checks game conditions, then starts a streaming sound. Returns handle | 0x40000000.
+        fn/Usercall LOAD_AND_PLAY_STREAMING = 0x0054_6C20;
         /// ComputeDistanceParams
         fn/Fastcall COMPUTE_DISTANCE_PARAMS = 0x0054_6300;
         /// DispatchLocalSound

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

@@ -46,3 +46,38 @@ pub struct ActiveSoundEntry {
 }
 
 const _: () = assert!(core::mem::size_of::<ActiveSoundEntry>() == 0x18);
+
+impl ActiveSoundTable {
+    /// Stop an active streaming sound by handle. Port of FUN_00546490.
+    ///
+    /// The `handle` should have the 0x40000000 bit already cleared (the caller
+    /// strips it before calling). The low 6 bits index into the entry table.
+    ///
+    /// Returns true if the sound was found and stopped.
+    pub unsafe fn stop_sound(&mut self, handle: u32) -> bool {
+        let slot = (handle & 0x3F) as usize;
+        let entry = &mut self.entries[slot];
+
+        if entry.sequence != handle || entry.channel_handle == 0 {
+            return false;
+        }
+
+        // Stop the DSSound channel via the DDGame's sound system
+        let ddgame = &*self.ddgame;
+        let sound = ddgame.sound;
+        if !sound.is_null() {
+            ((*(*sound).vtable).stop_channel)(sound, entry.channel_handle as i32);
+        }
+        entry.channel_handle = 0;
+
+        // Release the emitter reference
+        if !entry.emitter.is_null() {
+            // Decrement ref count at emitter+8
+            let ref_count = entry.emitter.add(8) as *mut i32;
+            *ref_count -= 1;
+            entry.emitter = core::ptr::null_mut();
+        }
+
+        true
+    }
+}

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

@@ -13,7 +13,8 @@ use openwa_core::address::va;
 use openwa_core::audio::{play_sound, play_sound_pooled, KnownSoundId, SoundId};
 use openwa_core::engine::{DDGame, DDGameWrapper, SoundQueueEntry};
 use openwa_core::fixed::Fixed;
-use openwa_core::task::{CGameTask, CTask};
+use openwa_core::task::worm::CTaskWorm;
+use openwa_core::task::{CGameTask, CTask, Task};
 
 use crate::hook;
 use crate::log_line;
@@ -159,6 +160,102 @@ pub(crate) unsafe fn play_sound_local(
     true
 }
 
+// ============================================================
+// Worm sound functions (streaming sound handle at CTaskWorm+0x3B0)
+// ============================================================
+
+/// Stop the worm's active streaming sound. Port of FUN_00515180.
+///
+/// Reads the sound handle from `worm.sound_handle`, dispatches to either
+/// DSSound::stop_channel (regular) or ActiveSoundTable::stop_sound (streaming,
+/// handle has bit 30 set), then clears the handle.
+pub(crate) unsafe fn stop_worm_sound(worm: *mut CTaskWorm) {
+    let handle = (*worm).sound_handle;
+    if handle != 0 {
+        let ddgame = &*(*worm).ddgame();
+        let sound = ddgame.sound;
+        if !sound.is_null() && (handle as i32) >= 0 {
+            if handle & 0x40000000 != 0 {
+                // Streaming sound — stop via ActiveSoundTable
+                if !ddgame.active_sounds.is_null() {
+                    (*ddgame.active_sounds).stop_sound(handle & !0x40000000);
+                }
+            } else {
+                // Regular DSSound channel
+                ((*(*sound).vtable).stop_channel)(sound, handle as i32);
+            }
+        }
+    }
+    (*worm).sound_handle = 0;
+}
+
+/// Stop current worm sound, then start a new streaming sound.
+/// Port of FUN_005150D0.
+///
+/// Stops the current sound (same logic as [`stop_worm_sound`] but with
+/// reversed condition order matching the original), then calls the WA
+/// streaming load-and-play function (FUN_00546c20) and stores the new handle.
+pub(crate) unsafe fn play_worm_sound(worm: *mut CTaskWorm, sound_id: SoundId, volume: Fixed) {
+    let handle = (*worm).sound_handle;
+    if handle != 0 {
+        let ddgame = &*(*worm).ddgame();
+        let sound = ddgame.sound;
+        if !sound.is_null() && (handle as i32) >= 0 {
+            if handle & 0x40000000 == 0 {
+                // Regular DSSound channel — stop via vtable
+                ((*(*sound).vtable).stop_channel)(sound, handle as i32);
+            } else {
+                // Streaming sound — stop via ActiveSoundTable
+                if !ddgame.active_sounds.is_null() {
+                    (*ddgame.active_sounds).stop_sound(handle & !0x40000000);
+                }
+            }
+        }
+    }
+    // Start new streaming sound via WA function (FUN_00546c20)
+    let new_handle = call_load_and_play_streaming(worm, sound_id.0, volume.0 as u32);
+    (*worm).sound_handle = new_handle;
+}
+
+/// Bridge to FUN_00546c20 — load and play a streaming sound.
+/// usercall(EAX=worm, ESI=&worm.sound_emitter) + stack(sound_id, 3, volume), plain RET.
+/// Returns new sound handle (with bit 30 set for streaming, 0 on failure, -1 if suppressed).
+unsafe fn call_load_and_play_streaming(
+    worm: *mut CTaskWorm,
+    sound_id: u32,
+    volume: u32,
+) -> u32 {
+    let addr = LOAD_AND_PLAY_STREAMING_ADDR.load(core::sync::atomic::Ordering::Relaxed);
+    call_load_and_play_streaming_bridge(worm, sound_id, volume, addr)
+}
+
+static LOAD_AND_PLAY_STREAMING_ADDR: core::sync::atomic::AtomicU32 =
+    core::sync::atomic::AtomicU32::new(0);
+
+#[unsafe(naked)]
+unsafe extern "C" fn call_load_and_play_streaming_bridge(
+    _worm: *mut CTaskWorm,
+    _sound_id: u32,
+    _volume: u32,
+    _addr: u32,
+) -> u32 {
+    core::arch::naked_asm!(
+        "push esi",
+        "push ebx",
+        // Stack: 2 saves(8) + ret(4) = 12 to first arg
+        "mov eax, [esp+12]",   // worm → EAX (must be EAX when target is called)
+        "lea esi, [eax+0xE8]", // &worm.sound_emitter → ESI
+        "mov ebx, [esp+24]",   // addr (12 + 3*4 = 24) → EBX (temp)
+        "push [esp+20]",       // volume (12+8=20)
+        "push 3",              // flags = 3
+        "push [esp+24]",       // sound_id (12+4+8=24, shifted by 2 pushes)
+        "call ebx",            // call target; EAX = worm is preserved
+        "pop ebx",
+        "pop esi",
+        "ret",
+    );
+}
+
 // ============================================================
 // Sound dispatch helpers (bridge: queue → DSSound)
 // ============================================================
@@ -284,6 +381,12 @@ pub fn install() -> Result<(), String> {
 
         // Patch DSSound vtable: replace trivial slots with Rust implementations.
         patch_dssound_vtable()?;
+
+        // Initialize bridge addresses for worm sound functions
+        LOAD_AND_PLAY_STREAMING_ADDR.store(
+            openwa_core::rebase::rb(va::LOAD_AND_PLAY_STREAMING),
+            core::sync::atomic::Ordering::Relaxed,
+        );
     }
 
     Ok(())

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

@@ -290,30 +290,27 @@ unsafe extern "cdecl" fn weapon_release_impl(
     let w = &*worm; // re-borrow after mutation above
     let entry = w.active_weapon_entry;
 
-    let play_worm_sound_addr = rb(va::PLAY_WORM_SOUND);
-    let stop_worm_sound_addr = rb(va::STOP_WORM_SOUND);
-
     match FireType::try_from((*entry).fire_type) {
         Ok(FireType::Projectile) => {
             match (*entry).special_subtype {
                 1 => {
                     if w.sound_handle == 0 {
-                        call_play_worm_sound(worm, 0x1004E, 0x10000, play_worm_sound_addr);
+                        sound::play_worm_sound(worm, SoundId(0x1004E), Fixed::ONE);
                     }
                     do_effect = true;
                     effect_state = 0x73;
                 }
                 2 => {
                     sound::play_sound_local(task, KnownSoundId::ThrowRelease, 3, Fixed::ONE, Fixed::ONE);
-                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                    sound::stop_worm_sound(worm);
                 }
                 3 | 7 | 0xB | 0xC => {
                     sound::play_sound_local(task, KnownSoundId::RocketRelease, 3, Fixed::ONE, Fixed::ONE);
-                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                    sound::stop_worm_sound(worm);
                 }
                 4 => {
                     if w.sound_handle == 0 {
-                        call_play_worm_sound(worm, 0x1004F, 0x10000, play_worm_sound_addr);
+                        sound::play_worm_sound(worm, SoundId(0x1004F), Fixed::ONE);
                     }
                     do_effect = true;
                     effect_state = 0x73;
@@ -330,7 +327,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
                 }
                 10 => {
                     sound::play_sound_local(task, KnownSoundId::LongbowRelease, 3, Fixed::ONE, Fixed::ONE);
-                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                    sound::stop_worm_sound(worm);
                 }
                 _ => {}
             }
@@ -364,7 +361,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
                 }
                 Ok(S::ScalesOfJustice) => {
                     if w.sound_handle == 0 {
-                        call_play_worm_sound(worm, 0x10035, 0x10000, play_worm_sound_addr);
+                        sound::play_worm_sound(worm, SoundId(0x10035), Fixed::ONE);
                     }
                 }
                 _ => {}
@@ -415,43 +412,6 @@ fn write_u32(buf: &mut [u8], offset: usize, value: u32) {
 }
 
 // ── Bridge functions ────────────────────────────────────────
-// All bridges pass the runtime target address as the last cdecl parameter,
-// matching the pattern used in weapon.rs (avoids sym + jmp indirection issues).
-
-/// PlayWormSound (0x5150D0): usercall(EDI=worm) + stack(sound_handle_id, volume), RET 0x8.
-#[unsafe(naked)]
-unsafe extern "C" fn call_play_worm_sound(
-    _worm: *mut CTaskWorm,
-    _sound_id: u32,
-    _volume: u32,
-    _addr: u32,
-) {
-    core::arch::naked_asm!(
-        "push edi",
-        // Stack: 1 save(4) + ret(4) = 8 to first arg
-        "mov edi, [esp+8]",    // worm
-        "mov eax, [esp+20]",   // addr
-        "push [esp+16]",       // volume
-        "push [esp+16]",       // sound_id (shifted +4)
-        "call eax",
-        "pop edi",
-        "ret",
-    );
-}
-
-/// StopWormSound (0x515180): usercall(ESI=worm), plain RET.
-#[unsafe(naked)]
-unsafe extern "C" fn call_stop_worm_sound(_worm: *mut CTaskWorm, _addr: u32) {
-    core::arch::naked_asm!(
-        "push esi",
-        // Stack: 1 save(4) + ret(4) = 8 to first arg
-        "mov esi, [esp+8]",    // worm
-        "mov eax, [esp+12]",   // addr
-        "call eax",
-        "pop esi",
-        "ret",
-    );
-}
 
 /// SpawnEffect (0x547C30): usercall(EAX=0x80000, ECX=speed_x, ESI=worm) + 7 stack, RET 0x1C.
 #[unsafe(naked)]