refactor: add weapon fire type enums, use Fixed for aim/scale params

Add FireType, FireMethod, and SpecialFireSubtype enums to weapon.rs
with TryFrom<i32>. All weapon dispatch matches in weapon.rs and
weapon_release.rs now use typed enum variants instead of raw integers.

Rename fire_subtype_34 → special_subtype, fire_subtype_38 → fire_method
in WeaponEntry for clarity.

Use Fixed type for aim direction params and landscape_scale field.
Add Mul<i32> for Fixed (integer scaling without shift). Remove
fixed_mul_shrd — superseded by Fixed's Mul impl. Spawn offset
calculation now reads as: aim_dir_x * scale * 0x18.

Rename param_1/param_2 → spawn_x/spawn_y, param_3/param_4 →
aim_dir_x/aim_dir_y based on caller analysis (FUN_0051cb60 computes
adjusted worm position + aim direction from angle).

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

crates/openwa-core/src/fixed.rs

@@ -72,6 +72,15 @@ impl Mul for Fixed {
     }
 }
 
+/// Scale a Fixed value by a plain integer (no shift — just `raw * n`).
+impl Mul<i32> for Fixed {
+    type Output = Self;
+    #[inline]
+    fn mul(self, rhs: i32) -> Self {
+        Self(self.0 * rhs)
+    }
+}
+
 impl Neg for Fixed {
     type Output = Self;
     #[inline]

crates/openwa-core/src/game/weapon.rs

@@ -143,6 +143,130 @@ const _: () = assert!(core::mem::size_of::<WeaponSpawnData>() == 0x2C);
 
 /// Per-weapon data entry in the weapon table (0x1D0 = 464 bytes).
 ///
+/// Top-level weapon fire type (WeaponEntry+0x30).
+///
+/// Determines which sub-function handles the weapon fire in FireWeapon dispatch.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i32)]
+pub enum FireType {
+    /// Projectile weapons (Bazooka, Grenade, Shotgun, etc.).
+    /// Sub-dispatched by `fire_method`.
+    Projectile = 1,
+    /// Rope-based weapons (Ninja Rope, Bungee).
+    /// Sub-dispatched by `fire_method`.
+    Rope = 2,
+    /// Strike weapons (Air Strike, Napalm Strike, Mail Strike, etc.).
+    /// Uses `special_subtype` as parameter data (not a subtype selector).
+    Strike = 3,
+    /// Special weapons (melee, utility, powerups).
+    /// Sub-dispatched by `special_subtype`.
+    Special = 4,
+}
+
+impl TryFrom<i32> for FireType {
+    type Error = i32;
+    fn try_from(v: i32) -> Result<Self, i32> {
+        match v {
+            1 => Ok(Self::Projectile),
+            2 => Ok(Self::Rope),
+            3 => Ok(Self::Strike),
+            4 => Ok(Self::Special),
+            _ => Err(v),
+        }
+    }
+}
+
+/// Fire method for projectile (type 1) and rope (type 2) weapons (WeaponEntry+0x38).
+///
+/// Selects which sub-function creates the projectile or rope entity.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i32)]
+pub enum FireMethod {
+    /// PlacedExplosive: usercall, places mine/dynamite at worm position.
+    PlacedExplosive = 1,
+    /// ProjectileFire: stdcall, fires projectile with spread/rotation.
+    ProjectileFire = 2,
+    /// CreateWeaponProjectile: thiscall, allocates CTaskMissile.
+    CreateWeaponProjectile = 3,
+    /// CreateArrow: thiscall, allocates CTaskArrow (Shotgun, Longbow).
+    CreateArrow = 4,
+}
+
+impl TryFrom<i32> for FireMethod {
+    type Error = i32;
+    fn try_from(v: i32) -> Result<Self, i32> {
+        match v {
+            1 => Ok(Self::PlacedExplosive),
+            2 => Ok(Self::ProjectileFire),
+            3 => Ok(Self::CreateWeaponProjectile),
+            4 => Ok(Self::CreateArrow),
+            _ => Err(v),
+        }
+    }
+}
+
+/// Special weapon subtype (WeaponEntry+0x34, when fire_type == Special).
+///
+/// Each value corresponds to a specific weapon's fire handler.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(i32)]
+pub enum SpecialFireSubtype {
+    Blowtorch = 1,
+    PneumaticDrill = 2,
+    Girder = 3,
+    BaseballBat = 4,
+    FirePunch = 5,
+    DragonBall = 6,
+    // 7: unknown
+    Kamikaze = 8,
+    Prod = 9,
+    AirStrike = 10,
+    ScalesOfJustice = 11,
+    // 12: unknown
+    NapalmStrike = 13,
+    MailMineMole = 14,
+    // 15: unknown
+    IndianNuclearTest = 16,
+    Freeze = 17,
+    SuicideBomber = 18,
+    SkipGo = 19,
+    Surrender = 20,
+    SelectWorm = 21,
+    JetPack = 22,
+    MagicBullet = 23,
+    LowGravity = 24,
+}
+
+impl TryFrom<i32> for SpecialFireSubtype {
+    type Error = i32;
+    fn try_from(v: i32) -> Result<Self, i32> {
+        match v {
+            1 => Ok(Self::Blowtorch),
+            2 => Ok(Self::PneumaticDrill),
+            3 => Ok(Self::Girder),
+            4 => Ok(Self::BaseballBat),
+            5 => Ok(Self::FirePunch),
+            6 => Ok(Self::DragonBall),
+            8 => Ok(Self::Kamikaze),
+            9 => Ok(Self::Prod),
+            10 => Ok(Self::AirStrike),
+            11 => Ok(Self::ScalesOfJustice),
+            13 => Ok(Self::NapalmStrike),
+            14 => Ok(Self::MailMineMole),
+            16 => Ok(Self::IndianNuclearTest),
+            17 => Ok(Self::Freeze),
+            18 => Ok(Self::SuicideBomber),
+            19 => Ok(Self::SkipGo),
+            20 => Ok(Self::Surrender),
+            21 => Ok(Self::SelectWorm),
+            22 => Ok(Self::JetPack),
+            23 => Ok(Self::MagicBullet),
+            24 => Ok(Self::LowGravity),
+            _ => Err(v),
+        }
+    }
+}
+
 /// 71 standard entries (indices 0..70), matching the `Weapon` enum.
 /// Source: wkJellyWorm/src/CustomWeapons.h (WeaponStruct).
 ///
@@ -183,9 +307,9 @@ pub struct WeaponEntry {
     /// Read by FireWeapon to dispatch to the correct handler.
     pub fire_type: i32,
     /// +0x34: Fire subtype for weapon types 3 (grenade/mortar) and 4 (special).
-    pub fire_subtype_34: i32,
+    pub special_subtype: i32,
     /// +0x38: Fire subtype for weapon types 1 (projectile) and 2 (rope).
-    pub fire_subtype_38: i32,
+    pub fire_method: i32,
     /// +0x3C: Fire parameters sub-structure. Pointer to this field is passed
     /// to fire sub-functions (PlacedExplosive, Projectile, CreateWeaponProjectile, etc.).
     pub fire_params: WeaponFireParams,

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

@@ -1,5 +1,6 @@
 use super::base::CTask;
 use super::game_task::CGameTask;
+use crate::fixed::Fixed;
 use crate::game::weapon::WeaponEntry;
 use crate::FieldRegistry;
 
@@ -314,9 +315,9 @@ pub struct CTaskWorm {
     pub _unknown_208: i32,
     /// 0x20C–0x247: Unknown
     pub _unknown_20c: [u8; 0x248 - 0x20C],
-    /// 0x248: Landscape scale factor for spawn offset calculation.
+    /// 0x248: Landscape scale factor for spawn offset calculation (Fixed 16.16).
     /// Used by WeaponRelease to convert aim params to world-space projectile offsets.
-    pub landscape_scale: i32,
+    pub landscape_scale: Fixed,
     /// 0x24C: Aim angle (fixed-point 16.16, range 0..0x10000 = 0..360 degrees).
     pub aim_angle: u32,
     /// 0x250–0x267: Unknown

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

@@ -201,9 +201,8 @@ pub(crate) unsafe extern "cdecl" fn fire_weapon_impl(
 ) {
     use openwa_core::rebase::rb;
 
-    let weapon_type = (*entry).fire_type;
-    let subtype_34 = (*entry).fire_subtype_34;
-    let subtype_38 = (*entry).fire_subtype_38;
+    let fire_type = (*entry).fire_type;
+    let fire_method = (*entry).fire_method;
     let fire_params = &raw const (*entry).fire_params;
     // Log weapon fire
     let weapon_id = (*worm).selected_weapon;
@@ -212,32 +211,33 @@ pub(crate) unsafe extern "cdecl" fn fire_weapon_impl(
         .unwrap_or_else(|id| format!("Unknown({})", id));
     let _ = log_line(&format!(
         "[Weapon] FireWeapon: {} (id={}) type={} sub34={} sub38={}",
-        weapon_name, weapon_id, weapon_type, subtype_34, subtype_38
+        weapon_name, weapon_id, fire_type, (*entry).special_subtype, fire_method
     ));
 
     CTaskWorm::set_fire_complete_raw(worm, 0);
 
-    match weapon_type {
-        1 => match subtype_38 {
-            1 => call_fire_placed_explosive(worm, fire_params, local_struct, rb(0x51EC80)), // PlacedExplosive
-            2 => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51DFB0)),      // Projectile
-            3 => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51E0F0)),     // CreateWeaponProjectile
-            4 => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51ED90)),     // CreateArrow (Shotgun/Longbow)
+    use openwa_core::game::weapon::{FireType, FireMethod, SpecialFireSubtype};
+    match FireType::try_from(fire_type) {
+        Ok(FireType::Projectile) => match FireMethod::try_from(fire_method) {
+            Ok(FireMethod::PlacedExplosive) => call_fire_placed_explosive(worm, fire_params, local_struct, rb(0x51EC80)),
+            Ok(FireMethod::ProjectileFire) => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51DFB0)),
+            Ok(FireMethod::CreateWeaponProjectile) => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51E0F0)),
+            Ok(FireMethod::CreateArrow) => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51ED90)),
             _ => {}
         },
