refactor: rename NapalmStrike subtype to StrikeFire

SpecialFireSubtype::NapalmStrike (subtype 13) is actually used by
multiple weapons (Napalm Strike, Surrender, and others) — it's a
generic "send team message 0x2B" handler, not Napalm-specific.

Renamed to StrikeFire to match the WA function name (StrikeFire at
0x51E2C0). Also renamed TeamMessage::NapalmStrike to StrikeFire and
on_napalm_strike to on_strike_fire.

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

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

@@ -223,7 +223,7 @@ pub enum SpecialFireSubtype {
     AirStrike = 10,
     ScalesOfJustice = 11,
     // 12: unknown
-    NapalmStrike = 13,
+    StrikeFire = 13,
     MailMineMole = 14,
     // 15: unknown
     IndianNuclearTest = 16,
@@ -251,7 +251,7 @@ impl TryFrom<i32> for SpecialFireSubtype {
             9 => Ok(Self::Prod),
             10 => Ok(Self::AirStrike),
             11 => Ok(Self::ScalesOfJustice),
-            13 => Ok(Self::NapalmStrike),
+            13 => Ok(Self::StrikeFire),
             14 => Ok(Self::MailMineMole),
             16 => Ok(Self::IndianNuclearTest),
             17 => Ok(Self::Freeze),

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

@@ -118,26 +118,20 @@ bind_CTaskTeamVTable!(CTaskTeam, base.vtable);
 // ── Typed message handlers ──────────────────────────────────
 
 impl CTaskTeam {
-    /// Handle NapalmStrike message (0x2B) — ported from CTaskTeam::HandleMessage.
+    /// Handle StrikeFire / Surrender message (0x2B) — ported from
+    /// CTaskTeam::HandleMessage case 0x2B.
     ///
-    /// Uses raw pointer (not `&mut self`) to avoid noalias issues with broadcast calls.
-    ///
-    /// Logic:
-    /// 1. Team ownership check (msg team_index must match this.team_index)
-    /// 2. If game_version > 0xF4: broadcast DetonateWeapon (0x2A) to children
-    /// 3. Set per-team napalm flag at ddgame + team_index * 0x51C + 0x4618
-    /// 4. Broadcast original message (0x2B) to children
-    ///
-    /// # Safety
-    /// `this` must be a valid CTaskTeam pointer with valid ddgame.
-    /// Handle NapalmStrike message (0x2B) — ported from CTaskTeam::HandleMessage.
+    /// Used by SpecialFireSubtype::StrikeFire (subtype 13), shared by
+    /// Napalm Strike, Surrender, and other weapons.
     ///
     /// Uses `CTask::broadcast_message_raw` for child dispatch (no `&mut self`,
     /// no noalias UB). This is a pure Rust handler — no bridge to WA code.
     ///
+    /// **Status:** Has a behavioral difference vs the WA handler — under investigation.
+    ///
     /// # Safety
     /// `this` must be a valid CTaskTeam pointer with valid ddgame.
-    pub unsafe fn on_napalm_strike(
+    pub unsafe fn on_strike_fire(
         this: *mut Self,
         sender: *mut CTask,
         msg_team_index: u32,

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

@@ -12,9 +12,11 @@ use crate::game::TaskMessage;
 /// its payload as typed fields instead of a raw byte buffer.
 #[derive(Debug, Clone, Copy)]
 pub enum TeamMessage {
-    /// 0x2B (Surrender): Napalm strike or similar team-targeted action.
+    /// 0x2B (Surrender): Strike fire / team-targeted action.
+    /// Used by SpecialFireSubtype::StrikeFire (subtype 13) — shared by
+    /// Napalm Strike, Surrender, and other weapons that send a team message.
     /// Sets a per-team flag and optionally broadcasts DetonateWeapon.
-    NapalmStrike {
+    StrikeFire {
         /// Team index (1-based) identifying which team fired.
         team_index: u32,
     },
@@ -32,12 +34,11 @@ impl TeamMessage {
     pub unsafe fn from_raw(msg_type: u32, _size: u32, data: *const u8) -> Option<Self> {
         match TaskMessage::try_from(msg_type) {
             Ok(TaskMessage::Surrender) => {
-                // data[0..4] = team_index
                 if data.is_null() {
                     return None;
                 }
                 let team_index = *(data as *const u32);
-                Some(TeamMessage::NapalmStrike { team_index })
+                Some(TeamMessage::StrikeFire { team_index })
             }
             _ => None,
         }
@@ -48,7 +49,7 @@ impl TeamMessage {
     /// Writes the payload into `buf` and returns `(msg_type, size)`.
     pub fn to_raw(&self, buf: &mut [u8]) -> (u32, u32) {
         match self {
-            TeamMessage::NapalmStrike { team_index } => {
+            TeamMessage::StrikeFire { team_index } => {
                 buf[0..4].copy_from_slice(&team_index.to_ne_bytes());
                 (TaskMessage::Surrender as u32, 4)
             }

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

@@ -323,7 +323,7 @@ unsafe fn fire_weapon_special(
         Ok(S::Prod) => fire_prod(worm, ctx as *const u8),
         Ok(S::AirStrike) => fire_air_strike(worm),
         Ok(S::ScalesOfJustice) => CTaskWorm::set_state_raw(worm, WormState::ScalesOfJustice),
-        Ok(S::NapalmStrike) => fire_napalm_strike_typed(worm),
+        Ok(S::StrikeFire) => fire_strike_typed(worm),
         Ok(S::MailMineMole) => fire_mail_mine_mole(worm),
         Ok(S::IndianNuclearTest) => {
             if can_fire_subtype16((*worm).state()) {
@@ -364,14 +364,13 @@ pub(crate) unsafe fn lookup_team_task(worm: *const CTaskWorm) -> *mut openwa_cor
     table.lookup(0, 0x14) as *mut openwa_core::task::CTaskTeam
 }
 
-/// Napalm Strike (subtype 14) — typed Rust handler.
+/// StrikeFire (subtype 13) — typed Rust handler.
 ///
-/// Calls on_napalm_strike which uses broadcast_message_raw.
-/// Napalm Strike (subtype 14) — typed Rust handler.
-///
-/// Uses on_napalm_strike for the full Rust path.
+/// Shared by Napalm Strike, Surrender, and other weapons that send
+/// message 0x2B to CTaskTeam. Constructs a typed TeamMessage::StrikeFire,
+/// serializes to raw bytes, and dispatches through CTaskTeam's WA vtable.
 #[inline(never)]
-unsafe fn fire_napalm_strike_typed(worm: *mut CTaskWorm) {
+unsafe fn fire_strike_typed(worm: *mut CTaskWorm) {
     use openwa_core::task::TeamMessage;
 
     let team = lookup_team_task(worm);
@@ -379,7 +378,7 @@ unsafe fn fire_napalm_strike_typed(worm: *mut CTaskWorm) {
         return;
     }
 
-    let msg = TeamMessage::NapalmStrike {
+    let msg = TeamMessage::StrikeFire {
         team_index: (*worm).team_index,
     };
     let mut buf = [0u8; 0x40C];