feat: port streaming sound chain to Rust, unify SoundId/SoundSlot

Fully port play_worm_sound/play_worm_sound_2 — the streaming sound
playback chain no longer calls into WA.exe via naked asm bridges.

New Rust implementations (sound_ops.rs):
- distance_3d_attenuation: stereo panning with i64 fixed-point math
- compute_distance_params: reads listener pos + attenuation from DDGame
- record_active_sound: ring buffer insert into ActiveSoundTable
- dispatch_local_sound: 3D audio + play_sound_pooled + record
- load_and_play_streaming / load_and_play_streaming_positional

Removed: naked asm bridges (call_load_and_play_streaming,
call_load_and_play_streaming_positional, LOAD_AND_PLAY_STREAMING_ADDR).

Unify SoundId and SoundSlot into a single SoundId type — they were
the same packed u32 format (low 16 = slot index, bit 16 = loop,
bit 17 = raw volume). Flag accessors moved to SoundId.

Other changes:
- Add Fixed Div/Div<i32> operators
- Name DDGame+0x77B8 (level_width_sound), GameInfo+0xF38C
(sound_attenuation), DDGame listener_pos() accessor

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

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

@@ -40,7 +40,7 @@ pub struct ActiveSoundEntry {
     /// 0x0C: Volume (fixed-point 16.16, 0x10000 = 1.0).
     pub volume: Fixed,
     /// 0x10: Running counter value at time of insertion (unique ID).
-    pub sequence: u32,
+    pub sequence: i32,
     /// 0x14: DSSound channel handle (return from play_sound_pooled). 0 = free slot.
     pub channel_handle: u32,
 }