-        2 => match subtype_38 {
-            1 => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51E1C0)),      // RopeType1
-            2 => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51E0F0)),     // CreateWeaponProjectile
-            3 => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51E240)),      // RopeType3
+        Ok(FireType::Rope) => match FireMethod::try_from(fire_method) {
+            Ok(FireMethod::PlacedExplosive) => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51E1C0)), // RopeType1
+            Ok(FireMethod::ProjectileFire) => call_fire_thiscall2(worm, fire_params, local_struct, rb(0x51E0F0)),
+            Ok(FireMethod::CreateWeaponProjectile) => call_fire_stdcall3(worm, fire_params, local_struct, rb(0x51E240)), // RopeType3
             _ => {}
         },
-        3 => {
+        Ok(FireType::Strike) => {
             // StrikeFire takes a pointer to the subtype_34 field (reinterpreted as fire params)
-            let subtype_34_ptr = &raw const (*entry).fire_subtype_34 as *const WeaponFireParams;
+            let subtype_34_ptr = &raw const (*entry).special_subtype as *const WeaponFireParams;
             call_fire_stdcall3(worm, subtype_34_ptr, local_struct, rb(0x51E2C0));
         }
-        4 => {
-            fire_weapon_special(subtype_34, entry, worm, local_struct);
+        Ok(FireType::Special) => {
+            fire_weapon_special((*entry).special_subtype, entry, worm, local_struct);
         }
         _ => {}
     }
@@ -352,61 +352,40 @@ unsafe extern "C" fn call_fire_stdcall2(
 unsafe fn fire_weapon_special(
     subtype: i32, entry: *const WeaponEntry, worm: *mut CTaskWorm, local_struct: *const u8,
 ) {
+    use openwa_core::game::weapon::SpecialFireSubtype as S;
     use openwa_core::rebase::rb;
 
-    // Pointer to fire_subtype_38 field, reinterpreted as fire params pointer for Girder
-    let params_38_ptr = &raw const (*entry).fire_subtype_38 as *const WeaponFireParams;
-
-    match subtype {
-        // Blowtorch
-        1 => CTaskWorm::set_state_raw(worm,WormState::Blowtorch),
-        // Pneumatic Drill (pure Rust)
-        2 => fire_drill(worm, local_struct),
-        // Girder (pure Rust)
-        3 => fire_girder(worm, params_38_ptr, local_struct),
-        // Baseball Bat
-        4 => CTaskWorm::set_state_raw(worm,WormState::BaseballBat),
-        // Fire Punch
-        5 => CTaskWorm::set_state_raw(worm,WormState::FirePunch),
-        // Dragon Ball
-        6 => CTaskWorm::set_state_raw(worm,WormState::DragonBall),
-        // Kamikaze
-        8 => CTaskWorm::set_state_raw(worm,WormState::Kamikaze),
-        // Prod (pure Rust)
-        9 => fire_prod(worm, local_struct),
-        // Air Strike (pure Rust)
-        10 => fire_air_strike(worm),
-        // Scales of Justice
-        11 => CTaskWorm::set_state_raw(worm,WormState::ScalesOfJustice),
-        // Napalm Strike
-        13 => fire_send_team_message(worm, 0x2B),
-        // Mail/Mine/Mole (pure Rust)
-        14 => fire_mail_mine_mole(worm),
-        // Indian Nuclear Test: check worm state, then detonate or cancel
-        16 => {
-            let worm_state = (*worm).state();
-            if can_fire_subtype16(worm_state) {
+    // Pointer to fire_method field, reinterpreted as fire params pointer for Girder
+    let params_38_ptr = &raw const (*entry).fire_method as *const WeaponFireParams;
+
+    match S::try_from(subtype) {
+        Ok(S::Blowtorch) => CTaskWorm::set_state_raw(worm, WormState::Blowtorch),
+        Ok(S::PneumaticDrill) => fire_drill(worm, local_struct),
+        Ok(S::Girder) => fire_girder(worm, params_38_ptr, local_struct),
+        Ok(S::BaseballBat) => CTaskWorm::set_state_raw(worm, WormState::BaseballBat),
+        Ok(S::FirePunch) => CTaskWorm::set_state_raw(worm, WormState::FirePunch),
+        Ok(S::DragonBall) => CTaskWorm::set_state_raw(worm, WormState::DragonBall),
+        Ok(S::Kamikaze) => CTaskWorm::set_state_raw(worm, WormState::Kamikaze),
+        Ok(S::Prod) => fire_prod(worm, local_struct),
+        Ok(S::AirStrike) => fire_air_strike(worm),
+        Ok(S::ScalesOfJustice) => CTaskWorm::set_state_raw(worm, WormState::ScalesOfJustice),
+        Ok(S::NapalmStrike) => fire_send_team_message(worm, 0x2B),
+        Ok(S::MailMineMole) => fire_mail_mine_mole(worm),
+        Ok(S::IndianNuclearTest) => {
+            if can_fire_subtype16((*worm).state()) {
                 fire_indian_nuclear_test(worm);
             } else {
-                CTaskWorm::set_state_raw(worm,WormState::TeleportCancelled_Maybe);
+                CTaskWorm::set_state_raw(worm, WormState::TeleportCancelled_Maybe);
             }
         }
-        // Freeze (pure Rust)
-        17 => fire_freeze(worm),
-        // Suicide Bomber
-        18 => CTaskWorm::set_state_raw(worm,WormState::SuicideBomber),
-        // Skip Go (pure Rust)
-        19 => fire_skip_go(worm, entry),
-        // Surrender (pure Rust)
-        20 => fire_surrender(worm),
-        // Select Worm (pure Rust)
-        21 => fire_select_worm(worm),
-        // Jet Pack (pure Rust)
-        22 => fire_jet_pack(worm),
-        // Magic Bullet
-        23 => CTaskWorm::set_state_raw(worm,WormState::WeaponAimed_Maybe),
-        // Low Gravity — kept on bridge pending codegen UB investigation
-        24 => call_fire_usercall(entry as *const (), worm, rb(0x51EA60)),
+        Ok(S::Freeze) => fire_freeze(worm),
+        Ok(S::SuicideBomber) => CTaskWorm::set_state_raw(worm, WormState::SuicideBomber),
+        Ok(S::SkipGo) => fire_skip_go(worm, entry),
+        Ok(S::Surrender) => fire_surrender(worm),
+        Ok(S::SelectWorm) => fire_select_worm(worm),
+        Ok(S::JetPack) => fire_jet_pack(worm),
+        Ok(S::MagicBullet) => CTaskWorm::set_state_raw(worm, WormState::WeaponAimed_Maybe),
+        Ok(S::LowGravity) => call_fire_usercall(entry as *const (), worm, rb(0x51EA60)),
         _ => {}
     }
 }
@@ -621,10 +600,10 @@ unsafe fn fire_indian_nuclear_test(worm: *mut CTaskWorm) {
     let entry = &*(*worm).active_weapon_entry;
     let team = lookup_team_task(worm);
 
-    // Message 0x59 (RaiseWater): buf[0]=fire_subtype_38, buf[4]=8
+    // Message 0x59 (RaiseWater): buf[0]=fire_method, buf[4]=8
     if !team.is_null() {
         let mut buf = [0u8; 0x40C];
-        buf[0..4].copy_from_slice(&entry.fire_subtype_38.to_ne_bytes());
+        buf[0..4].copy_from_slice(&entry.fire_method.to_ne_bytes());
         buf[4..8].copy_from_slice(&8i32.to_ne_bytes());
         (*team).handle_message((*worm).as_task_ptr_mut(), 0x59, 0x408, buf.as_ptr());
     }
@@ -1059,7 +1038,7 @@ unsafe fn fire_drill(worm: *mut CTaskWorm, local_struct: *const u8) {
     let version = (*ddgame).version_flag_4;
     let entry = &*(*worm).active_weapon_entry;
     let shot_count = entry.fire_params.shot_count;
-    let weapon_type = entry.fire_subtype_38;
+    let weapon_type = entry.fire_method;
     let facing = (*worm).facing_direction_2;
 
     // Cast local_struct to WeaponSpawnData for field access (offsets match)
@@ -1092,7 +1071,7 @@ unsafe fn fire_prod(worm: *mut CTaskWorm, local_struct: *const u8) {
     let entry = &*(*worm).active_weapon_entry;
     let shot_count = entry.fire_params.shot_count;
     let spread = entry.fire_params.spread;
-    let weapon_type = entry.fire_subtype_38;
+    let weapon_type = entry.fire_method;
     let facing = (*worm).facing_direction_2;
 
     let spawn = &*(local_struct as *const WeaponSpawnData);

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

@@ -10,7 +10,7 @@ use openwa_core::audio::SoundId;
 use openwa_core::fixed::Fixed;
 use openwa_core::log::log_line;
 use openwa_core::rebase::rb;
-use openwa_core::task::worm::CTaskWorm;
+use openwa_core::task::worm::{CTaskWorm, WormState};
 use openwa_core::task::{CGameTask, Task};
 
 use crate::hook::{self, usercall_trampoline};
@@ -30,8 +30,8 @@ usercall_trampoline!(fn trampoline_weapon_release; impl_fn = weapon_release_impl
 struct WeaponReleaseContext {
     team_id: u32,
     worm_id: u32,
-    param_1: u32,
-    param_2: u32,
+    spawn_x: u32,
+    spawn_y: u32,
     spawn_offset_x: i32,
     spawn_offset_y: i32,
     ammo_per_turn: u32,
@@ -70,25 +70,14 @@ 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,
+    spawn_x: u32,
+    spawn_y: u32,
+    aim_dir_x: Fixed,
+    aim_dir_y: Fixed,
 ) {
     let w = &*worm;
 
@@ -96,8 +85,8 @@ unsafe extern "cdecl" fn weapon_release_impl(
     let mut ctx = WeaponReleaseContext {
         team_id: 0,
         worm_id: 0,
-        param_1: 0,
-        param_2: 0,
+        spawn_x: 0,
+        spawn_y: 0,
         spawn_offset_x: 0,
         spawn_offset_y: 0,
         ammo_per_turn: 0,
@@ -123,59 +112,64 @@ unsafe extern "cdecl" fn weapon_release_impl(
     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.spawn_x = spawn_x;
+    ctx.spawn_y = spawn_y;
     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;
+    let special_subtype = (*entry).special_subtype;
+    let fire_method = (*entry).fire_method;
 
-    // ── 3. Spawn offset calculation ─────────────────────────
-    let landscape_scale = w.landscape_scale;
+    use openwa_core::game::weapon::{FireType, FireMethod};
 
-    match fire_type {
-        1 => match fire_subtype_38 {
-            1 => {
-                ctx.spawn_offset_x = param_3 * 0x18;
-                ctx.spawn_offset_y = param_4 * 0x18;
+    // ── 3. Spawn offset calculation ─────────────────────────
+    let scale = w.landscape_scale;
+
+    let (mut offset_x, mut offset_y) = (Fixed::ZERO, Fixed::ZERO);
+    match FireType::try_from(fire_type) {
+        Ok(FireType::Projectile) => match FireMethod::try_from(fire_method) {
+            Ok(FireMethod::PlacedExplosive) => {
+                offset_x = aim_dir_x * 0x18;
+                offset_y = aim_dir_y * 0x18;
             }
-            2 => {
-                // Falls through to type 3 (passthrough)
-                ctx.spawn_offset_x = param_3;
-                ctx.spawn_offset_y = param_4;
+            Ok(FireMethod::ProjectileFire) => {
+                // Falls through to Strike (passthrough)
+                offset_x = aim_dir_x;
+                offset_y = aim_dir_y;
             }
-            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;
+            Ok(FireMethod::CreateWeaponProjectile) => {
+                offset_x = aim_dir_x * scale * 0x18;
+                offset_y = aim_dir_y * scale * 0x18;
             }
-            4 => {
-                ctx.spawn_offset_x = param_3 * 0x14;
-                ctx.spawn_offset_y = param_4 * 0x14;
+            Ok(FireMethod::CreateArrow) => {
+                offset_x = aim_dir_x * 0x14;
+                offset_y = aim_dir_y * 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;
+        Ok(FireType::Rope) => {
+            offset_x = aim_dir_x * scale * 0x18;
+            offset_y = aim_dir_y * scale * 0x18;
+            // Special Y adjustment for state 0x79
+            if w.state() == WormState::Unknown_0x79 as u32 {
+                offset_y += w.base.speed_y;
             }
         }
-        3 => {
-            ctx.spawn_offset_x = param_3;
-            ctx.spawn_offset_y = param_4;
+        Ok(FireType::Strike) => {
+            offset_x = aim_dir_x;
+            offset_y = aim_dir_y;
         }
-        4 => {
-            if (fire_subtype_34 as u32).wrapping_sub(1) < 0x18 {
-                ctx.spawn_offset_x = param_3;
-                ctx.spawn_offset_y = param_4;
+        Ok(FireType::Special) => {
+            if (special_subtype as u32).wrapping_sub(1) < 0x18 {
+                offset_x = aim_dir_x;
+                offset_y = aim_dir_y;
             }
         }
         _ => {}
     }
+    ctx.spawn_offset_x = offset_x.0;
+    ctx.spawn_offset_y = offset_y.0;
 
     // ── 4. Delay ────────────────────────────────────────────
     if w.difficulty_level == 0 {
@@ -264,14 +258,13 @@ unsafe extern "cdecl" fn weapon_release_impl(
 
     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 {
+    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);
@@ -311,7 +304,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
                 _ => {}
             }
         }
-        2 => {
+        Ok(FireType::Rope) => {
             if w._unknown_2cc == 0 || w._unknown_2c8 == 1 {
                 let team_sound_raw = (*w.ddgame()).team_sound_id(team_id);
                 if let Ok(sid) = SoundId::try_from(team_sound_raw) {
@@ -319,16 +312,16 @@ unsafe extern "cdecl" fn weapon_release_impl(
                 }
             }
         }
-        // Type 3: no sound
-        4 => {
-            match (*entry).fire_subtype_34 {
+        // Type 3 (Strike): no sound
+        Ok(FireType::Special) => {
+            match (*entry).special_subtype {
                 2 => {
                     sound::play_sound_local(
                         task, SoundId::BaseballBatRelease, 3, Fixed::ONE, Fixed::ONE,
                     );
                 }
                 3 => {
-                    if let Ok(sid) = SoundId::try_from((*entry).fire_subtype_38 as u32) {
+                    if let Ok(sid) = SoundId::try_from((*entry).fire_method as u32) {
                         sound::play_sound_local(task, sid, 3, Fixed::ONE, Fixed::ONE);
                     }
                 }
@@ -385,7 +378,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
 
     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,
+        worm as u32, weapon_id, fire_type, special_subtype, fire_method,
     ));
 }