feat: port remaining 5 team/weapon accessor hooks (32 total)

Add SubtractAmmo, CountAliveWorms, CheckTeamWormState0x64,
CheckAnyWormState0x8b, and SetActiveWorm_Maybe replacements.
Extend TeamWeaponState with active_worm_count, last_active_team,
and last_active_alliance fields. Rename SetTeamAliveFlag to
SetActiveWorm_Maybe based on runtime behavior analysis.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CLAUDE.md

@@ -46,6 +46,8 @@ WormKit auto-loads any `wk*.dll` from the game directory. Logs appear in the gam
 
 Use the `/replay-test` skill to automatically build, deploy, launch WA.exe with a replay file, capture validation logs, and present results. This is the fastest way to validate struct layouts, hooks, and game state against live WA.exe.
 
+**Use replay testing to validate assumptions and test theories!** You don't have to figure out everything from disassembly and static analysis. Make a hypothesis, implement it in the DLL, then use replay testing to see if it holds up against the real game. This iterative approach is much faster than trying to get everything right on the first try.
+
 ```bash
 # Manual invocation (skill runs this automatically):
 powershell -ExecutionPolicy Bypass -File replay-test.ps1
@@ -116,6 +118,9 @@ For `__usercall` functions, use a naked trampoline to capture register params be
 A Ghidra MCP bridge is configured in `.mcp.json`. When using Ghidra tools:
 - **Prefer batch tools** (`batch_create_labels`, `batch_rename_function_components`) — single-item tools have address parsing bugs.
 - WA.exe is loaded at image base 0x400000 in Ghidra.
+- When you encounter unnamed functions, globals or structs, name them in Ghidra if you know their purpose. Even a guess is helpful for future reference, but add `_Maybe` suffix if uncertain.
+- Remove `_Maybe` suffix when you confirm the purpose.
+- When you learn more about a function or address, update both the Ghidra database (rename function / label and update signature) and the corresponding Rust code.
 
 ## Third-Party RE Sources
 
@@ -124,8 +129,6 @@ A Ghidra MCP bridge is configured in `.mcp.json`. When using Ghidra tools:
 
 ## Design Conventions
 
-- `Ptr32 = u32` for pointer fields (compiles on 64-bit host, correct sizes on 32-bit target)
-- `#[repr(u32)]` enums with `TryFrom<u32>` for safe conversion from game memory
 - Unknown struct fields as `_unknown_XX` padding arrays
 - Fixed-point: `Fixed(i32)` newtype, 16.16 format (0x10000 = 1.0)
 - Naked asm uses `naked_asm!` (Rust 1.79+ syntax), not `asm!`

crates/openwa-types/src/address.rs