@@ -54,7 +54,7 @@ impl ActiveSoundTable {
     /// 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 {
+    pub unsafe fn stop_sound(&mut self, handle: i32) -> bool {
         let slot = (handle & 0x3F) as usize;
         let entry = &mut self.entries[slot];
 

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

@@ -2,41 +2,7 @@ use crate::fixed::Fixed;
 
 use windows::Win32::Media::Audio::DirectSound::IDirectSoundBuffer;
 
-/// Packed sound slot index + playback flags, passed as a single u32.
-///
-/// Layout:
-/// - Bits 0-15: sound slot index (1-499)
-/// - Bit 16: loop flag (play in a loop)
-/// - Bit 17: raw volume flag (skip master volume scaling)
-#[derive(Clone, Copy)]
-#[repr(transparent)]
-pub struct SoundSlot(pub u32);
-
-impl SoundSlot {
-    /// Sound slot index (0-499). 0 = invalid/empty.
-    #[inline]
-    pub fn index(self) -> usize {
-        (self.0 & 0xFFFF) as usize
-    }
-
-    /// Whether the sound should loop continuously.
-    #[inline]
-    pub fn is_looping(self) -> bool {
-        self.0 & 0x10000 != 0
-    }
-
-    /// Whether volume should be used directly (skip master volume scaling).
-    #[inline]
-    pub fn is_raw_volume(self) -> bool {
-        self.0 & 0x20000 != 0
-    }
-
-    /// Return a copy with the loop flag cleared.
-    #[inline]
-    pub fn without_loop(self) -> Self {
-        Self(self.0 & 0xFFFE_FFFF)
-    }
-}
+use crate::audio::sound::SoundId;
 
 /// Volume-to-dB attenuation table (64 entries of i16).
 /// Copied from WA.exe .rdata at 0x6A6A60.
@@ -69,10 +35,10 @@ type Ptr32 = u32;
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct ChannelDescriptor {
-    /// +0x00: The SoundSlot that was used to start this channel.
+    /// +0x00: The SoundId that was used to start this channel.
     /// Stored by core_play_sound; checked by set_master_volume/set_channel_volume
     /// for the raw-volume flag (bit 17).
-    pub slot: SoundSlot,
+    pub slot: SoundId,
     /// +0x04: Buffer pool index (0..63), or -1 if not pooled.
     /// Set by play_sound_pooled; checked by update_channels/stop_channel/allocate_channel.
     pub pool_idx: i32,
@@ -128,7 +94,7 @@ pub struct DSSoundVtable {
     /// play_sound — wrapper around core play. RET 0x14 = 5 stack params.
     pub play_sound: fn(
         this: *mut DSSound,
-        slot: SoundSlot,
+        slot: SoundId,
         priority: i32,
         volume: Fixed,
         pan: Fixed,
@@ -137,7 +103,7 @@ pub struct DSSoundVtable {
     /// play_sound_pooled — allocates from buffer pool, plays. RET 0x14.
     pub play_sound_pooled: fn(
         this: *mut DSSound,
-        slot: SoundSlot,
+        slot: SoundId,
         priority: i32,
         volume: Fixed,
         pan: Fixed,
@@ -508,7 +474,7 @@ pub unsafe extern "thiscall" fn destructor(this: *mut DSSound, flags: u8) -> *mu
 /// Returns channel descriptor index on success, -1 on failure.
 unsafe fn core_play_sound(
     snd: &mut DSSound,
-    slot: SoundSlot,
+    slot: SoundId,
     priority: i32,
     frequency: Fixed,
     volume: Fixed,
@@ -652,7 +618,7 @@ unsafe fn allocate_channel(snd: &mut DSSound, priority: i32) -> i32 {
 /// Params: slot (with flags), priority, frequency, volume, pan.
 pub unsafe extern "thiscall" fn play_sound(
     this: *mut DSSound,
-    slot: SoundSlot,
+    slot: SoundId,
     priority: i32,
     frequency: Fixed,
     volume: Fixed,
@@ -667,7 +633,7 @@ pub unsafe extern "thiscall" fn play_sound(
 /// Returns pool_id (1-based) on success, 0 on failure.
 pub unsafe extern "thiscall" fn play_sound_pooled(
     this: *mut DSSound,
-    slot: SoundSlot,
+    slot: SoundId,
     priority: i32,
     frequency: Fixed,
     volume: Fixed,

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

@@ -14,7 +14,7 @@ pub use dssound::{
     set_master_volume, set_pan, set_volume_params, stop_channel,
     sub_destructor as dssound_sub_destructor, update_channels,
 };
-pub use dssound::{ChannelDescriptor, DSSound, DSSoundVtable, SoundSlot};
+pub use dssound::{ChannelDescriptor, DSSound, DSSoundVtable};
 pub use music::Music;
 pub use sound::{KnownSoundId, SoundId};
 pub use speech::{SpeechLineId, SpeechLineTableEntry, SpeechSlotTable, SPEECH_LINE_TABLE_COUNT};

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

@@ -1,10 +1,42 @@
-/// Opaque sound ID. WA uses a wider range than just the known SFX enum
-/// (e.g., speech/voice lines use IDs above 126). This newtype wraps the
-/// raw u32 value and can be constructed from [`KnownSoundId`] variants.
+/// Packed sound ID + playback flags, passed as a single u32.
+///
+/// Layout:
+/// - Bits 0-15: sound slot index (1-499 for SFX, higher for speech)
+/// - Bit 16: loop flag (play in a loop)
+/// - Bit 17: raw volume flag (skip master volume scaling)
+///
+/// Used throughout the sound system: queue insertion, DSSound playback,
+/// and streaming dispatch all operate on this same packed format.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[repr(transparent)]
 pub struct SoundId(pub u32);
 
+impl SoundId {
+    /// Sound slot index (low 16 bits). 0 = invalid/empty.
+    #[inline]
+    pub fn index(self) -> usize {
+        (self.0 & 0xFFFF) as usize
+    }
+
+    /// Whether the sound should loop continuously (bit 16).
+    #[inline]
+    pub fn is_looping(self) -> bool {
+        self.0 & 0x10000 != 0
+    }
+
+    /// Whether volume should be used directly, skipping master volume scaling (bit 17).
+    #[inline]
+    pub fn is_raw_volume(self) -> bool {
+        self.0 & 0x20000 != 0
+    }
+
+    /// Return a copy with the loop flag cleared.
+    #[inline]
+    pub fn without_loop(self) -> Self {
+        Self(self.0 & 0xFFFE_FFFF)
+    }
+}
+
 impl From<KnownSoundId> for SoundId {
     #[inline]
     fn from(known: KnownSoundId) -> Self {

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

@@ -13,9 +13,7 @@
 //! - DispatchGlobalSound (0x526270)
 //! - PlaySoundPooled_Direct (0x546B50)
 
-use core::sync::atomic::{AtomicU32, Ordering};
-
-use crate::audio::{play_sound, play_sound_pooled, SoundId, SoundSlot};
+use crate::audio::{play_sound, play_sound_pooled, SoundId};
 use crate::engine::{DDGame, DDGameWrapper, SoundQueueEntry};
 use crate::fixed::Fixed;
 use crate::task::worm::CTaskWorm;
@@ -141,9 +139,9 @@ pub unsafe fn play_worm_sound(worm: *mut CTaskWorm, sound_id: SoundId, volume: F
             }
         }
     }
-    // Start new streaming sound via WA function (FUN_00546c20)
+    // Start new streaming sound — fully ported, no WA bridge needed
     // FUN_005150D0 hardcodes flags=3
-    let new_handle = call_load_and_play_streaming(worm, sound_id.0, 3, volume.0 as u32);
+    let new_handle = load_and_play_streaming(worm, sound_id, 3, volume);
     (*worm).sound_handle = new_handle;
 }
 
@@ -178,17 +176,17 @@ pub unsafe fn play_worm_sound_2(
     let worm_y = *((worm as *const u8).add(0x88) as *const i32);
     let new_handle = if worm_y < -0x270F_FFFF && sound_id.0 == 0x36 {
         // Special teleport case: play at weapon target position
-        call_load_and_play_streaming_positional(
+        load_and_play_streaming_positional(
             worm,
-            sound_id.0,
+            sound_id,
             flags,
-            volume.0 as u32,
-            (*worm).weapon_param_1 as u32,
-            (*worm).weapon_param_2 as u32,
+            volume,
+            Fixed((*worm).weapon_param_1 as i32),
+            Fixed((*worm).weapon_param_2 as i32),
         )
     } else {
-        // Normal case: play streaming sound
-        call_load_and_play_streaming(worm, sound_id.0, flags, volume.0 as u32)
+        // Normal case: play streaming sound — fully ported
+        load_and_play_streaming(worm, sound_id, flags, volume)
     };
 
     (*worm).sound_handle_2 = new_handle;
@@ -213,10 +211,10 @@ pub unsafe fn is_sound_suppressed(ddgame: *const DDGame) -> bool {
 /// Returns 0xFFFFFFFF if suppressed, 0 if no DSSound, otherwise the channel handle.
 pub unsafe fn dispatch_global_sound(
     ddgame_wrapper: *const DDGameWrapper,
-    sound_id: u32,
-    flags: u32,
-    volume: u32,
-    pitch: u32,
+    slot: SoundId,
+    priority: i32,
+    frequency: Fixed,
+    volume: Fixed,
 ) -> u32 {
     let g = &*(*ddgame_wrapper).ddgame;
     let gi = &*g.game_info;
@@ -230,14 +228,7 @@ pub unsafe fn dispatch_global_sound(
         return 0;
     }
 
-    play_sound(
-        dssound,
-        SoundSlot(sound_id),
-        flags as i32,
-        Fixed(volume as i32),
-        Fixed(pitch as i32),
-        Fixed(0),
-    ) as u32
+    play_sound(dssound, slot, priority, frequency, volume, Fixed::ZERO) as u32
 }
 
 /// Direct pooled sound playback — port of PlaySoundPooled_Direct (0x546B50).
@@ -245,9 +236,9 @@ pub unsafe fn dispatch_global_sound(
 /// Bypasses queue, checks suppression + fast-forward, calls DSSound play_sound_pooled.
 pub unsafe fn play_sound_pooled_direct(
     task: *const CTask,
-    param1: SoundSlot,
-    param2: i32,
-    param3: Fixed,
+    slot: SoundId,
+    priority: i32,
+    volume: Fixed,
 ) -> i32 {
     let g = &*(*task).ddgame;
     let gi = &*g.game_info;
@@ -265,97 +256,309 @@ pub unsafe fn play_sound_pooled_direct(
         return 0;
     }
 
-    play_sound_pooled(dssound, param1, param2, Fixed::ONE, param3, Fixed::ZERO)
+    play_sound_pooled(dssound, slot, priority, Fixed::ONE, volume, Fixed::ZERO)
 }
 
 // ============================================================
-// Streaming sound bridges (naked asm — WA usercall conventions)
+// Local/streaming sound — full Rust port
 // ============================================================
+//
+// Replaces the former naked asm bridges to WA's LoadAndPlayStreaming (0x546C20)
+// and LoadAndPlayStreamingPositional (0x546BB0) with pure Rust implementations
+// of the entire call chain:
+//
+//   load_and_play_streaming → dispatch_local_sound
+//     → compute_distance_params → distance_3d_attenuation
+//     → DSSound::play_sound_pooled (vtable, already Rust)
+//     → ActiveSoundTable::record_sound
+
+use crate::audio::active_sound::ActiveSoundTable;
+
+/// 3D stereo distance attenuation — port of Distance3D_Attenuation (0x5430F0).
+///
+/// Computes volume attenuation and stereo pan based on the distance between
+/// a sound source and the listener, using an elliptical model.
+///
+/// The function models two "ears" at ±half_width from the listener's X position.
+/// For each ear, it computes an inverse-distance attenuation from the sound source
+/// using: `attenuation = scaled² / (scaled² + dy² + dx_ear²)`, where `scaled` is
+/// the characteristic distance (abs(half_width) * 0xDDB3 / 0x10000 ≈ 0.866 * half_width).
+///
+/// Returns `(volume, pan)` as Fixed values where:
+/// - `volume` = max(left_atten, right_atten), clamped to Fixed::ONE
+/// - `pan` = right_atten - left_atten (positive = sound is to the right)
+///
+/// Convention: EAX = &listener_pos[x,y], stdcall(sound_x, sound_y, level_width_fixed,
+///   attenuation_factor, out_volume, out_pan), RET 0x18.
+fn distance_3d_attenuation(
+    listener_x: Fixed,
+    listener_y: Fixed,
+    sound_x: Fixed,
+    sound_y: Fixed,
+    level_width_fixed: Fixed,
+    attenuation_factor: i32,
+) -> (Fixed, Fixed) {
+    /// √3/2 ≈ 0.866, stored as Fixed (0xDDB3 / 0x10000)
+    const SQRT3_HALF: Fixed = Fixed(0xDDB3);
+
+    // Step 1: half_width = level_width / attenuation_factor
+    // Uses 64-bit intermediate, clamped so abs() can't overflow i32
+    let wide = (level_width_fixed.0 as i64) * (Fixed::ONE.0 as i64);
+    let half_width_64 = wide / (attenuation_factor as i64);
+    let half_width = Fixed(if half_width_64 > 0x7FFFFFFF {
+        0x7FFFFFFF
+    } else if half_width_64 < -0x7FFFFFFF {
+        // Clamp to -0x7FFFFFFF (not i32::MIN) so abs() in step 2 can't overflow
+        -0x7FFFFFFF
+    } else {
+        half_width_64 as i32
+    });
+
+    // Step 2: characteristic distance = abs(half_width) * √3/2
+    let scaled = half_width.abs() * SQRT3_HALF;
+
+    // Steps 3-5 use i64 intermediates to match the original's __allmul/__alldiv
+    // precision. The original keeps scaled_sq/dy_sq as full 64-bit values through
+    // the attenuation computation; truncating to i32 (Fixed) would lose precision.
+    let scaled_i = scaled.0 as i64;
+    let dy_i = (sound_y.0 - listener_y.0) as i64;
+    let dx = sound_x - listener_x;
+    let half = half_width / 2;
+
+    // squared terms: a² / ONE (fixed-point squares, 64-bit)
+    let scaled_sq = (scaled_i * scaled_i) / Fixed::ONE.0 as i64;
+    let dy_sq = (dy_i * dy_i) / Fixed::ONE.0 as i64;
+
+    // Compute per-ear inverse-distance attenuation:
+    //   atten = (scaled_sq * ONE) / (scaled_sq + dy_sq + dx_ear²)
+
+    // Step 4: Left ear — distance from sound to left ear = -(half + dx)
+    let left_dist = -(half + dx).0 as i64;
+    let left_dist_sq = (left_dist * left_dist) / Fixed::ONE.0 as i64;
+    let left_denom = scaled_sq + dy_sq + left_dist_sq;
+    let left_atten = if left_denom == 0 {
+        Fixed::ONE
+    } else {
+        Fixed(((scaled_sq * Fixed::ONE.0 as i64) / left_denom) as i32).min(Fixed::ONE)
+    };
+
+    // Step 5: Right ear — distance from sound to right ear = half - dx
+    let right_dist = (half - dx).0 as i64;
+    let right_dist_sq = (right_dist * right_dist) / Fixed::ONE.0 as i64;
+    let right_denom = right_dist_sq + dy_sq + scaled_sq;
+    let right_atten = if right_denom == 0 {
+        Fixed::ONE
+    } else {
+        Fixed(((scaled_sq * Fixed::ONE.0 as i64) / right_denom) as i32).min(Fixed::ONE)
+    };
+
+    // Step 6: volume = max(left, right), pan = right - left
+    (left_atten.max(right_atten), right_atten - left_atten)
+}
+
+/// Compute distance-based volume and pan for a local sound — port of
+/// ComputeDistanceParams (0x546300).
+///
+/// Reads the attenuation factor from GameInfo and the level width from DDGame.
+/// If attenuation is disabled (factor == 0), returns full volume and center pan.
+///
+/// Convention: fastcall(ECX=&out_pan, EDX=&out_volume, stack=[table, x, y]), RET 0xC.
+unsafe fn compute_distance_params(ddgame: *const DDGame, x: Fixed, y: Fixed) -> (Fixed, Fixed) {
+    let gi = &*(*ddgame).game_info;
+    let attenuation = gi.sound_attenuation;
+
+    if attenuation == 0 {
+        // No 3D audio — full volume, center pan
+        return (Fixed::ONE, Fixed::ZERO);
+    }
+
+    let level_width_fixed = Fixed((*ddgame).level_width_sound << 16);
+    let (lx, ly) = (*ddgame).listener_pos();
+
+    distance_3d_attenuation(Fixed(lx), Fixed(ly), x, y, level_width_fixed, attenuation)
+}
+
+/// Record an active local sound in the tracking table — port of
+/// RecordActiveSound (0x546260).
+///
+/// Finds a free slot in the 64-entry ring buffer (probing by incrementing
+/// counter until channel_handle == 0), then writes the entry.
+///
+/// Convention: usercall(EAX=table, ESI=emitter) + stdcall(x, y, volume, channel_handle),
+/// RET 0x10. Returns the counter value (used as handle with 0x40000000 bit).
+unsafe fn record_active_sound(
+    table: *mut ActiveSoundTable,
+    emitter: *mut u8,
+    x: i32,
+    y: i32,
+    volume: i32,
+    channel_handle: i32,
+) -> i32 {
+    let t = &mut *table;
+
+    // Probe for a free slot (channel_handle == 0)
+    loop {
+        t.counter = t.counter.wrapping_add(1);
+        let slot = (t.counter & 0x3F) as usize;
+        if t.entries[slot].channel_handle == 0 {
+            break;
+        }
+    }
+
+    let slot = (t.counter & 0x3F) as usize;
+    let entry = &mut t.entries[slot];
+    entry.pos_x = Fixed(x);
+    entry.pos_y = Fixed(y);
+    entry.emitter = emitter;
+    entry.volume = Fixed(volume);
+    entry.sequence = t.counter as i32;
+    entry.channel_handle = channel_handle as u32;
+
+    // Increment emitter ref count (emitter+0x08)
+    if !emitter.is_null() {
+        let ref_count = emitter.add(8) as *mut i32;
+        *ref_count += 1;
+    }
+
+    t.counter as i32
+}
+
+/// Dispatch a local (positional) sound — port of DispatchLocalSound (0x546360).
+///
+/// Clamps volume, computes 3D distance attenuation and pan, calls
+/// DSSound::play_sound_pooled, then records the active sound.
+///
+/// Convention: usercall(EAX=volume, EDI=active_sound_table) +
+///   stdcall(sound_slot, flags, x, y, emitter), RET 0x14.
+unsafe fn dispatch_local_sound(
+    table: *mut ActiveSoundTable,
+    volume: Fixed,
+    sound_slot: SoundId,
+    flags: i32,
+    pos: (Fixed, Fixed),
+    emitter: *mut u8,
+) -> i32 {
+    let volume = volume.min(Fixed::ONE);
+
+    let ddgame = (*table).ddgame;
+    let (volume_atten, pan) = compute_distance_params(ddgame, pos.0, pos.1);
+
+    let scaled_volume = volume * volume_atten;
+
+    // Call DSSound::play_sound_pooled (vtable slot 4)
+    let sound = (*ddgame).sound;
+    let sound_vt = &*(*sound).vtable;
+    let handle =
+        (sound_vt.play_sound_pooled)(sound, sound_slot, flags, Fixed::ONE, scaled_volume, pan);
+
+    if handle == 0 {
+        return 0;
+    }
 
-/// Rebased address for FUN_00546c20 (LoadAndPlayStreaming).
-/// Initialized by wormkit's sound::install().
-pub static LOAD_AND_PLAY_STREAMING_ADDR: AtomicU32 = AtomicU32::new(0);
+    record_active_sound(table, emitter, pos.0 .0, pos.1 .0, volume.0, handle)
+}
 
-/// Bridge to FUN_00546c20 — load and play a streaming sound.
-/// usercall(EAX=worm, ESI=&worm.sound_emitter) + stdcall(sound_id, flags, volume), plain RET.
-/// Returns new sound handle (with bit 30 set for streaming, 0 on failure, -1 if suppressed).
-pub unsafe fn call_load_and_play_streaming(
+/// Load and play a streaming sound — port of LoadAndPlayStreaming (0x546C20).
+///
+/// Checks suppression conditions, gets emitter position via vtable call,
+/// then dispatches as a local sound. Returns handle | 0x40000000 on success,
+/// 0 on failure, -1 (0xFFFFFFFF) if suppressed.
+///
+/// Replaces the former naked asm bridge `call_load_and_play_streaming`.
+pub unsafe fn load_and_play_streaming(
     worm: *mut CTaskWorm,
-    sound_id: u32,
+    sound_id: SoundId,
     flags: u32,
-    volume: u32,
-) -> u32 {
-    let addr = LOAD_AND_PLAY_STREAMING_ADDR.load(Ordering::Relaxed);
-    call_load_and_play_streaming_bridge(worm, sound_id, flags, volume, addr)
-}
+    volume: Fixed,
+) -> i32 {
+    let ddgame = CTask::ddgame_raw(worm as *const CTask);
+    let gi = &*(*ddgame).game_info;
 
-#[unsafe(naked)]
-unsafe extern "C" fn call_load_and_play_streaming_bridge(
-    _worm: *mut CTaskWorm,
-    _sound_id: u32,
-    _flags: 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
-        "lea esi, [eax+0xE8]", // &worm.sound_emitter → ESI
-        "mov ebx, [esp+28]",   // addr (12 + 4*4 = 28)
-        "push [esp+24]",       // volume (12+12=24)
-        "push [esp+20]",       // flags (12+8=20, shifted+4=24)
-        "push [esp+24]",       // sound_id (12+4=16, shifted+8=24)
-        "call ebx",
-        "pop ebx",
-        "pop esi",
-        "ret",
+    // Suppression checks (matching 0x546C20 exactly)
+    if gi.sound_mute != 0 || (*ddgame).frame_counter < gi.sound_start_frame {
+        return -1;
+    }
+    if (*ddgame).fast_forward_active != 0 {
+        return -1;
+    }
+
+    let sound = (*ddgame).sound;
+    if sound.is_null() {
+        return 0;
+    }
+
+    // Get emitter position via sound_emitter vtable[0] (GetPosition)
+    let task = worm as *mut CGameTask;
+    let emitter = &(*task).sound_emitter;
+    let mut pos_x: u32 = 0;
+    let mut pos_y: u32 = 0;
+    ((*emitter.vtable).get_position)(emitter, &mut pos_x, &mut pos_y);
+
+    // Dispatch as local sound
+    let table = (*ddgame).active_sounds;
+    if table.is_null() {
+        return 0;
+    }
+
+    let handle = dispatch_local_sound(
+        table,
+        volume,
+        sound_id,
+        flags as i32,
+        (Fixed(pos_x as i32), Fixed(pos_y as i32)),
+        emitter as *const _ as *mut u8,
     );
+    if handle == 0 {
+        return 0;
+    }
+    handle | 0x40000000
 }
 
-/// Bridge to FUN_00546bb0 — load and play a positional streaming sound.
-/// usercall(EAX=worm, ESI=&worm.sound_emitter) + stdcall(sound_id, flags, volume, x, y).
-/// Returns handle | 0x40000000 on success, 0 on failure, -1 if suppressed.
-pub unsafe fn call_load_and_play_streaming_positional(
+/// Load and play a streaming sound at a specific position — port of
+/// LoadAndPlayStreamingPositional (0x546BB0).
+///
+/// Same as `load_and_play_streaming` but uses explicit (x, y) coordinates
+/// instead of reading from the emitter. Used by teleport sound special case.
+pub unsafe fn load_and_play_streaming_positional(
     worm: *mut CTaskWorm,
-    sound_id: u32,
+    sound_id: SoundId,
     flags: u32,
-    volume: u32,
-    x: u32,
-    y: u32,
-) -> u32 {
-    let addr = crate::rebase::rb(0x546BB0u32);
-    call_load_and_play_streaming_positional_bridge(worm, sound_id, flags, volume, x, y, addr)
-}
+    volume: Fixed,
+    x: Fixed,
+    y: Fixed,
+) -> i32 {
+    let ddgame = CTask::ddgame_raw(worm as *const CTask);
+    let gi = &*(*ddgame).game_info;
 
-#[unsafe(naked)]
-unsafe extern "C" fn call_load_and_play_streaming_positional_bridge(
-    _worm: *mut CTaskWorm,
-    _sound_id: u32,
-    _flags: u32,
-    _volume: u32,
-    _x: u32,
-    _y: u32,
-    _addr: u32,
-) -> u32 {
-    core::arch::naked_asm!(
-        "push esi",
-        "push ebx",
-        // Stack after saves: [ESP+12]=worm [+16]=sound_id [+20]=flags
-        //   [+24]=volume [+28]=x [+32]=y [+36]=addr
-        "mov eax, [esp+12]",   // worm → EAX
-        "lea esi, [eax+0xE8]", // &worm.sound_emitter → ESI
-        "mov ebx, [esp+36]",   // addr
-        // Push 5 stdcall params right-to-left: y, x, volume, flags, sound_id.
-        "push [esp+32]", // y
-        "push [esp+32]", // x (was +28, shifted +4)
-        "push [esp+32]", // volume (was +24, shifted +8)
-        "push [esp+32]", // flags (was +20, shifted +12)
-        "push [esp+32]", // sound_id (was +16, shifted +16)
-        "call ebx",
-        "pop ebx",
-        "pop esi",
-        "ret",
+    // Suppression checks (matching 0x546BB0 exactly)
+    if gi.sound_mute != 0 || (*ddgame).frame_counter < gi.sound_start_frame {
+        return -1;
+    }
+    if (*ddgame).fast_forward_active != 0 {
+        return -1;
+    }
+
+    let sound = (*ddgame).sound;
+    if sound.is_null() {
+        return 0;
+    }
+
+    let table = (*ddgame).active_sounds;
+    if table.is_null() {
+        return 0;
+    }
+
+    // Note: positional variant passes 0 for emitter (no ref tracking)
+    let handle = dispatch_local_sound(
+        table,
+        volume,
+        sound_id,
+        flags as i32,
+        (x, y),
+        core::ptr::null_mut(),
     );
+    if handle == 0 {
+        return 0;
+    }
+    handle | 0x40000000
 }

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

@@ -285,8 +285,13 @@ pub struct DDGame {
     pub level_bound_min_y: i32,
     /// 0x77A8: Level bound max Y (Fixed-point).
     pub level_bound_max_y: i32,
-    /// 0x77AC-0x77BF: Unknown
-    pub _unknown_77ac: [u8; 0x77C0 - 0x77AC],
+    /// 0x77AC-0x77B7: Unknown
+    pub _unknown_77ac: [u8; 0x77B8 - 0x77AC],
+    /// 0x77B8: Level width for 3D sound distance computation (pixels, not fixed-point).
+    /// Read by ComputeDistanceParams, shifted left 16 before passing to Distance3D_Attenuation.
+    pub level_width_sound: i32,
+    /// 0x77BC-0x77BF: Unknown
+    pub _unknown_77bc: [u8; 0x77C0 - 0x77BC],
 
     /// 0x77C0: Level width in pixels (set by PCLandscape constructor).
     pub level_width: u32,
@@ -494,6 +499,14 @@ impl DDGame {
             self.hud_status_text = load_string(0x70F);
         }
     }
+
+    /// Listener position for 3D audio — stored at DDGame+0x8CEC (screen_coords[3]).
+    ///
+    /// Returns `(x, y)` as raw i32 values (fixed-point 16.16).
+    /// Used by ComputeDistanceParams / Distance3D_Attenuation.
+    pub fn listener_pos(&self) -> (i32, i32) {
+        (self.screen_coords[3].x, self.screen_coords[3].y)
+    }
 }
 
 // DDGame constructor code (create_ddgame, init helpers, usercall bridges)

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

@@ -144,8 +144,13 @@ pub struct GameInfo {
     /// 0xF374: Display flags passed to DDDisplay::Init.
     pub display_flags: u32,
 
-    /// 0xF378-0xF39F: Unknown
-    pub _unknown_f378: [u8; 0xF3A0 - 0xF378],
+    /// 0xF378-0xF38B: Unknown
+    pub _unknown_f378: [u8; 0xF38C - 0xF378],
+    /// 0xF38C: Sound distance attenuation factor (i32). When nonzero, enables 3D
+    /// positional audio via Distance3D_Attenuation. Zero = all sounds at full volume.
+    pub sound_attenuation: i32,
+    /// 0xF390-0xF39F: Unknown
+    pub _unknown_f390: [u8; 0xF3A0 - 0xF390],
 
     // --- Cluster 2: game options (populated by LoadOptions) ---
     /// 0xF3A0: Unknown config byte (from global 0x7C0D38)

crates/openwa-core/src/fixed.rs

@@ -1,4 +1,4 @@
-use core::ops::{Add, Mul, Neg, Sub};
+use core::ops::{Add, Div, Mul, Neg, Sub};
 use std::ops::{AddAssign, SubAssign};
 
 /// 16.16 fixed-point number used throughout WA for coordinates and velocities.
@@ -104,6 +104,24 @@ impl Mul<i32> for Fixed {
     }
 }
 
+impl Div for Fixed {
+    type Output = Self;
+    /// Fixed-point division: (self << 16) / rhs, using i64 intermediate.
+    #[inline]
+    fn div(self, rhs: Self) -> Self {
+        Self((((self.0 as i64) << Self::FRACTIONAL_BITS) / rhs.0 as i64) as i32)
+    }
+}
+
+/// Divide a Fixed value by a plain integer (no shift — just `raw / n`).
+impl Div<i32> for Fixed {
+    type Output = Self;
+    #[inline]
+    fn div(self, rhs: i32) -> Self {
+        Self(self.0 / rhs)
+    }
+}
+
 impl Neg for Fixed {
     type Output = Self;
     #[inline]

crates/openwa-core/src/task/worm.rs

@@ -396,10 +396,10 @@ pub struct CTaskWorm {
     /// 0x3B0: Streaming sound handle. Nonzero when a worm sound effect
     /// (e.g., weapon charge-up) is actively playing. PlayWormSound stores the
     /// new handle here; StopWormSound clears it.
-    pub sound_handle: u32,
+    pub sound_handle: i32,
     /// 0x3B4: Secondary sound handle, used by FUN_00515020 (teleport/weapon sounds).
     /// Same stop/play semantics as `sound_handle` but a separate channel.
-    pub sound_handle_2: u32,
+    pub sound_handle_2: i32,
     /// 0x3B8–0x3DB: Unknown
     pub _unknown_3b8: [u8; 0x3DC - 0x3B8],
     /// 0x3DC: Facing direction. -1 = facing left, +1 = facing right.

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

@@ -15,7 +15,7 @@ use std::sync::atomic::Ordering;
 
 use openwa_core::address::va;
 use openwa_core::audio::sound_ops;
-use openwa_core::audio::{KnownSoundId, SoundId, SoundSlot};
+use openwa_core::audio::{KnownSoundId, SoundId};
 use openwa_core::engine::{DDGame, DDGameWrapper};
 use openwa_core::fixed::Fixed;
 use openwa_core::task::worm::CTaskWorm;
@@ -31,23 +31,22 @@ static SOUND_LOG_ENABLED: std::sync::atomic::AtomicBool = std::sync::atomic::Ato
 
 unsafe extern "thiscall" fn hook_play_sound_global(
     this: *const CGameTask,
-    sound_id: u32,
+    sound_id: SoundId,
     flags: u32,
     volume: Fixed,
     pitch: Fixed,
 ) -> u32 {
     if SOUND_LOG_ENABLED.load(Ordering::Relaxed) {
-        let sound_name = KnownSoundId::try_from(sound_id)
+        let sound_name = KnownSoundId::try_from(sound_id.0)
             .map(|s| format!("{s:?}"))
             .unwrap_or_else(|v| format!("#{v}"));
         let _ = log_line(&format!(
-            "[Sound] Global: task=0x{this:08X?} id={sound_id}({sound_name}) \
+            "[Sound] Global: task=0x{this:08X?} id={sound_id:?}({sound_name}) \
              p3={flags} p4={volume} p5={pitch}"
         ));
     }
 
-    sound_ops::queue_sound((*this).base.ddgame, SoundId(sound_id), flags, volume, pitch).is_some()
-        as u32
+    sound_ops::queue_sound((*this).base.ddgame, sound_id, flags, volume, pitch).is_some() as u32
 }
 
 // ── PlaySoundLocal (0x4FDFE0): usercall(EAX=pitch, ECX=volume, EDI=task, stack) ──
@@ -59,20 +58,20 @@ unsafe extern "cdecl" fn play_sound_local_impl(
     pitch: Fixed,
     volume: Fixed,
     task: *mut CGameTask,
-    sound_id: u32,
+    sound_id: SoundId,
     flags: u32,
 ) -> u32 {
     if SOUND_LOG_ENABLED.load(Ordering::Relaxed) {
-        let sound_name = KnownSoundId::try_from(sound_id)
+        let sound_name = KnownSoundId::try_from(sound_id.0)
             .map(|s| format!("{s:?}"))
             .unwrap_or_else(|v| format!("#{v}"));
         let _ = log_line(&format!(
             "[Sound] Local: pitch={pitch} volume={volume} task=0x{task:08X?} \
-             id={sound_id}({sound_name}) flags={flags}"
+             id={sound_id:?}({sound_name}) flags={flags}"
         ));
     }
 
-    sound_ops::play_sound_local(task, SoundId(sound_id), flags, volume, pitch) as u32
+    sound_ops::play_sound_local(task, sound_id, flags, volume, pitch) as u32
 }
 
 // ── WormPlaySound2 (0x515020): usercall(EDI=worm) + stdcall(sound_id, volume, flags) ──
@@ -93,11 +92,11 @@ unsafe extern "C" fn trampoline_worm_play_sound_2() {
 
 unsafe extern "cdecl" fn play_worm_sound_2_cdecl(
     worm: *mut CTaskWorm,
-    sound_id: u32,
-    volume: u32,
+    sound_id: SoundId,
+    volume: Fixed,
     flags: u32,
 ) {
-    sound_ops::play_worm_sound_2(worm, SoundId(sound_id), Fixed(volume as i32), flags);
+    sound_ops::play_worm_sound_2(worm, sound_id, volume, flags);
 }
 
 // ── IsSoundSuppressed (0x5261E0): thiscall(ECX=DDGame*) ──
@@ -111,12 +110,12 @@ unsafe extern "thiscall" fn hook_is_sound_suppressed(ddgame: *mut DDGame) -> u32
 unsafe extern "fastcall" fn hook_dispatch_global_sound(
     _ecx: u32,
     ddgame_wrapper: *const DDGameWrapper,
-    sound_id: u32,
-    flags: u32,
-    volume: u32,
-    pitch: u32,
+    slot: SoundId,
+    priority: i32,
+    frequency: Fixed,
+    volume: Fixed,
 ) -> u32 {
-    sound_ops::dispatch_global_sound(ddgame_wrapper, sound_id, flags, volume, pitch)
+    sound_ops::dispatch_global_sound(ddgame_wrapper, slot, priority, frequency, volume)
 }
 
 // ── PlaySoundPooled_Direct (0x546B50): fastcall(ECX=unused, EDX=task) + 3 stack ──
@@ -124,11 +123,11 @@ unsafe extern "fastcall" fn hook_dispatch_global_sound(
 unsafe extern "fastcall" fn hook_play_sound_pooled_direct(
     _ecx: u32,
     task: *const CTask,
-    param1: SoundSlot,
-    param2: i32,
-    param3: Fixed,
+    slot: SoundId,
+    priority: i32,
+    volume: Fixed,
 ) -> i32 {
-    sound_ops::play_sound_pooled_direct(task, param1, param2, param3)
+    sound_ops::play_sound_pooled_direct(task, slot, priority, volume)
 }
 
 // ── Hook installation ──
@@ -175,12 +174,6 @@ pub fn install() -> Result<(), String> {
             va::WORM_PLAY_SOUND_2,
             trampoline_worm_play_sound_2 as *const (),
         )?;
-
-        // Initialize bridge address for streaming sound functions
-        sound_ops::LOAD_AND_PLAY_STREAMING_ADDR.store(
-            openwa_core::rebase::rb(va::LOAD_AND_PLAY_STREAMING),
-            core::sync::atomic::Ordering::Relaxed,
-        );
     }
 
     Ok(())