feat: port WeaponRelease (0x51C3D0) to Rust

Full Rust reimplementation of the weapon release orchestration function
that handles ammo sync, spawn offset calculation, network timing, weapon
stat counters, sound/visual effects, and delegates to FireWeapon.

New module weapon_release.rs with:
- usercall trampoline (EAX=worm, 4 stack params, RET 0x10)
- Pure Rust: sync check, spawn offsets, delay, network timing,
SharedData HandleMessage (0x49), 4 weapon stat counters,
3 weapon category classifiers (IsSuperWeapon, CategoryA/B)
- Rust-to-Rust PlaySoundLocal via new sound::play_sound_local() helper
- Bridges for PlayWormSound/StopWormSound/SpawnEffect (addr-as-param)
- Direct call to fire_weapon_impl (made pub(crate))
- DDGame::advance_effect_rng() for secondary RNG at +0x45F0

Also adds 16 named fields to CTaskWorm (landscape_scale, shot_data,
fire_sync_frames, difficulty_level, weapon_params, sound_handle, etc.),
fills all WormState enum gaps (0x69-0x6B, 0x6F, 0x76, 0x79-0x7A,
0x84-0x85, 0x8A), and removes from_raw_unchecked antipattern.

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

crates/openwa-core/src/address.rs

@@ -345,6 +345,15 @@ pub mod va {
     // =========================================================================
 
     crate::define_addresses! {
+        /// PlayWormSound: usercall(EDI=worm) + stack(sound_handle_id, volume), RET 0x8.
+        /// Stops current streaming sound at worm+0x3B0, then starts a new one.
+        fn PLAY_WORM_SOUND = 0x0051_50D0;
+        /// StopWormSound: usercall(ESI=worm), plain RET.
+        /// Stops streaming sound at worm+0x3B0 and clears the handle.
+        fn STOP_WORM_SOUND = 0x0051_5180;
+        /// SpawnEffect: complex usercall, RET 0x1C.
+        /// Builds a 0x408-byte struct from params, SharedData lookup, HandleMessage(0x56).
+        fn SPAWN_EFFECT = 0x0054_7C30;
         fn INIT_WEAPON_TABLE = 0x0053_CAB0;
         fn COUNT_ALIVE_WORMS = 0x0052_25A0;
         fn GET_AMMO = 0x0052_25E0;

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

@@ -423,6 +423,20 @@ impl DDGame {
         rng
     }
 
+    /// Advance the secondary effect RNG at DDGame+0x45F0 and return the new state.
+    ///
+    /// Formula: `rng = rng * 0x19660D + 0x3C6EF35F` (simpler than [`advance_rng`] — no
+    /// frame_counter). Uses `team_health_ratio[0]`, the unused index-0 slot of the
+    /// 1-indexed health ratio array, repurposed by WA as a secondary RNG for weapon
+    /// release visual effects.
+    pub fn advance_effect_rng(&mut self) -> u32 {
+        let rng = (self.team_health_ratio[0] as u32)
+            .wrapping_mul(0x19660D)
+            .wrapping_add(0x3C6EF35F);
+        self.team_health_ratio[0] = rng as i32;
+        rng
+    }
+
     /// Show the "too many objects" warning on the HUD.
     ///
     /// Sets `hud_status_code = 6` and loads string resource 0x70F into

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

@@ -29,14 +29,20 @@ pub enum WormState {
     Active = 0x67,
     /// Active variant — observed in WormEntry. Start of weapon/action range.
     ActiveVariant_Maybe = 0x68,
-    // 0x69–0x6B: unknown (within weapon/action range)
+    /// Unknown (within weapon/action range).
+    Unknown_0x69 = 0x69,
+    /// Unknown (within weapon/action range).
+    Unknown_0x6A = 0x6A,
+    /// Unknown (within weapon/action range).
+    Unknown_0x6B = 0x6B,
     /// Blowtorch — using the blowtorch weapon.
     Blowtorch = 0x6C,
     /// Baseball Bat — swinging the baseball bat. Frequently checked in HandleMessage.
     BaseballBat = 0x6D,
     /// Kamikaze — performing kamikaze attack.
     Kamikaze = 0x6E,
-    // 0x6F: unknown
+    /// Air Strike pending — set when air strike fires with `_unknown_208 == 0`.
+    AirStrikePending_Maybe = 0x6F,
     /// Dragon Ball — performing dragon ball attack.
     DragonBall = 0x70,
     /// Scales of Justice — using scales of justice.
@@ -50,14 +56,18 @@ pub enum WormState {
     TeleportCancelled_Maybe = 0x74,
     /// Fire Punch — performing fire punch attack.
     FirePunch = 0x75,
-    // 0x76: unknown
+    /// Unknown (within weapon/action range).
+    Unknown_0x76 = 0x76,
     /// Weapon selected — entered via SelectCursor (msg 0x24) from idle/active states.
     /// HandleMessage sets param[0xa7]=-1 when already in this state.
     WeaponSelected_Maybe = 0x77,
     /// Weapon aimed — post-select state. Teleport check accepts this.
     /// Also used for Magic Bullet weapon fire.
     WeaponAimed_Maybe = 0x78,
-    // 0x79–0x7A: unknown
+    /// Unknown. Checked in WeaponRelease spawn offset (type 2, Y adjustment when state == 0x79).
+    Unknown_0x79 = 0x79,
+    /// Unknown.
+    Unknown_0x7A = 0x7A,
     /// Aiming with angle — entered for aimed weapons. Sets angle params.
     /// Teleport check accepts this. Transitions to 0x73 on fire.
     AimingAngle_Maybe = 0x7B,
@@ -80,7 +90,10 @@ pub enum WormState {
     Dying1_Maybe = 0x82,
     /// Dying variant 2 — checked alongside 0x82 in HandleMessage.
     Dying2_Maybe = 0x83,
-    // 0x84–0x85: unknown
+    /// Unknown.
+    Unknown_0x84 = 0x84,
+    /// Unknown.
+    Unknown_0x85 = 0x85,
     /// Dead — set by Surrender (msg 0x29). Frequently checked in HandleMessage.
     Dead = 0x86,
     /// Dead variant 3.
@@ -89,19 +102,14 @@ pub enum WormState {
     Unknown_0x88 = 0x88,
     /// Dying/special animation (from WormEntry state documentation).
     DyingAnimation_Maybe = 0x89,
-    // 0x8A: end of weapon/action range
+    /// Unknown. End of weapon/action range.
+    Unknown_0x8A = 0x8A,
     /// Unknown state checked in CTaskTeam handlers.
     /// Grouped with idle states in HandleMessage switch cases.
     Unknown_0x8B = 0x8B,
 }
 
-impl WormState {
-    /// Create a WormState from a raw u8 value without validation.
-    /// Use for states not yet added to the enum.
-    pub const unsafe fn from_raw_unchecked(val: u8) -> Self {
-        core::mem::transmute(val)
-    }
-}
+impl WormState {}
 
 /// Raw-pointer methods for CTaskWorm.
 ///
@@ -277,8 +285,18 @@ pub struct CTaskWorm {
     pub display_health_raw: u32,
     /// 0x17C: Target health (matches WormEntry.health). Same byte layout as display_health.
     pub target_health_raw: u32,
-    /// 0x180–0x1A7: Unknown
-    pub _unknown_180: [u8; 0x1A8 - 0x180],
+    /// 0x180–0x18F: Unknown
+    pub _unknown_180: [u8; 0x190 - 0x180],
+    /// 0x190: Secondary position/mode field. Air strike temporarily swaps this with +0x34.
+    pub _unknown_190: i32,
+    /// 0x194–0x197: Unknown
+    pub _unknown_194: [u8; 4],
+    /// 0x198: Cleared after air strike fire.
+    pub _unknown_198: i32,
+    /// 0x19C: Cleared after air strike fire.
+    pub _unknown_19c: i32,
+    /// 0x1A0–0x1A7: Unknown
+    pub _unknown_1a0: [u8; 0x1A8 - 0x1A0],
     /// 0x1A8: Facing direction copy. -1 = left, +1 = right (same as +0x3DC).
     pub facing_direction_2: i32,
     /// 0x1AC: Inverted facing direction. +1 = left, -1 = right.
@@ -289,10 +307,16 @@ pub struct CTaskWorm {
     /// in one direction. Resets to 0 when movement resumes after a stop.
     /// Set to -1 when the worm is blocked (e.g. hits a wall).
     pub movement_streak: i32,
-    /// 0x1F0–0x247: Unknown
-    pub _unknown_1f0: [u8; 0x248 - 0x1F0],
-    /// 0x248: Unknown
-    pub _unknown_248: u32,
+    /// 0x1F0–0x207: Unknown
+    pub _unknown_1f0: [u8; 0x208 - 0x1F0],
+    /// 0x208: Action/mode flag. Checked in air strike (must be 0 to fire).
+    /// Cleared after air strike completes.
+    pub _unknown_208: i32,
+    /// 0x20C–0x247: Unknown
+    pub _unknown_20c: [u8; 0x248 - 0x20C],
+    /// 0x248: Landscape scale factor for spawn offset calculation.
+    /// Used by WeaponRelease to convert aim params to world-space projectile offsets.
+    pub landscape_scale: i32,
     /// 0x24C: Aim angle (fixed-point 16.16, range 0..0x10000 = 0..360 degrees).
     pub aim_angle: u32,
     /// 0x250–0x267: Unknown
@@ -301,10 +325,52 @@ pub struct CTaskWorm {
     pub show_cursor: u32,
     /// 0x26C–0x283: Unknown
     pub _unknown_26c: [u8; 0x284 - 0x26C],
-    /// 0x284–0x28B: Aiming data (slots 5–6 in GetEntityData query 0x7D4)
-    pub _unknown_284: [u32; 2],
-    /// 0x28C–0x2EF: Unknown
-    pub _unknown_28c: [u8; 0x64],
+    /// 0x284: Shot/aim data 1 (slot 5 in GetEntityData query 0x7D4).
+    /// For weapons 0x22/0x24 (Teleport/Freeze), copied from shot_data_2 on first fire.
+    /// Sent in HandleMessage 0x49 buffer during WeaponRelease.
+    pub shot_data_1: u32,
+    /// 0x288: Shot/aim data 2 (slot 6 in GetEntityData query 0x7D4).
+    pub shot_data_2: u32,
+    /// 0x28C–0x28F: Unknown
+    pub _unknown_28c: [u8; 4],
+    /// 0x290: Fire sync frame counter 1. Compared with fire_sync_frame_2
+    /// in WeaponRelease; when equal, weapon slot table is reset.
+    pub fire_sync_frame_1: i32,
+    /// 0x294: Fire sync frame counter 2.
+    pub fire_sync_frame_2: i32,
+    /// 0x298–0x2BB: Unknown
+    pub _unknown_298: [u8; 0x2BC - 0x298],
+    /// 0x2BC: Network client index. Compared against max client count
+    /// (5 or 10 depending on FE version) to compute network delay.
+    pub network_client_index: i32,
+    /// 0x2C0: Difficulty level (0 = easier/30-frame delay, 1 = harder/60-frame delay).
+    pub difficulty_level: i32,
+    /// 0x2C4–0x2C7: Unknown
+    pub _unknown_2c4: [u8; 4],
+    /// 0x2C8: Network/sound condition flag. In type 2 (rope) sound dispatch,
+    /// sound plays only when this is 0 OR when it equals 1.
+    pub _unknown_2c8: i32,
+    /// 0x2CC: Network flag. Nonzero = network mode active.
+    /// Used in sound dispatch conditions and HandleMessage 0x49 buffer.
+    pub _unknown_2cc: i32,
+    /// 0x2D0–0x2DF: Unknown
+    pub _unknown_2d0: [u8; 0x2E0 - 0x2D0],
+    /// 0x2E0: Weapon parameter 1. Polymorphic per weapon:
+    /// - WeaponRelease: ammo_per_turn (copied to release context)
+    /// - Air Strike: fire position X
+    /// - Freeze: freeze effect X position
+    pub weapon_param_1: i32,
+    /// 0x2E4: Weapon parameter 2. Polymorphic per weapon:
+    /// - WeaponRelease: ammo_per_slot (copied to release context)
+    /// - Air Strike: fire position Y
+    /// - Freeze: freeze effect Y position
+    pub weapon_param_2: i32,
+    /// 0x2E8–0x2EB: Unknown
+    pub _unknown_2e8: [u8; 4],
+    /// 0x2EC: Weapon parameter 3 / launch count.
+    /// - Weapons 0x22/0x24: checked == 0 to copy shot_data_2 → shot_data_1
+    /// - Freeze: freeze target entity ID
+    pub weapon_param_3: i32,
     /// 0x2F0: Worm name, null-terminated (max 17 chars, from spawn init_data+3)
     #[field(kind = "CString")]
     pub worm_name: [u8; 0x11],
@@ -331,8 +397,14 @@ pub struct CTaskWorm {
     /// Contains fire type (+0x30), subtypes (+0x34/+0x38), and completion flag (+0x3C).
     /// Used by WeaponRelease: `MOV EAX, [EDI+0x36C]` before calling FireWeapon.
     pub active_weapon_entry: *mut WeaponEntry,
-    /// 0x370–0x3DB: Unknown (rope anchor, weapon-specific data, etc.)
-    pub _unknown_370: [u8; 0x3DC - 0x370],
+    /// 0x370–0x3AF: Unknown (rope anchor, weapon-specific data, etc.)
+    pub _unknown_370: [u8; 0x3B0 - 0x370],
+    /// 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,
+    /// 0x3B4–0x3DB: Unknown
+    pub _unknown_3b4: [u8; 0x3DC - 0x3B4],
     /// 0x3DC: Facing direction. -1 = facing left, +1 = facing right.
     pub facing_direction: i32,
     /// 0x3E0–0x3E3: Unknown

crates/openwa-wormkit/src/hook.rs

@@ -77,6 +77,27 @@ macro_rules! usercall_trampoline {
         }
     };
 
+    // 1 register arg, 4 stack params, ret N
+    (fn $name:ident; impl_fn = $impl:path; reg = $reg:ident;
+     stack_params = 4; ret_bytes = $ret:literal) => {
+        #[unsafe(naked)]
+        unsafe extern "C" fn $name() {
+            core::arch::naked_asm!(
+                "push edx",
+                "push [esp+20]",
+                "push [esp+20]",
+                "push [esp+20]",
+                "push [esp+20]",
+                concat!("push ", stringify!($reg)),
+                "call {impl_fn}",
+                "add esp, 20",
+                "pop edx",
+                concat!("ret ", $ret),
+                impl_fn = sym $impl,
+            );
+        }
+    };
+
     // 1 register arg, 5 stack params, ret N
     (fn $name:ident; impl_fn = $impl:path; reg = $reg:ident;
      stack_params = 5; ret_bytes = $ret:literal) => {

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

@@ -16,6 +16,7 @@ mod speech;
 mod task;
 mod team;
 mod weapon;
+mod weapon_release;
 
 /// Write gameplay milestone report. Called from DLL_PROCESS_DETACH.
 pub fn write_gameplay_report() {
@@ -41,5 +42,6 @@ pub fn install_all() -> Result<(), String> {
     game_state_hooks::install()?;
     replay::install()?;
     task::install()?;
+    weapon_release::install()?;
     Ok(())
 }

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

@@ -130,6 +130,34 @@ unsafe extern "cdecl" fn play_sound_local_impl(
     1
 }
 
+/// Play a local sound on a task — Rust-callable version of PlaySoundLocal (0x4FDFE0).
+///
+/// Queues the sound, marks it as local, records the emitter position, and
+/// increments the task's local sound count. Returns true on success.
+pub(crate) unsafe fn play_sound_local(
+    task: *mut CGameTask,
+    sound_id: u32,
+    flags: u32,
+    volume: u32,
+    pitch: u32,
+) -> bool {
+    let gt = &*task;
+    let ddgame = gt.base.ddgame;
+    let entry = match queue_sound(ddgame, sound_id, flags, volume, pitch) {
+        Some(e) => e,
+        None => return false,
+    };
+
+    (*entry).is_local = 1;
+
+    let emitter = &gt.sound_emitter;
+    (*entry).secondary_vtable = emitter as *const _ as u32;
+    ((*emitter.vtable).get_position)(emitter, &mut (*entry).pos_x, &mut (*entry).pos_y);
+
+    (*task).sound_emitter.local_sound_count += 1;
+    true
+}
+
 // ============================================================
 // Sound dispatch helpers (bridge: queue → DSSound)
 // ============================================================

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

@@ -195,7 +195,7 @@ unsafe extern "C" fn trampoline_fire_weapon() {
 ///
 /// Completion flag at worm+0x3C (CGameTask.subclass_data[12]).
 /// Params pointer at entry+0x3C (WeaponEntry.fire_complete) — different object, same offset.
-unsafe extern "cdecl" fn fire_weapon_impl(
+pub(crate) unsafe extern "cdecl" fn fire_weapon_impl(
     entry: *const WeaponEntry, local_struct: *const u8, worm: *mut CTaskWorm,
 ) {
     use openwa_core::rebase::rb;
@@ -564,11 +564,8 @@ unsafe fn fire_mail_mine_mole(worm: *mut CTaskWorm) {
 unsafe fn fire_air_strike(worm: *mut CTaskWorm) {
     use openwa_core::rebase::rb;
 
-    let worm_raw = worm as *mut u8;
-    let field_208 = *(worm_raw.add(0x208) as *const i32);
-
-    if field_208 == 0 {
-        CTaskWorm::set_state_raw(worm,WormState::from_raw_unchecked(0x6F));
+    if (*worm)._unknown_208 == 0 {
+        CTaskWorm::set_state_raw(worm,WormState::AirStrikePending_Maybe);
         return;
     }
 
@@ -576,14 +573,14 @@ unsafe fn fire_air_strike(worm: *mut CTaskWorm) {
     call_worm_play_sound(worm, 0x36, 0x10000, 3, rb(0x515020));
 
     // Spawn visual effect: usercall(EAX=0x80000, ECX=x) + stdcall(y, 0, 0, 0, 600, 0x10000, 0x1999)
-    let fire_x = *(worm_raw.add(0x2E0) as *const i32);
-    let fire_y = *(worm_raw.add(0x2E4) as *const i32);
+    let fire_x = (*worm).weapon_param_1;
+    let fire_y = (*worm).weapon_param_2;
     call_spawn_effect(fire_x, fire_y, rb(0x547C30));
 
     // Temporarily swap worm+0x34 with worm+0x190, call position update, restore
+    let worm_raw = worm as *mut u8;
     let saved_34 = *(worm_raw.add(0x34) as *const i32);
-    let field_190 = *(worm_raw.add(0x190) as *const i32);
-    *(worm_raw.add(0x34) as *mut i32) = field_190;
+    *(worm_raw.add(0x34) as *mut i32) = (*worm)._unknown_190;
     call_position_update(worm, fire_x, fire_y, rb(0x4FE070));
     *(worm_raw.add(0x34) as *mut i32) = saved_34;
 
@@ -599,10 +596,10 @@ unsafe fn fire_air_strike(worm: *mut CTaskWorm) {
 
     // Clear action fields
     *(worm_raw.add(0x48) as *mut i32) = 0;
-    *(worm_raw.add(0x208) as *mut i32) = 0;
-    *(worm_raw.add(0x198) as *mut i32) = 0;
-    *(worm_raw.add(0x19C) as *mut i32) = 0;
-    *(worm_raw.add(0x1AC) as *mut i32) = 0;
+    (*worm)._unknown_208 = 0;
+    (*worm)._unknown_198 = 0;
+    (*worm)._unknown_19c = 0;
+    (*worm).facing_direction_inv = 0;
 
     // FUN_0050D450: usercall(ESI=worm), cleanup/landing check
     call_worm_landing_check(worm, rb(0x50D450));
@@ -963,10 +960,9 @@ unsafe fn fire_freeze(worm: *mut CTaskWorm) {
     let game_version = (*(*ddgame).game_info).game_version;
 
     // Read freeze position and target from CTaskWorm fields
-    let worm_raw = worm as *const u8;
-    let freeze_x = *(worm_raw.add(0x2E0) as *const i32);
-    let freeze_y = *(worm_raw.add(0x2E4) as *const i32);
-    let freeze_target = *(worm_raw.add(0x2EC) as *const i32);
+    let freeze_x = (*worm).weapon_param_1;
+    let freeze_y = (*worm).weapon_param_2;
+    let freeze_target = (*worm).weapon_param_3;
 
     // Choose sound: 0x70 if freeze has target or old version, else 0x73
     let sound_id: u32 = if freeze_target != 0 || game_version < 0x21 {

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

@@ -0,0 +1,513 @@
+//! WeaponRelease hook (0x51C3D0).
+//!
+//! Orchestrates weapon firing: ammo sync, spawn offset calculation, network timing,
+//! weapon stat counters, sound/visual effects, then delegates to FireWeapon (in weapon.rs).
+//!
+//! Convention: usercall(EAX=CTaskWorm*) + 4 stack params, RET 0x10.
+
+use openwa_core::address::va;
+use openwa_core::log::log_line;
+use openwa_core::rebase::rb;
+use openwa_core::task::worm::CTaskWorm;
+use openwa_core::task::{CGameTask, SharedDataTable, Task};
+
+use crate::hook::{self, usercall_trampoline};
+use crate::replacements::{sound, weapon};
+
+// ── Trampoline ──────────────────────────────────────────────
+
+usercall_trampoline!(fn trampoline_weapon_release; impl_fn = weapon_release_impl;
+    reg = eax; stack_params = 4; ret_bytes = "0x10");
+
+// ── WeaponReleaseContext ────────────────────────────────────
+
+/// The 0x2C-byte stack-local struct populated by WeaponRelease and passed to
+/// FireWeapon as the `local_struct` (ECX) parameter.
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct WeaponReleaseContext {
+    team_id: u32,
+    worm_id: u32,
+    param_1: u32,
+    param_2: u32,
+    spawn_offset_x: i32,
+    spawn_offset_y: i32,
+    ammo_per_turn: u32,
+    ammo_per_slot: u32,
+    _zero: u32,
+    delay: u32,
+    network_delay: i32,
+}
+
+const _: () = assert!(core::mem::size_of::<WeaponReleaseContext>() == 0x2C);
+
+// ── Weapon category classifiers (pure Rust) ─────────────────
+
+/// IsSuperWeapon (0x565960): returns true for "super weapon" IDs.
+/// param_1 is the byte at DDGame+0x7E3F; for weapon 0x3B (SelectWorm) it returns param_1.
+fn is_super_weapon(weapon_id: u32, ddgame_7e3f: u8) -> bool {
+    match weapon_id {
+        10 | 0x13 | 0x1D | 0x1E | 0x1F | 0x24 | 0x29 | 0x2A | 0x2D | 0x2E | 0x31 | 0x32
+        | 0x33 | 0x36 | 0x37 | 0x38 | 0x3C | 0x3D => true,
+        0x3B => ddgame_7e3f != 0,
+        _ => false,
+    }
+}
+
+/// FUN_005658C0: weapon category A — checks if weapon is in a specific set.
+fn is_weapon_category_a(weapon_id: u32) -> bool {
+    matches!(
+        weapon_id,
+        4 | 5 | 0x17 | 0x18 | 0x19 | 0x1A | 0x1F | 0x2D | 0x2E | 0x30 | 0x32 | 0x34 | 0x35
+            | 0x36
+    )
+}
+
+/// FUN_00565920: weapon category B — checks if weapon is in a specific set.
+fn is_weapon_category_b(weapon_id: u32) -> bool {
+    matches!(weapon_id, 0x1C | 0x2C | 0x2F | 0x32)
+}
+
+// ── Fixed-point multiply ────────────────────────────────────
+
+/// Fixed-point 16.16 multiply: (a * b) >> 16, using SHRD like the original.
+/// Matches the `IMUL + SHRD EAX,EDX,0x10` pattern in the disassembly.
+#[inline(always)]
+fn fixed_mul_shrd(a: i32, b: i32) -> i32 {
+    let product = (a as i64) * (b as i64);
+    // SHRD EAX,EDX,0x10: shift the full 64-bit result right by 16
+    (product >> 16) as i32
+}
+
+// ── Main implementation ─────────────────────────────────────
+
+unsafe extern "cdecl" fn weapon_release_impl(
+    worm: *mut CTaskWorm,
+    param_1: u32,
+    param_2: u32,
+    param_3: i32,
+    param_4: i32,
+) {
+    let w = &*worm;
+
+    // Initialize context struct to zero
+    let mut ctx = WeaponReleaseContext {
+        team_id: 0,
+        worm_id: 0,
+        param_1: 0,
+        param_2: 0,
+        spawn_offset_x: 0,
+        spawn_offset_y: 0,
+        ammo_per_turn: 0,
+        ammo_per_slot: 0,
+        _zero: 0,
+        delay: 0,
+        network_delay: 0,
+    };
+
+    // ── 1. Sync check ───────────────────────────────────────
+    if w.fire_sync_frame_1 == w.fire_sync_frame_2 {
+        let ddgame = w.ddgame() as *mut u8;
+        *(ddgame.add(0x72E4) as *mut u32) = 0x0E;
+        let mut offset = 0u32;
+        while (offset as i32) < 0x118 {
+            *(ddgame.add(0x73B0).add(offset as usize) as *mut u32) = 0;
+            offset += 0x14;
+        }
+        *(ddgame.add(0x739C) as *mut u32) = 0;
+    }
+
+    // ── 2. Populate context fields ──────────────────────────
+    let speed_x = w.base.pos_x.0;
+    let speed_y = w.base.pos_y.0;
+    ctx.team_id = w.team_index;
+    ctx.worm_id = w.worm_index;
+    ctx.ammo_per_turn = w.weapon_param_1 as u32;
+    ctx.param_2 = param_2;
+    ctx.param_1 = param_1;
+    ctx.ammo_per_slot = w.weapon_param_2 as u32;
+
+    let entry = w.active_weapon_entry;
+    let fire_type = (*entry).fire_type;
+    let fire_subtype_34 = (*entry).fire_subtype_34;
+    let fire_subtype_38 = (*entry).fire_subtype_38;
+
+    // ── 3. Spawn offset calculation ─────────────────────────
+    let landscape_scale = w.landscape_scale;
+
+    match fire_type {
+        1 => match fire_subtype_38 {
+            1 => {
+                ctx.spawn_offset_x = param_3 * 0x18;
+                ctx.spawn_offset_y = param_4 * 0x18;
+            }
+            2 => {
+                // Falls through to type 3 (passthrough)
+                ctx.spawn_offset_x = param_3;
+                ctx.spawn_offset_y = param_4;
+            }
+            3 => {
+                ctx.spawn_offset_x = fixed_mul_shrd(param_3, landscape_scale) * 0x18;
+                ctx.spawn_offset_y = fixed_mul_shrd(param_4, landscape_scale) * 0x18;
+            }
+            4 => {
+                ctx.spawn_offset_x = param_3 * 0x14;
+                ctx.spawn_offset_y = param_4 * 0x14;
+            }
+            _ => {}
+        },
+        2 => {
+            ctx.spawn_offset_x = fixed_mul_shrd(param_3, landscape_scale) * 0x18;
+            ctx.spawn_offset_y = fixed_mul_shrd(param_4, landscape_scale) * 0x18;
+            // Special Y adjustment for angle 0x79
+            if w.state() == 0x79 {
+                ctx.spawn_offset_y += w.base.speed_y.0;
+            }
+        }
+        3 => {
+            ctx.spawn_offset_x = param_3;
+            ctx.spawn_offset_y = param_4;
+        }
+        4 => {
+            if (fire_subtype_34 as u32).wrapping_sub(1) < 0x18 {
+                ctx.spawn_offset_x = param_3;
+                ctx.spawn_offset_y = param_4;
+            }
+        }
+        _ => {}
+    }
+
+    // ── 4. Delay ────────────────────────────────────────────
+    if w.difficulty_level == 0 {
+        ctx.delay = 0x1E;
+    } else if w.difficulty_level == 1 {
+        ctx.delay = 0x3C;
+    }
+
+    // ── 5. Network timing ───────────────────────────────────
+    let ddgame_ptr = w.ddgame();
+    let ddgame_raw = ddgame_ptr as *const u8;
+    let ptr_at_24 = *(ddgame_raw.add(0x24) as *const *const u8);
+    let is_network = *ptr_at_24.add(0xD9D0);
+    let fe_version = *ptr_at_24.add(0xD9B1);
+
+    let mut adjust = 0i32;
+    let max_clients = if is_network == 0 {
+        5
+    } else if fe_version < 0x1B {
+        10
+    } else {
+        adjust = -1;
+        10
+    };
+
+    let client_idx = w.network_client_index;
+    if ((client_idx - adjust) as u32) < ((max_clients - adjust) as u32) {
+        ctx.network_delay = (client_idx + 1) * 1000;
+    }
+
+    // ── 6. Weapon 0x22/0x24 special ─────────────────────────
+    let weapon_id = w.selected_weapon;
+    if (weapon_id == 0x22 || weapon_id == 0x24) && w.weapon_param_3 == 0 {
+        (*worm).shot_data_1 = w.shot_data_2;
+    }
+
+    // ── 7. SharedData HandleMessage (msg 0x49) ──────────────
+    let mut msg_buf = [0u8; 0x408];
+    write_u32(&mut msg_buf, 0x00, w.team_index);
+    write_u32(&mut msg_buf, 0x04, w.worm_index);
+    write_u32(&mut msg_buf, 0x08, w.shot_data_1);
+    write_u32(&mut msg_buf, 0x0C, w.shot_data_2);
+    write_u32(&mut msg_buf, 0x10, w.fire_sync_frame_1 as u32);
+    write_u32(&mut msg_buf, 0x14, w.fire_sync_frame_2 as u32);
+    write_u32(
+        &mut msg_buf,
+        0x18,
+        if w._unknown_2cc != 0 { 1 } else { 0 },
+    );
+    write_u32(&mut msg_buf, 0x1C, weapon_id);
+
+    let table = SharedDataTable::from_task((*worm).as_task_ptr());
+    let team_entity = table.lookup(0, 0x14);
+    if !team_entity.is_null() {
+        let vtable = *(team_entity as *const *const usize);
+        let handle_msg: unsafe extern "thiscall" fn(
+            *mut u8,
+            *mut u8,
+            u32,
+            u32,
+            *const u8,
+        ) = core::mem::transmute(*vtable.add(2));
+        handle_msg(
+            team_entity as *mut u8,
+            (*worm).as_task_ptr_mut() as *mut u8,
+            0x49,
+            0x408,
+            msg_buf.as_ptr(),
+        );
+    }
+
+    // ── 8. Weapon stat counters ─────────────────────────────
+    let ddgame = (*worm).ddgame() as *mut u8;
+    let team_id = (*worm).team_index;
+    let worm_id = (*worm).worm_index;
+    let current_weapon_byte = *ddgame.add(0x7E3F);
+
+    if is_super_weapon(weapon_id, current_weapon_byte) {
+        let counter = ddgame
+            .add(0x40D8)
+            .add((team_id * 0x51C) as usize)
+            .add((worm_id * 0x9C) as usize) as *mut i32;
+        *counter += 1;
+    }
+
+    // Range 0x3E..=0x46
+    if weapon_id.wrapping_sub(0x3E) <= 8 {
+        let counter = ddgame
+            .add(0x40D4)
+            .add((team_id * 0x51C) as usize)
+            .add((worm_id * 0x9C) as usize) as *mut i32;
+        *counter += 1;
+    }
+
+    if is_weapon_category_a(weapon_id) {
+        let counter = ddgame
+            .add(0x40D0)
+            .add((team_id * 0x51C) as usize)
+            .add((worm_id * 0x9C) as usize) as *mut i32;
+        *counter += 1;
+    }
+
+    if is_weapon_category_b(weapon_id) {
+        let counter = ddgame
+            .add(0x40CC)
+            .add((team_id * 0x51C) as usize)
+            .add((worm_id * 0x9C) as usize) as *mut i32;
+        *counter += 1;
+    }
+
+    // ── 9. Sound dispatch + 10. Visual effect ───────────────
+    let task = worm as *mut CGameTask;
+    let mut do_effect = false;
+    let mut effect_state: u32 = 0x73;
+
+    let w = &*worm; // re-borrow after mutation above
+    let entry = w.active_weapon_entry;
+    let fire_type = (*entry).fire_type;
+
+    let play_worm_sound_addr = rb(va::PLAY_WORM_SOUND);
+    let stop_worm_sound_addr = rb(va::STOP_WORM_SOUND);
+
+    match fire_type {
+        1 => {
+            match (*entry).fire_subtype_34 {
+                1 => {
+                    if w.sound_handle == 0 {
+                        call_play_worm_sound(worm, 0x1004E, 0x10000, play_worm_sound_addr);
+                    }
+                    do_effect = true;
+                    effect_state = 0x73;
+                }
+                2 => {
+                    sound::play_sound_local(task, 0x49, 3, 0x10000, 0x10000);
+                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                }
+                3 | 7 | 0xB | 0xC => {
+                    sound::play_sound_local(task, 0x4B, 3, 0x10000, 0x10000);
+                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                }
+                4 => {
+                    if w.sound_handle == 0 {
+                        call_play_worm_sound(worm, 0x1004F, 0x10000, play_worm_sound_addr);
+                    }
+                    do_effect = true;
+                    effect_state = 0x73;
+                }
+                5 => {
+                    sound::play_sound_local(task, 0x50, 3, 0x10000, 0x10000);
+                    do_effect = true;
+                    effect_state = 0x75;
+                }
+                6 => {
+                    sound::play_sound_local(task, 0x52, 3, 0x10000, 0x10000);
+                    do_effect = true;
+                    effect_state = 0x73;
+                }
+                10 => {
+                    sound::play_sound_local(task, 0x1D, 3, 0x10000, 0x10000);
+                    call_stop_worm_sound(worm, stop_worm_sound_addr);
+                }
+                _ => {}
+            }
+        }
+        2 => {
+            if w._unknown_2cc == 0 || w._unknown_2c8 == 1 {
+                // Team sound from DDGame+0x7768 + team_id * 0xF0
+                let ddgame = w.ddgame() as *const u8;
+                let team_sound_offset = (team_id as usize) * 0xF0 + 0x7768;
+                let team_sound = *(ddgame.add(team_sound_offset) as *const u32);
+                sound::play_sound_local(task, team_sound, 3, 0x10000, 0x10000);
+            }
+        }
+        // Type 3: no sound
+        4 => {
+            match (*entry).fire_subtype_34 {
+                2 => {
+                    sound::play_sound_local(task, 0x60, 3, 0x10000, 0x10000);
+                }
+                3 => {
+                    let sound_id = (*entry).fire_subtype_38 as u32;
+                    sound::play_sound_local(task, sound_id, 3, 0x10000, 0x10000);
+                }
+                4 => {
+                    let sound_id = *((&raw const (*entry).fire_params as *const u8).add(4)
+                        as *const u32);
+                    sound::play_sound_local(task, sound_id, 3, 0x10000, 0x10000);
+                }
+                10 => {
+                    if w._unknown_208 == 0 {
+                        sound::play_sound_local(task, 0x43, 3, 0x10000, 0x10000);
+                    }
+                }
+                0xB => {
+                    if w.sound_handle == 0 {
+                        call_play_worm_sound(worm, 0x10035, 0x10000, play_worm_sound_addr);
+                    }
+                }
+                _ => {}
+            }
+        }
+        _ => {}
+    }
+
+    // ── 10. Visual effect (if triggered by sound dispatch) ──
+    if do_effect {
+        let ddgame = &mut *(*worm).ddgame();
+        let gfx_handler = *((&raw const *ddgame as *const u8).add(0x528) as *const *const u8);
+        let palette = *(gfx_handler.add(0x22C) as *const u32);
+
+        let rng1 = ddgame.advance_effect_rng();
+        let rng2 = ddgame.advance_effect_rng();
+
+        let rng2_offset = (rng2 & 0xFFFF) as i32 - 0x18000;
+        let facing = (*worm).facing_direction_2;
+        let rng_scaled = rng2_offset * facing;
+
+        let rng1_offset = (rng1 & 0xFFFF) as i32 - 0x18000;
+
+        let facing_flag: u32 = if facing < 1 { 0x40000 } else { 0 };
+        let state_flag = facing_flag + effect_state;
+
+        call_spawn_effect_full(
+            worm, speed_x, speed_y, rng_scaled, rng1_offset, palette, state_flag, 0xA0000,
+            0x1999, rb(va::SPAWN_EFFECT),
+        );
+    }
+
+    // ── 11. Call FireWeapon ──────────────────────────────────
+    let entry = (*worm).active_weapon_entry;
+    let ctx_ptr = &ctx as *const WeaponReleaseContext as *const u8;
+    weapon::fire_weapon_impl(entry, ctx_ptr, worm);
+
+    let _ = log_line(&format!(
+        "[WeaponRelease] worm=0x{:08X} weapon={} type={} sub34={} sub38={}",
+        worm as u32, weapon_id, fire_type, fire_subtype_34, fire_subtype_38,
+    ));
+}
+
+// ── Helper ──────────────────────────────────────────────────
+
+#[inline(always)]
+fn write_u32(buf: &mut [u8], offset: usize, value: u32) {
+    buf[offset..offset + 4].copy_from_slice(&value.to_ne_bytes());
+}
+
+// ── 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)]
+unsafe extern "C" fn call_spawn_effect_full(
+    _worm: *mut CTaskWorm,
+    _speed_x: i32,
+    _speed_y: i32,
+    _rng_scaled: i32,
+    _rng_offset: i32,
+    _palette: u32,
+    _state_flag: u32,
+    _size: u32,
+    _scale: u32,
+    _addr: u32,
+) {
+    core::arch::naked_asm!(
+        "push esi",
+        "push ebx",
+        // Stack: 2 saves(8) + ret(4) = 12 to first arg
+        // Args: +12=worm, +16=speed_x, +20=speed_y, +24=rng_scaled, +28=rng_offset,
+        //       +32=palette, +36=state_flag, +40=size, +44=scale, +48=addr
+        "mov esi, [esp+12]",   // worm → ESI
+        "mov ecx, [esp+16]",   // speed_x → ECX
+        "mov ebx, [esp+48]",   // addr
+        "push [esp+44]",       // scale
+        "push [esp+44]",       // size
+        "push [esp+44]",       // state_flag
+        "push [esp+44]",       // palette
+        "push [esp+44]",       // rng_offset
+        "push [esp+44]",       // rng_scaled
+        "push [esp+44]",       // speed_y (first stack param)
+        "mov eax, 0x80000",
+        "call ebx",
+        "pop ebx",
+        "pop esi",
+        "ret",
+    );
+}
+
+// ── Hook installation ───────────────────────────────────────
+
+pub fn install() -> Result<(), String> {
+    unsafe {
+        hook::install(
+            "WeaponRelease",
+            va::WEAPON_RELEASE,
+            trampoline_weapon_release as *const (),
+        )?;
+    }
+    Ok(())
+}