refactor: rename CGameTask._unknown_30 to subclass_data, add CTaskWorm weapon accessors

Rename the polymorphic 84-byte region at CGameTask+0x30 to
subclass_data with documentation of per-subclass usage (worm weapon
state, filter subscriptions, missile params, team vtable, etc.).

Add CTaskWorm weapon fire accessor methods:
- weapon_fire_type(), weapon_fire_subtype_34/38()
- weapon_fire_complete() / weapon_fire_complete_mut()
- weapon_params_ptr(), weapon_params_34_ptr(), weapon_params_38_ptr()
- weapon_self_ptr field at +0x36C

Make task::worm and task::game_task modules public.

Update FireWeapon impl to use worm_eax (first cdecl param = EAX) for
field reads — must match original register source for determinism.

Verified: headless PASS (byte-identical), headful 133+3 / 0 FAIL.

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

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

@@ -13,8 +13,15 @@ use crate::fixed::Fixed;
 pub struct CGameTask {
     /// 0x00-0x2F: Base CTask fields
     pub base: CTask,
-    /// 0x30-0x83: Unknown gameplay fields (84 bytes)
-    pub _unknown_30: [u8; 0x54],
+    /// 0x30-0x83: Subclass-specific data (84 bytes). Each CGameTask derivative
+    /// uses this region differently:
+    /// - CTaskWorm: weapon fire state (+0x30 type, +0x34/+0x38 subtypes, +0x3C flag)
+    /// - CTaskFilter: boolean message subscription table (+0x30..+0x93)
+    /// - CTaskMissile: spawn/physics parameters
+    /// - CTaskTeam: secondary vtable pointer (+0x30)
+    /// - CTaskCloud: parallax scroll depth (+0x30)
+    /// Access via subclass accessor methods, not directly.
+    pub subclass_data: [u8; 0x54],
     /// 0x84: X position in fixed-point
     pub pos_x: Fixed,
     /// 0x88: Y position in fixed-point

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

@@ -10,7 +10,7 @@ mod overlays;
 mod supply_crate;
 mod team;
 mod turn_game;
-mod worm;
+pub mod worm;
 
 pub use base::{CTask, CTaskBfsIter, SharedDataIter, SharedDataNode, SharedDataTable};
 pub use cloud::CTaskCloud;

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

@@ -75,7 +75,7 @@ const _: () = assert!(core::mem::size_of::<CTaskWormVTable>() == 20 * 4);
 /// Vtable at 0x6644C8. Class type byte: 0x12.
 ///
 /// # Important fields in the CGameTask base
-/// The worm state field lives at **offset +0x44** (inside `base._unknown_30`).
+/// The worm state field lives at **offset +0x44** (inside `base.subclass_data`).
 /// Use [`CTaskWorm::state`] to read it without pointer arithmetic.
 ///
 /// Source: Ghidra decompilation of 0x50BFB0, vtable analysis of 0x6644C8,
@@ -175,16 +175,59 @@ pub struct CTaskWorm {
 const _: () = assert!(core::mem::size_of::<CTaskWorm>() == 0x3FC);
 
 impl CTaskWorm {
-    /// Returns the worm's current state code (lives at offset +0x44, inside the
-    /// CGameTask base's `_unknown_40` padding region).
+    /// Returns the worm's current state code (lives at offset +0x44, inside
+    /// `base.subclass_data`).
     ///
     /// Known states: `0x65`=idle, `0x67`=active turn, `0x7F`=drowning,
     /// `0x80`=hurt, `0x81`/`0x86`=dead, `0x87`=dead variant, `0x8B`=unknown.
     pub fn state(&self) -> u32 {
-        // SAFETY: offset 0x44 is within CGameTask._unknown_40 (0x40..0x84).
         unsafe { *((self as *const CTaskWorm as *const u8).add(0x44) as *const u32) }
     }
 
+    // ── Weapon fire state accessors (offsets +0x30..+0x3C in subclass_data) ──
+
+    /// Weapon fire type (1=projectile, 2=rope, 3=grenade, 4=special).
+    /// Offset +0x30 in CGameTask.subclass_data.
+    pub fn weapon_fire_type(&self) -> i32 {
+        unsafe { *(self.base.subclass_data.as_ptr().add(0) as *const i32) }
+    }
+
+    /// Weapon fire subtype for types 3 and 4. Offset +0x34.
+    pub fn weapon_fire_subtype_34(&self) -> i32 {
+        unsafe { *(self.base.subclass_data.as_ptr().add(4) as *const i32) }
+    }
+
+    /// Weapon fire subtype for types 1 and 2. Offset +0x38.
+    pub fn weapon_fire_subtype_38(&self) -> i32 {
+        unsafe { *(self.base.subclass_data.as_ptr().add(8) as *const i32) }
+    }
+
+    /// Weapon fire completion flag. Offset +0x3C.
+    /// Set to 0 before dispatch, 1 after.
+    pub fn weapon_fire_complete(&self) -> i32 {
+        unsafe { *(self.base.subclass_data.as_ptr().add(12) as *const i32) }
+    }
+
+    /// Mutable pointer to weapon_fire_complete for setting the flag.
+    pub fn weapon_fire_complete_mut(&mut self) -> &mut i32 {
+        unsafe { &mut *(self.base.subclass_data.as_mut_ptr().add(12) as *mut i32) }
+    }
+
+    /// Address of weapon_fire_complete field (passed as params base to fire handlers).
+    pub fn weapon_params_ptr(&self) -> u32 {
+        self as *const _ as u32 + 0x3C
+    }
+
+    /// Address of weapon_fire_subtype_34 field (params for GrenadeMortar).
+    pub fn weapon_params_34_ptr(&self) -> u32 {
+        self as *const _ as u32 + 0x34
+    }
+
+    /// Address of weapon_fire_subtype_38 field (params for type-4 specials).
+    pub fn weapon_params_38_ptr(&self) -> u32 {
+        self as *const _ as u32 + 0x38
+    }
+
     /// Returns a reference to the vtable.
     ///
     /// # Safety

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

@@ -179,28 +179,38 @@ unsafe extern "C" fn trampoline_fire_weapon() {
 }
 
 /// Rust implementation of FireWeapon dispatch.
-unsafe extern "cdecl" fn fire_weapon_impl(weapon_ctx: u32, local_struct: u32, worm: u32) {
-    let ctx = weapon_ctx as *const u8;
+/// EAX = worm self-pointer (== stack param), ECX = local_struct from WeaponRelease.
+unsafe extern "cdecl" fn fire_weapon_impl(worm_eax: u32, local_struct: u32, worm: u32) {
+    use openwa_core::rebase::rb;
+
+    // EAX (worm_eax) = *(CTaskWorm+0x36C), stack param (worm) = CTaskWorm*.
+    // Check if they're actually the same — they might not be!
+    if worm_eax != worm {
+        let _ = log_line(&format!(
+            "[Weapon] WARNING: EAX={:#x} != worm={:#x} (delta={})",
+            worm_eax, worm, worm_eax.wrapping_sub(worm) as i32
+        ));
+    }
+
+    // Use worm_eax (original EAX) for field reads — this is what the original code uses
+    let ctx = worm_eax as *const u8;
     let weapon_type = *(ctx.add(0x30) as *const i32);
     let subtype_34 = *(ctx.add(0x34) as *const i32);
     let subtype_38 = *(ctx.add(0x38) as *const i32);
-    let params = weapon_ctx.wrapping_add(0x3C);
-    let worm_ptr = worm as *mut u8;
+    let params = worm_eax.wrapping_add(0x3C);
 
     // Log weapon fire
-    let weapon_id = *(worm_ptr.add(0x170) as *const u32);
+    let weapon_id = *((worm as *const u8).add(0x170) as *const u32);
     let weapon_name = Weapon::try_from(weapon_id)
-        .map(|w| format!("{:?}", w))
+        .map(|wp| format!("{:?}", wp))
         .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
     ));
 
-    // worm+0x3C = completion flag
-    *(worm_ptr.add(0x3C) as *mut i32) = 0;
-
-    use openwa_core::rebase::rb;
+    // Clear completion flag before dispatch
+    core::ptr::write_volatile((worm + 0x3C) as *mut i32, 0);
 
     match weapon_type {
         1 => match subtype_38 {
@@ -216,18 +226,13 @@ unsafe extern "cdecl" fn fire_weapon_impl(weapon_ctx: u32, local_struct: u32, wo
             3 => call_fire_stdcall3(worm, params, local_struct, rb(0x51E240)),      // RopeType3
             _ => {}
         },
-        3 => {
-            let params_34 = weapon_ctx.wrapping_add(0x34);
-            call_fire_stdcall3(worm, params_34, local_struct, rb(0x51E2C0));        // GrenadeMortar
-        }
-        4 => {
-            let params_38 = weapon_ctx.wrapping_add(0x38);
-            fire_weapon_special(subtype_34, params_38, worm, local_struct);
-        }
+        3 => call_fire_stdcall3(worm, worm_eax.wrapping_add(0x34), local_struct, rb(0x51E2C0)),
+        4 => fire_weapon_special(subtype_34, worm_eax.wrapping_add(0x38), worm, local_struct),
         _ => {}
     }
 
-    *(worm_ptr.add(0x3C) as *mut i32) = 1;
+    // Set completion flag after dispatch
+    core::ptr::write_volatile((worm + 0x3C) as *mut i32, 1);
 }
 
 // ── Sub-function bridges ────────────────────────────────────

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

@@ -1529,7 +1529,7 @@ unsafe fn dump_missile_raw(ptr: u32) {
     let base = ptr as *const u32;
     let sections: &[(usize, usize, &str)] = &[
         (0x000, 0x030, "CTask base"),
-        (0x030, 0x084, "CGameTask _unknown_30"),
+        (0x030, 0x084, "CGameTask subclass_data"),
         (0x084, 0x098, "CGameTask pos/speed (0x84–0x97)"),
         (0x098, 0x0FC, "CGameTask _unknown_98"),
         (0x0FC, 0x130, "CTaskMissile 0xFC–0x12F"),