@@ -150,6 +150,17 @@ pub mod va {
     /// Despite the comparison to 100, reads worms[].state NOT .health.
     /// usercall(EAX=base) → EAX=bool, plain RET.
     pub const CHECK_WORM_STATE_0X64: u32 = 0x0052_28D0;
+    /// Per-team version of CheckWormState0x64. Returns 1 if any worm on the
+    /// specified team has state==0x64. 1 xref.
+    /// usercall(EAX=team_idx, ECX=base) → EAX=bool, plain RET.
+    pub const CHECK_TEAM_WORM_STATE_0X64: u32 = 0x0052_2930;
+    /// Scans all teams for any worm with state 0x8b. 1 xref.
+    /// usercall(EAX=base) → EAX=bool, plain RET.
+    pub const CHECK_ANY_WORM_STATE_0X8B: u32 = 0x0052_2970;
+    /// Sets the active worm for a team. flag=0 deactivates, flag=N sets worm N active.
+    /// Called on turn transitions and worm selection (Tab key).
+    /// usercall(EAX=base, EDX=team_idx, ESI=worm_index) → void, plain RET. 3 xrefs.
+    pub const SET_ACTIVE_WORM_MAYBE: u32 = 0x0052_2500;
 
     // === Graphics / rendering ===
 

crates/openwa-types/src/ddgame.rs

@@ -324,21 +324,25 @@ pub struct TeamWeaponState {
     /// 0x2C28: Game phase counter (>=484 = sudden death, >=-2 = normal game)
     pub game_phase: i32,
 
-    // === Alliance tracking (set by CountTeamsByAlliance, 0x522030) ===
+    // === Alliance tracking (set by CountTeamsByAlliance + SetActiveWorm_Maybe) ===
 
     /// 0x2C2C: Current alliance being evaluated
     pub current_alliance: i32,
-    /// 0x2C30: Unknown padding
-    pub _pad_2c30: [u8; 4],
-    /// 0x2C34: Count of teams alive with valid alliance (>=0)
+    /// 0x2C30: Count of teams with an active worm (set by SetActiveWorm_Maybe)
+    pub active_worm_count: i32,
+    /// 0x2C34: Count of active teams with valid alliance (>=0)
     pub active_team_count: i32,
     /// 0x2C38: Count of teams matching current_alliance
     pub same_alliance_count: i32,
     /// 0x2C3C: Count of teams not matching current_alliance
     pub enemy_team_count: i32,
+    /// 0x2C40: Last team index set active (written by SetActiveWorm_Maybe)
+    pub last_active_team: i32,
+    /// 0x2C44: Alliance of last activated team (written by SetActiveWorm_Maybe)
+    pub last_active_alliance: i32,
 }
 
-const _: () = assert!(core::mem::size_of::<TeamWeaponState>() == 0x2C40);
+const _: () = assert!(core::mem::size_of::<TeamWeaponState>() == 0x2C48);
 
 /// Worm state constants and helpers.
 pub mod worm {

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

@@ -6,6 +6,9 @@
 //! - IsWormInSpecialState (0x5226B0): check worm state flag
 //! - GetWormPosition (0x522700): read worm X,Y coordinates
 //! - CheckWormState0x64 (0x5228D0): check if any worm has state 0x64
+//! - CheckTeamWormState0x64 (0x522930): per-team version of above
+//! - CheckAnyWormState0x8b (0x522970): scan all teams for state 0x8b
+//! - SetActiveWorm_Maybe (0x522500): update team active state and counters
 
 use openwa_types::address::va;
 use openwa_types::ddgame::{self, offsets, FullTeamBlock, TeamWeaponState};
@@ -150,6 +153,125 @@ unsafe extern "cdecl" fn check_worm_state_0x64_impl(base: u32) -> u32 {
 usercall_trampoline!(fn trampoline_check_worm_state_0x64; impl_fn = check_worm_state_0x64_impl;
     reg = eax);
 
+// ============================================================
+// CheckTeamWormState0x64 replacement (0x522930)
+// ============================================================
+// __usercall: EAX = base, EDX = team_idx
+// plain RET, returns EAX = bool (1 if any worm on team has state 0x64)
+//
+// Per-team version of CheckWormState0x64. 1 xref (FUN_00556ad0).
+
+unsafe extern "cdecl" fn check_team_worm_state_0x64_impl(base: u32, team_idx: u32) -> u32 {
+    let blocks = (base as *const u8).sub(offsets::TWS_TO_BLOCKS) as *const FullTeamBlock;
+    let block = &*blocks.add(team_idx as usize);
+    let sentinel = &(*blocks.add(team_idx as usize + 1)).worms[0];
+
+    if sentinel.sentinel_eliminated() != 0 {
+        return 0;
+    }
+
+    let worm_count = sentinel.sentinel_worm_count();
+    for w in 1..=worm_count as usize {
+        if block.worms[w].state == 0x64 {
+            return 1;
+        }
+    }
+    0
+}
+
+usercall_trampoline!(fn trampoline_check_team_worm_state_0x64; impl_fn = check_team_worm_state_0x64_impl;
+    regs = [eax, edx]);
+
+// ============================================================
+// CheckAnyWormState0x8b replacement (0x522970)
+// ============================================================
+// __usercall: EAX = base
+// plain RET, returns EAX = bool (1 if any worm on any team has state 0x8b)
+//
+// Scans all teams. 1 xref (FUN_00557310).
+
+unsafe extern "cdecl" fn check_any_worm_state_0x8b_impl(base: u32) -> u32 {
+    let state = &*(base as *const TeamWeaponState);
+    let blocks = (base as *const u8).sub(offsets::TWS_TO_BLOCKS) as *const FullTeamBlock;
+
+    for i in 1..=state.team_count as usize {
+        let sentinel = &(*blocks.add(i + 1)).worms[0];
+        if sentinel.sentinel_eliminated() != 0 {
+            continue;
+        }
+        let worm_count = sentinel.sentinel_worm_count();
+        let worm_block = &*blocks.add(i);
+        for w in 1..=worm_count as usize {
+            if worm_block.worms[w].state == 0x8b {
+                return 1;
+            }
+        }
+    }
+    0
+}
+
+usercall_trampoline!(fn trampoline_check_any_worm_state_0x8b; impl_fn = check_any_worm_state_0x8b_impl;
+    reg = eax);
+
+// ============================================================
+// SetActiveWorm_Maybe replacement (0x522500)
+// ============================================================
+// __usercall: EAX = base, EDX = team_idx (1-indexed), ESI = worm_index
+// plain RET (4 RET sites in original)
+//
+// Sets the active worm for a team. worm_index=0 deactivates, worm_index=N
+// sets worm N as active. Called on turn transitions and worm selection (Tab).
+// Updates active counters and records last_active_team/alliance. 3 xrefs.
+
+unsafe extern "cdecl" fn set_active_worm_impl(base: u32, team_idx: u32, worm_index: i32) {
+    let state = &mut *(base as *mut TeamWeaponState);
+    let base_ptr = base as *mut u8;
+
+    // Access team_data fields: alliance at (team_idx * 0x51C - 0xC),
+    // alive_flag at (team_idx * 0x51C - 0x8) — matches team_data::BASE_OFFSET pattern
+    let team_offset = team_idx as usize * 0x51C;
+    let alliance_ptr = base_ptr.add(team_offset).sub(0xC) as *const i32;
+    let alive_ptr = base_ptr.add(team_offset).sub(0x8) as *mut i32;
+
+    if worm_index == 0 {
+        // Deactivate team
+        if *alive_ptr != 0 {
+            state.active_worm_count -= 1;
+            let alliance = *alliance_ptr;
+            if alliance >= 0 {
+                state.active_team_count -= 1;
+                if alliance == state.current_alliance {
+                    state.same_alliance_count -= 1;
+                } else {
+                    state.enemy_team_count -= 1;
+                }
+            }
+            *alive_ptr = 0;
+        }
+    } else {
+        // Activate team — only update counters if not already active
+        if *alive_ptr == 0 {
+            state.active_worm_count += 1;
+            state.last_active_team = team_idx as i32;
+            let alliance = *alliance_ptr;
+            state.last_active_alliance = alliance;
+            if alliance >= 0 {
+                state.active_team_count += 1;
+                if alliance == state.current_alliance {
+                    state.same_alliance_count += 1;
+                } else {
+                    state.enemy_team_count += 1;
+                }
+            }
+        }
+        // Always write worm_index (original writes ESI unconditionally)
+        *alive_ptr = worm_index;
+    }
+}
+
+usercall_trampoline!(fn trampoline_set_active_worm; impl_fn = set_active_worm_impl;
+    regs = [eax, edx, esi]);
+
 // ============================================================
 // Hook installation
 // ============================================================
@@ -185,6 +307,24 @@ pub fn install() -> Result<(), String> {
             va::CHECK_WORM_STATE_0X64,
             trampoline_check_worm_state_0x64 as *const (),
         )?;
+
+        let _ = hook::install(
+            "CheckTeamWormState0x64",
+            va::CHECK_TEAM_WORM_STATE_0X64,
+            trampoline_check_team_worm_state_0x64 as *const (),
+        )?;
+
+        let _ = hook::install(
+            "CheckAnyWormState0x8b",
+            va::CHECK_ANY_WORM_STATE_0X8B,
+            trampoline_check_any_worm_state_0x8b as *const (),
+        )?;
+
+        let _ = hook::install(
+            "SetActiveWorm_Maybe",
+            va::SET_ACTIVE_WORM_MAYBE,
+            trampoline_set_active_worm as *const (),
+        )?;
     }
 
     Ok(())

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

@@ -3,6 +3,8 @@
 //! Replaces WA.exe functions that manage weapon ammo in the TeamWeaponState area (DDGame + 0x4628):
 //! - GetAmmo (0x5225E0): query ammo count with delay/phase checks
 //! - AddAmmo (0x522640): add ammo to a weapon slot
+//! - SubtractAmmo (0x522680): decrement ammo count
+//! - CountAliveWorms (0x5225A0): check if >1 worm alive on team
 
 use openwa_types::address::va;
 use openwa_types::ddgame::{self, offsets, FullTeamBlock, TeamWeaponState};
@@ -32,6 +34,24 @@ unsafe extern "cdecl" fn add_ammo_impl(team_index: u32, amount: i32, base: u32,
 usercall_trampoline!(fn trampoline_add_ammo; impl_fn = add_ammo_impl;
     regs = [eax, edx]; stack_params = 2; ret_bytes = "0x8");
 
+// ============================================================
+// SubtractAmmo replacement (0x522680)
+// ============================================================
+// __usercall: EAX = team_index, ECX = team_info_base, [ESP+4] = weapon_id
+// RET 0x4
+
+unsafe extern "cdecl" fn subtract_ammo_impl(team_index: u32, base: u32, weapon_id: u32) {
+    let state = &mut *(base as *mut TeamWeaponState);
+    let idx = state.ammo_index(team_index as usize, weapon_id);
+    let ammo = state.get_ammo(idx);
+    if ammo > 0 {
+        *state.ammo_mut(idx) = ammo - 1;
+    }
+}
+
+usercall_trampoline!(fn trampoline_subtract_ammo; impl_fn = subtract_ammo_impl;
+    regs = [eax, ecx]; stack_params = 1; ret_bytes = "0x4");
+
 // ============================================================
 // GetAmmo replacement (0x5225E0)
 // ============================================================
@@ -56,7 +76,8 @@ unsafe extern "cdecl" fn get_ammo_impl(team_index: u32, base: u32, weapon_id: u3
 
     // SelectWorm (0x3B) requires >1 alive worm on the team
     if state.game_phase >= ddgame::GAME_PHASE_NORMAL_MIN && weapon_id == Weapon::SelectWorm as u32 {
-        if !count_alive_worms(state, team_index as usize) {
+        let base = state as *const TeamWeaponState as u32;
+        if count_alive_worms_impl(team_index, base) == 0 {
             return 0;
         }
     }
@@ -64,12 +85,19 @@ unsafe extern "cdecl" fn get_ammo_impl(team_index: u32, base: u32, weapon_id: u3
     state.get_ammo(idx) as u32
 }
 
-/// Returns true if more than 1 worm is alive on the team (health > 0).
-unsafe fn count_alive_worms(state: &TeamWeaponState, team_index: usize) -> bool {
-    let base = state as *const TeamWeaponState as *const u8;
-    let blocks = base.sub(offsets::TWS_TO_BLOCKS) as *const FullTeamBlock;
-    let block = &*blocks.add(team_index);
-    let sentinel = &(*blocks.add(team_index + 1)).worms[0];
+usercall_trampoline!(fn trampoline_get_ammo; impl_fn = get_ammo_impl;
+    regs = [eax, esi, edx]);
+
+// ============================================================
+// CountAliveWorms replacement (0x5225A0)
+// ============================================================
+// __usercall: EAX = team_index, ECX = base
+// plain RET, returns EAX = bool (1 if >1 worm alive on team)
+
+unsafe extern "cdecl" fn count_alive_worms_impl(team_index: u32, base: u32) -> u32 {
+    let blocks = (base as *const u8).sub(offsets::TWS_TO_BLOCKS) as *const FullTeamBlock;
+    let block = &*blocks.add(team_index as usize);
+    let sentinel = &(*blocks.add(team_index as usize + 1)).worms[0];
     let worm_count = sentinel.sentinel_worm_count();
     let mut alive = 0i32;
     for w in 1..=worm_count as usize {
@@ -77,11 +105,11 @@ unsafe fn count_alive_worms(state: &TeamWeaponState, team_index: usize) -> bool
             alive += 1;
         }
     }
-    alive > 1
+    if alive > 1 { 1 } else { 0 }
 }
 
-usercall_trampoline!(fn trampoline_get_ammo; impl_fn = get_ammo_impl;
-    regs = [eax, esi, edx]);
+usercall_trampoline!(fn trampoline_count_alive_worms; impl_fn = count_alive_worms_impl;
+    regs = [eax, ecx]);
 
 // ============================================================
 // Hook installation
@@ -100,6 +128,18 @@ pub fn install() -> Result<(), String> {
             va::GET_AMMO,
             trampoline_get_ammo as *const (),
         )?;
+
+        let _ = hook::install(
+            "SubtractAmmo",
+            va::SUBTRACT_AMMO,
+            trampoline_subtract_ammo as *const (),
+        )?;
+
+        let _ = hook::install(
+            "CountAliveWorms",
+            va::COUNT_ALIVE_WORMS,
+            trampoline_count_alive_worms as *const (),
+        )?;
     }
 
     Ok(())