feat: port Surrender and Mail/Mine/Mole weapon handlers to pure Rust

Port two FireWeapon sub-handlers from WA bridge calls to pure Rust:
- Surrender (0x51E600): SharedData lookup + HandleMessage(0x29) + WormEntry counter
- Mail/Mine/Mole (0x51E670): version-conditional vtable call + HandleMessage(0x28) + counter

Fix replay loader V2 scheme bug: our code was clearing super weapon data
(memset 0x4C) for both V1 and V2 schemes when header < 0, but the original
WA only clears for V1. V2 schemes already contain valid super weapon data.

Other changes:
- Name WormEntry fields: effect_counter_04_Maybe (+0x04), turn_action_counter_Maybe (+0x08)
- Add TeamArenaRef::team_worm_mut() for mutable worm entry access
- Add mail_mine_mole replay test (Mail Strike, Mine Strike, Mole Squadron, Surrender)

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

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

@@ -1728,8 +1728,11 @@ pub struct WormEntry {
     /// Values: 0x65=idle, 0x67=active/selected, 0x68=active variant.
     /// Special states {0x80..0x85, 0x89} = dying/drowning/special animation.
     pub state: u32,
-    /// 0x04-0x0B: Unknown
-    pub _unknown_04: [u8; 8],
+    /// 0x04: Unknown counter. Incremented by Freeze (+10).
+    pub effect_counter_04_Maybe: i32,
+    /// 0x08: Turn action counter. Incremented by weapon handlers:
+    /// Surrender (+14), Mail/Mine/Mole (+7), Freeze (+3).
+    pub turn_action_counter_Maybe: i32,
     /// 0x0C: Active/alive flag (1 for alive worms in game, 0 otherwise).
     pub active_flag: i32,
     /// 0x10-0x57: Unknown
@@ -2051,6 +2054,16 @@ impl TeamArenaRef {
         &*(ptr as *const WormEntry)
     }
 
+    /// Get a mutable reference to a specific worm entry.
+    pub unsafe fn team_worm_mut(&self, team_idx: usize, worm_num: usize) -> &mut WormEntry {
+        let ptr = self
+            .base
+            .add(team_idx * 0x51C)
+            .add(worm_num * 0x9C)
+            .sub(0x598);
+        &mut *(ptr as *mut WormEntry)
+    }
+
     /// Get a team's block and its header in one call.
     ///
     /// Returns `(block[team_idx], &block[team_idx+1].header.team)`.

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

@@ -344,13 +344,21 @@ unsafe fn parse_and_write_v2plus(
         let scheme_slice = s.advance_raw(scheme_data_size)?;
         ptr::copy_nonoverlapping(scheme_slice.as_ptr(), rb(va::G_SCHEME_DATA) as *mut u8, scheme_data_size);
 
-        // If scheme_header < 0 (signed) and v1/v2: clear + defaults
-        if scheme_version <= 2 && (*(rb(va::G_SCHEME_HEADER) as *const i8)) < 0 {
-            ptr::write_bytes(rb(va::G_SCHEME_OPTIONS) as *mut u8, 0, 0x4C);
-            ptr::copy_nonoverlapping(
-                rb(va::SCHEME_V3_DEFAULTS) as *const u8,
-                rb(va::G_SCHEME_V3_DATA) as *mut u8, 0x6E,
-            );
+        let header_val = *(rb(va::G_SCHEME_HEADER) as *const i8);
+
+        // If scheme_header < 0 (signed): apply defaults.
+        // V1: clear super weapons (0x4C bytes) + copy V3 defaults.
+        // V2: copy V3 defaults ONLY (super weapon data is already in the payload).
+        if header_val < 0 {
+            if scheme_version == 1 {
+                ptr::write_bytes(rb(va::G_SCHEME_OPTIONS) as *mut u8, 0, 0x4C);
+            }
+            if scheme_version <= 2 {
+                ptr::copy_nonoverlapping(
+                    rb(va::SCHEME_V3_DEFAULTS) as *const u8,
+                    rb(va::G_SCHEME_V3_DATA) as *mut u8, 0x6E,
+                );
+            }
         }
 
         // Validate extended options for v3

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

@@ -369,7 +369,7 @@ unsafe fn fire_weapon_special(
         10 => call_fire_usercall(w, w, rb(0x51E710)),                                    // Air Strike (EAX=worm)
         11 => fire_worm_vtable_0xe(w, 0x71),                                            // Scales of Justice
         13 => fire_send_team_message(worm, 0x2B),                                          // Napalm Strike
-        14 => call_fire_usercall(w, w, rb(0x51E670)),                                    // Mail/Mine/Mole (EAX=worm)
+        14 => fire_mail_mine_mole(worm),                                                   // Mail/Mine/Mole (pure Rust)
         16 => {
             // Teleport: MOV EAX,[ESI+0x44] (worm state) before check
             let worm_state = (*worm).state();
@@ -383,7 +383,7 @@ unsafe fn fire_weapon_special(
         17 => call_fire_usercall(w, w, rb(0x51E920)),                                    // Freeze (EAX=worm)
         18 => fire_worm_vtable_0xe(w, 0x72),                                            // Suicide Bomber
         19 => fire_skip_go(worm, entry),                                                 // Skip Go (pure Rust)
-        20 => call_fire_usercall(w, w, rb(0x51E600)),                                    // Surrender (EAX=worm)
+        20 => fire_surrender(worm),                                                        // Surrender (pure Rust)
         21 => fire_select_worm(worm),                                                     // Select Worm (pure Rust)
         22 => call_fire_usercall(e, w, rb(0x51EC30)),                                    // Jet Pack (EAX=entry)
         23 => fire_worm_vtable_0xe(w, 0x78),                                            // Magic Bullet
@@ -479,6 +479,61 @@ unsafe fn fire_skip_go(worm: *const CTaskWorm, entry: *const WeaponEntry) {
     }
 }
 
+/// Surrender (subtype 20) — pure Rust replacement for 0x51E600.
+///
+/// Sends message 0x29 to CTaskTeam with buf = [team_index], then increments
+/// WormEntry.turn_action_counter_Maybe by 14 (0x0E).
+unsafe fn fire_surrender(worm: *mut CTaskWorm) {
+    use openwa_core::engine::ddgame::TeamArenaRef;
+    use openwa_core::engine::DDGame;
+
+    fire_send_team_message(worm, 0x29);
+
+    let ddgame = (*worm).base.base.ddgame;
+    let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
+    let team_index = (*worm).team_index as usize;
+    let worm_index = (*worm).worm_index as usize;
+    let entry = arena.team_worm_mut(team_index, worm_index);
+    entry.turn_action_counter_Maybe += 14;
+}
+
+/// Mail/Mine/Mole (subtype 14) — pure Rust replacement for 0x51E670.
+///
+/// Conditionally calls worm->vtable[0xE](0x65) based on game version and worm state,
+/// then sends message 0x28 to CTaskTeam, then increments
+/// WormEntry.turn_action_counter_Maybe by 7.
+///
+/// Version check logic (from disassembly at 0x51E670):
+/// - version < 2: call vtable[0xE](0x65)
+/// - 2 <= version < 5: skip vtable call
+/// - version >= 5 && worm state == 0x7D: call vtable
+/// - version >= 5 && worm state == 0x78 && version < 8: call vtable
+/// - otherwise: skip
+unsafe fn fire_mail_mine_mole(worm: *mut CTaskWorm) {
+    use openwa_core::engine::ddgame::TeamArenaRef;
+    use openwa_core::engine::DDGame;
+
+    let ddgame = (*worm).base.base.ddgame as *mut DDGame;
+    let version = *((ddgame as *const u8).add(0x7E40));
+    let worm_state = (*worm).state();
+
+    let should_call_vtable = version < 2
+        || (version >= 5
+            && (worm_state == 0x7D || (worm_state == 0x78 && version < 8)));
+
+    if should_call_vtable {
+        fire_worm_vtable_0xe(worm as u32, 0x65);
+    }
+
+    fire_send_team_message(worm, 0x28);
+
+    let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
+    let team_index = (*worm).team_index as usize;
+    let worm_index = (*worm).worm_index as usize;
+    let entry = arena.team_worm_mut(team_index, worm_index);
+    entry.turn_action_counter_Maybe += 7;
+}
+
 // ── Naked asm bridges ───────────────────────────────────────
 
 /// Bridge: usercall(EAX=eax_val, ESI=worm, EDI=worm), plain RET.

testdata/replays/mail_mine_mole.WAgame

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c81a4b368910b7403aa0386409b27cea530e8d105b9eee0edf155c3f2d55e5c
+size 12078

testdata/replays/mail_mine_mole_expected.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3adc4d59932df7aef98b2bf022f771b5313dfa7d492665451bce0573b168cdc0
+size 1298