style: cargo fmt across all crates

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

crates/openwa-core/src/address.rs

@@ -29,46 +29,41 @@ pub mod va {
 
     // Re-exported from task modules
     pub use crate::task::base::{
-        CTASK_VTABLE, CTASK_CONSTRUCTOR, CTASK_VT0_INIT, CTASK_VT1_FREE,
-        CTASK_VT2_HANDLE_MESSAGE, CTASK_VT3, CTASK_VT5, CTASK_VT6,
-        CTASK_VT7_PROCESS_FRAME,
-        CTASK_LAND_VTABLE, CTASK_LAND_CTOR,
-        CTASK_DIRT_VTABLE, CTASK_DIRT_CTOR,
-        CTASK_SPRITE_ANIM_VTABLE, CTASK_SPRITE_ANIM_CTOR,
-        CTASK_CPU_VTABLE, CTASK_CPU_CTOR,
-        CTASK_SEA_BUBBLE_VTABLE, CTASK_SEABUBBLE_CTOR,
-        CTASK_AIRSTRIKE_CTOR, CTASK_ARROW_CTOR, CTASK_CANISTER_CTOR,
-        CTASK_CROSS_CTOR, CTASK_FIREBALL_CTOR, CTASK_FLAME_CTOR,
-        CTASK_GAS_CTOR, CTASK_OLDWORM_CTOR, CTASK_SCOREBUBBLE_CTOR,
-        CTASK_SMOKE_CTOR,
+        CTASK_AIRSTRIKE_CTOR, CTASK_ARROW_CTOR, CTASK_CANISTER_CTOR, CTASK_CONSTRUCTOR,
+        CTASK_CPU_CTOR, CTASK_CPU_VTABLE, CTASK_CROSS_CTOR, CTASK_DIRT_CTOR, CTASK_DIRT_VTABLE,
+        CTASK_FIREBALL_CTOR, CTASK_FLAME_CTOR, CTASK_GAS_CTOR, CTASK_LAND_CTOR, CTASK_LAND_VTABLE,
+        CTASK_OLDWORM_CTOR, CTASK_SCOREBUBBLE_CTOR, CTASK_SEABUBBLE_CTOR, CTASK_SEA_BUBBLE_VTABLE,
+        CTASK_SMOKE_CTOR, CTASK_SPRITE_ANIM_CTOR, CTASK_SPRITE_ANIM_VTABLE, CTASK_VT0_INIT,
+        CTASK_VT1_FREE, CTASK_VT2_HANDLE_MESSAGE, CTASK_VT3, CTASK_VT5, CTASK_VT6,
+        CTASK_VT7_PROCESS_FRAME, CTASK_VTABLE,
     };
+    pub use crate::task::cloud::{CTASK_CLOUD_CTOR, CTASK_CLOUD_VTABLE};
+    pub use crate::task::filter::{CTASK_FILTER_CTOR, CTASK_FILTER_VTABLE};
+    pub use crate::task::fire::{CTASK_FIRE_CTOR, CTASK_FIRE_VTABLE};
     pub use crate::task::game_task::{
-        CGAMETASK_VTABLE, CGAMETASK_SOUND_EMITTER_VT, CGAMETASK_CONSTRUCTOR,
-        CGAMETASK_VT0, CGAMETASK_VT1_FREE, CGAMETASK_VT2_HANDLE_MESSAGE,
+        CGAMETASK_CONSTRUCTOR, CGAMETASK_SOUND_EMITTER_VT, CGAMETASK_VT0, CGAMETASK_VT1_FREE,
+        CGAMETASK_VT2_HANDLE_MESSAGE, CGAMETASK_VTABLE,
     };
-    pub use crate::task::worm::{CTASK_WORM_VTABLE, CTASK_WORM_CONSTRUCTOR};
-    pub use crate::task::turn_game::{
-        CTASK_TURN_GAME_VTABLE, CTASK_TURNGAME_CTOR,
-        TURNGAME_HANDLE_MESSAGE, TURNGAME_HURRY_HANDLER, TURNGAME_AUTO_SELECT_TEAMS,
-    };
-    pub use crate::task::team::{CTASK_TEAM_VTABLE, CTASK_TEAM_CTOR};
-    pub use crate::task::missile::{CTASK_MISSILE_VTABLE, CTASK_MISSILE_CTOR};
     pub use crate::task::mine_oil_drum::{
-        CTASK_MINE_VTABLE, CTASK_MINE_CTOR, CTASK_OILDRUM_VTABLE, CTASK_OILDRUM_CTOR,
+        CTASK_MINE_CTOR, CTASK_MINE_VTABLE, CTASK_OILDRUM_CTOR, CTASK_OILDRUM_VTABLE,
+    };
+    pub use crate::task::missile::{CTASK_MISSILE_CTOR, CTASK_MISSILE_VTABLE};
+    pub use crate::task::supply_crate::{CTASK_CRATE_CTOR, CTASK_CRATE_VTABLE};
+    pub use crate::task::team::{CTASK_TEAM_CTOR, CTASK_TEAM_VTABLE};
+    pub use crate::task::turn_game::{
+        CTASK_TURNGAME_CTOR, CTASK_TURN_GAME_VTABLE, TURNGAME_AUTO_SELECT_TEAMS,
+        TURNGAME_HANDLE_MESSAGE, TURNGAME_HURRY_HANDLER,
     };
-    pub use crate::task::supply_crate::{CTASK_CRATE_VTABLE, CTASK_CRATE_CTOR};
-    pub use crate::task::cloud::{CTASK_CLOUD_VTABLE, CTASK_CLOUD_CTOR};
-    pub use crate::task::filter::{CTASK_FILTER_VTABLE, CTASK_FILTER_CTOR};
-    pub use crate::task::fire::{CTASK_FIRE_VTABLE, CTASK_FIRE_CTOR};
+    pub use crate::task::worm::{CTASK_WORM_CONSTRUCTOR, CTASK_WORM_VTABLE};
 
     // Re-exported from modules using #[vtable(...)] attribute
-    pub use crate::display::palette::PALETTE_VTABLE;
+    pub use crate::audio::dssound::DS_SOUND_VTABLE;
+    pub use crate::display::base::DISPLAY_BASE_VTABLE;
     pub use crate::display::dd_display::DD_DISPLAY_VTABLE;
-    pub use crate::input::controller::INPUT_CTRL_VTABLE;
+    pub use crate::display::palette::PALETTE_VTABLE;
     pub use crate::frontend::map_view::MAP_VIEW_VTABLE;
+    pub use crate::input::controller::INPUT_CTRL_VTABLE;
     pub use crate::task::game_task::SOUND_EMITTER_VTABLE;
-    pub use crate::display::base::DISPLAY_BASE_VTABLE;
-    pub use crate::audio::dssound::DS_SOUND_VTABLE;
 
     crate::define_addresses! {
         class "DDGameWrapper" {

crates/openwa-core/src/display/dd_display.rs

@@ -31,10 +31,23 @@ pub struct DDDisplayVtable {
     pub set_layer_visibility: fn(this: *mut DDDisplay, layer: i32, value: i32),
     /// load sprite with flag (RET 0x14)
     #[slot(31)]
-    pub load_sprite: fn(this: *mut DDDisplay, layer: u32, id: u32, flag: u32, gfx: *mut u8, name: *const core::ffi::c_char) -> i32,
+    pub load_sprite: fn(
+        this: *mut DDDisplay,
+        layer: u32,
+        id: u32,
+        flag: u32,
+        gfx: *mut u8,
+        name: *const core::ffi::c_char,
+    ) -> i32,
     /// load sprite by layer (RET 0x10)
     #[slot(37)]
-    pub load_sprite_by_layer: fn(this: *mut DDDisplay, layer: u32, id: u32, gfx: *mut u8, name: *const core::ffi::c_char) -> i32,
+    pub load_sprite_by_layer: fn(
+        this: *mut DDDisplay,
+        layer: u32,
+        id: u32,
+        gfx: *mut u8,
+        name: *const core::ffi::c_char,
+    ) -> i32,
 }
 
 // Generate calling wrappers: DDDisplay::set_layer_color(), etc.

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

@@ -1,17 +1,17 @@
-use crate::FieldRegistry;
 use crate::audio::active_sound::ActiveSoundTable;
-use crate::fixed::Fixed;
 use crate::audio::dssound::DSSound;
 use crate::audio::music::Music;
 use crate::audio::speech::SpeechSlotTable;
 use crate::display::dd_display::DDDisplay;
 use crate::display::palette::Palette;
 use crate::engine::game_info::GameInfo;
+use crate::fixed::Fixed;
 use crate::game::weapon::WeaponTable;
 use crate::input::keyboard::DDKeyboard;
 use crate::render::landscape::PCLandscape;
 use crate::render::queue::RenderQueue;
 use crate::render::turn_order::TurnOrderWidget;
+use crate::FieldRegistry;
 
 // Re-export constructor items so existing `engine::ddgame::*` imports keep working.
 pub use super::ddgame_constructor::{
@@ -24,9 +24,9 @@ pub use crate::render::gfx_dir::gfx_dir_load_dir;
 
 // Re-export all team_arena types so existing `engine::ddgame::*` imports keep working.
 pub use crate::engine::team_arena::{
-    CoordEntry, CoordList, CoordListEntry, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH,
-    RenderEntry, SoundQueueEntry, TeamArenaRef, TeamArenaState, TeamBlock, TeamHeader,
-    TeamIndexMap, TeamSlot0, TeamWeaponSlots, WeaponSlots, WormEntry, worm,
+    worm, CoordEntry, CoordList, CoordListEntry, RenderEntry, SoundQueueEntry, TeamArenaRef,
+    TeamArenaState, TeamBlock, TeamHeader, TeamIndexMap, TeamSlot0, TeamWeaponSlots, WeaponSlots,
+    WormEntry, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH,
 };
 
 /// DDGame — the main game engine object.
@@ -483,8 +483,8 @@ impl DDGame {
     /// # Safety
     /// `self.game_info` must be valid.
     pub unsafe fn show_pool_overflow_warning(&mut self) {
-        use crate::rebase::rb;
         use crate::address::va;
+        use crate::rebase::rb;
 
         let game_version = (*self.game_info).game_version;
         if game_version < 0x3C {
@@ -621,36 +621,91 @@ pub mod offsets {
 
 #[cfg(target_arch = "x86")]
 impl crate::snapshot::Snapshot for DDGame {
-    unsafe fn write_snapshot(&self, w: &mut dyn core::fmt::Write, indent: usize) -> core::fmt::Result {
+    unsafe fn write_snapshot(
+        &self,
+        w: &mut dyn core::fmt::Write,
+        indent: usize,
+    ) -> core::fmt::Result {
         use crate::fixed::Fixed;
-        use crate::snapshot::{write_indent, fmt_ptr};
+        use crate::snapshot::{fmt_ptr, write_indent};
         let i = indent;
 
-        write_indent(w, i)?; writeln!(w, "frame_counter = {}", self.frame_counter)?;
-        write_indent(w, i)?; writeln!(w, "game_speed = {}", Fixed(self.game_speed))?;
-        write_indent(w, i)?; writeln!(w, "game_speed_target = {}", Fixed(self.game_speed_target))?;
-        write_indent(w, i)?; writeln!(w, "rng_state = 0x{:08X} 0x{:08X}", self.rng_state_1, self.rng_state_2)?;
-        write_indent(w, i)?; writeln!(w, "camera = ({}, {})", Fixed(self.camera_x), Fixed(self.camera_y))?;
-        write_indent(w, i)?; writeln!(w, "camera_target = ({}, {})", Fixed(self.camera_target_x), Fixed(self.camera_target_y))?;
-        write_indent(w, i)?; writeln!(w, "level_size = {}x{}", self.level_width, self.level_height)?;
-        write_indent(w, i)?; writeln!(w, "level_size_raw = {}x{}", self.level_width_raw, self.level_height_raw)?;
-        write_indent(w, i)?; writeln!(w, "landscape_property = {}", fmt_ptr(self.landscape_property as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "gfx_color_table = {:?}", self.gfx_color_table)?;
-        write_indent(w, i)?; writeln!(w, "fast_forward = req={} active={}", self.fast_forward_request, self.fast_forward_active)?;
-        write_indent(w, i)?; writeln!(w, "keyboard = {}", fmt_ptr(self.keyboard as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "display = {}", fmt_ptr(self.display as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "sound = {}", fmt_ptr(self.sound as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "game_info = {}", fmt_ptr(self.game_info as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "landscape = {}", fmt_ptr(self.landscape as *const u8))?;
-        write_indent(w, i)?; writeln!(w, "task_land = {}", fmt_ptr(self.task_land))?;
+        write_indent(w, i)?;
+        writeln!(w, "frame_counter = {}", self.frame_counter)?;
+        write_indent(w, i)?;
+        writeln!(w, "game_speed = {}", Fixed(self.game_speed))?;
+        write_indent(w, i)?;
+        writeln!(w, "game_speed_target = {}", Fixed(self.game_speed_target))?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "rng_state = 0x{:08X} 0x{:08X}",
+            self.rng_state_1, self.rng_state_2
+        )?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "camera = ({}, {})",
+            Fixed(self.camera_x),
+            Fixed(self.camera_y)
+        )?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "camera_target = ({}, {})",
+            Fixed(self.camera_target_x),
+            Fixed(self.camera_target_y)
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "level_size = {}x{}", self.level_width, self.level_height)?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "level_size_raw = {}x{}",
+            self.level_width_raw, self.level_height_raw
+        )?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "landscape_property = {}",
+            fmt_ptr(self.landscape_property as *const u8)
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "gfx_color_table = {:?}", self.gfx_color_table)?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "fast_forward = req={} active={}",
+            self.fast_forward_request, self.fast_forward_active
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "keyboard = {}", fmt_ptr(self.keyboard as *const u8))?;
+        write_indent(w, i)?;
+        writeln!(w, "display = {}", fmt_ptr(self.display as *const u8))?;
+        write_indent(w, i)?;
+        writeln!(w, "sound = {}", fmt_ptr(self.sound as *const u8))?;
+        write_indent(w, i)?;
+        writeln!(w, "game_info = {}", fmt_ptr(self.game_info as *const u8))?;
+        write_indent(w, i)?;
+        writeln!(w, "landscape = {}", fmt_ptr(self.landscape as *const u8))?;
+        write_indent(w, i)?;
+        writeln!(w, "task_land = {}", fmt_ptr(self.task_land))?;
 
         // TeamArenaState summary
-        write_indent(w, i)?; writeln!(w, "team_arena.team_count = {}", self.team_arena.team_count)?;
-        write_indent(w, i)?; writeln!(w, "team_arena.game_phase = {}", self.team_arena.game_phase)?;
-        write_indent(w, i)?; writeln!(w, "team_arena.game_mode_flag = {}", self.team_arena.game_mode_flag)?;
+        write_indent(w, i)?;
+        writeln!(w, "team_arena.team_count = {}", self.team_arena.team_count)?;
+        write_indent(w, i)?;
+        writeln!(w, "team_arena.game_phase = {}", self.team_arena.game_phase)?;
+        write_indent(w, i)?;
+        writeln!(
+            w,
+            "team_arena.game_mode_flag = {}",
+            self.team_arena.game_mode_flag
+        )?;
 
         // Dump weapon slots (ammo only, skip zeros)
-        write_indent(w, i)?; writeln!(w, "weapon_slots:")?;
+        write_indent(w, i)?;
+        writeln!(w, "weapon_slots:")?;
         for team in 0..6usize {
             let slots = &self.team_arena.weapon_slots.teams[team];
             let mut has_any = false;
@@ -658,7 +713,8 @@ impl crate::snapshot::Snapshot for DDGame {
                 let ammo = slots.ammo[wpn];
                 if ammo != 0 {
                     if !has_any {
-                        write_indent(w, i + 1)?; write!(w, "team[{}] ammo:", team)?;
+                        write_indent(w, i + 1)?;
+                        write!(w, "team[{}] ammo:", team)?;
                         has_any = true;
                     }
                     if ammo == -1 {
@@ -668,10 +724,11 @@ impl crate::snapshot::Snapshot for DDGame {
                     }
                 }
             }
-            if has_any { writeln!(w)?; }
+            if has_any {
+                writeln!(w)?;
+            }
         }
 
         Ok(())
     }
 }
-

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

@@ -52,8 +52,16 @@ pub unsafe fn ddgame_init_fields(ddgame: *mut DDGame) {
     // These offsets are deep in the unknown 0x2E00-0x45EB region and don't
     // have named fields yet — keep as raw offsets for now.
     for &off in &[
-        0x379Cusize, 0x3930, 0x3AC4, 0x3C58, 0x3DEC,
-        0x3F80, 0x4114, 0x42A8, 0x443C, 0x45D0,
+        0x379Cusize,
+        0x3930,
+        0x3AC4,
+        0x3C58,
+        0x3DEC,
+        0x3F80,
+        0x4114,
+        0x42A8,
+        0x443C,
+        0x45D0,
     ] {
         *(base.add(off) as *mut u32) = 0;
     }
@@ -482,13 +490,7 @@ unsafe fn init_graphics_and_resources(
         let disp = (*wrapper).display;
         let gfx_dir = (*wrapper).primary_gfx_dir;
         (*disp).set_layer_color(1, 0xFE);
-        (*disp).load_sprite(
-            1,
-            1,
-            0,
-            gfx_dir,
-            rb(va::STR_CDROM_SPR) as *const c_char,
-        );
+        (*disp).load_sprite(1, 1, 0, gfx_dir, rb(va::STR_CDROM_SPR) as *const c_char);
         (*disp).set_layer_visibility(1, -100);
 
         // Palette slot range init (raw byte offsets into DisplayBase)
@@ -618,9 +620,15 @@ unsafe fn init_graphics_and_resources(
         let palette_ctx = wa_malloc_zeroed(0x900);
         *(palette_ctx as *mut u16) = 1;
         *(palette_ctx.add(2) as *mut u16) = 0xFE;
-        call_usercall_eax(palette_ctx as *mut DDGameWrapper, rb(va::PALETTE_CONTEXT_INIT));
-        gfx_resource =
-            gfx_resource_create(gfx_dir, rb(va::STR_MASKS_IMG) as *const core::ffi::c_char, palette_ctx);
+        call_usercall_eax(
+            palette_ctx as *mut DDGameWrapper,
+            rb(va::PALETTE_CONTEXT_INIT),
+        );
+        gfx_resource = gfx_resource_create(
+            gfx_dir,
+            rb(va::STR_MASKS_IMG) as *const core::ffi::c_char,
+            palette_ctx,
+        );
     }
 
     // ── Dump GfxResource for A/B comparison ──
@@ -771,13 +779,13 @@ unsafe fn init_graphics_and_resources(
                 let region = if !alloc.is_null() {
                     call_sprite_region_ctor(
                         alloc,
-                        (sprite_w / 2) as u32,                   // ECX → this[5] = ECX - p2
-                        (sprite_h - margin_h) as u32,            // EDX → this[4] = EDX - p3
-                        margin_w as u32,                          // p2 (left margin)
-                        margin_h as u32,                          // p3 (top margin)
-                        (sprite_w - margin_w) as u32,             // p4 → this[3] = p4 - p2
-                        (sprite_h / 2) as u32,                    // p5 → this[6] = p5 - p3
-                        sprite as u32,                            // p6 = arrow sprite (NOT landscape gfx_resource)
+                        (sprite_w / 2) as u32, // ECX → this[5] = ECX - p2
+                        (sprite_h - margin_h) as u32, // EDX → this[4] = EDX - p3
+                        margin_w as u32,       // p2 (left margin)
+                        margin_h as u32,       // p3 (top margin)
+                        (sprite_w - margin_w) as u32, // p4 → this[3] = p4 - p2
+                        (sprite_h / 2) as u32, // p5 → this[6] = p5 - p3
+                        sprite as u32,         // p6 = arrow sprite (NOT landscape gfx_resource)
                     )
                 } else {
                     core::ptr::null_mut()
@@ -917,12 +925,7 @@ unsafe fn init_graphics_and_resources(
         // GenerateDebrisParticles (0x546F70) for particle effects, which affects
         // the game RNG (DDGame+0x45EC). The original constructor loads them even
         // in headless mode. Skipping them causes replay desync.
-        (*disp).load_sprite_by_layer(
-            3,
-            0x26D,
-            land_layer,
-            c"back.spr".as_ptr().cast(),
-        );
+        (*disp).load_sprite_by_layer(3, 0x26D, land_layer, c"back.spr".as_ptr().cast());
         // debris.spr must be loaded unconditionally — it's used by
         // GenerateDebrisParticles (0x546F70) for particle effects, which
         // affects the game RNG (DDGame+0x45EC). Skipping it in headless

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

@@ -94,7 +94,6 @@ pub struct GameInfo {
     pub land_dat_path: [u8; 14],
 
     // --- Replay configuration (populated by ReplayLoader) ---
-
     /// 0xDAFA-0xDB07: Unknown
     pub _unknown_dafa: [u8; 0xDB08 - 0xDAFA],
     /// 0xDB08: Invisibility (weapon 0x42) mode flag (u32). Controls team-count

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

@@ -376,10 +376,9 @@ pub unsafe fn check_weapon_avail(ddgame: *mut DDGame, weapon_index: u32) -> i32
             }
         }
         w if w == Weapon::DoubleTurnTime as u32 => {
-            if game_version > 0xD1
-                && (*gi).double_turn_time_threshold > 0x7FFF {
-                    return 0;
-                }
+            if game_version > 0xD1 && (*gi).double_turn_time_threshold > 0x7FFF {
+                return 0;
+            }
         }
         _ => {}
     }
@@ -401,8 +400,7 @@ pub unsafe fn check_weapon_avail(ddgame: *mut DDGame, weapon_index: u32) -> i32
         }
 
         // AquaSheep (25) or SuperSheep (24) depending on weapon_index_offset
-        let restricted_id = Weapon::AquaSheep as u32
-            - ((*gi).aquasheep_is_supersheep != 0) as u32;
+        let restricted_id = Weapon::AquaSheep as u32 - ((*gi).aquasheep_is_supersheep != 0) as u32;
         if weapon_index != restricted_id {
             return 1;
         }

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

@@ -1,6 +1,5 @@
 pub mod ddgame;
 pub mod ddgame_constructor;
-pub mod replay;
 pub mod ddgame_wrapper;
 pub mod game_info;
 pub mod game_session;
@@ -8,20 +7,21 @@ pub mod game_state_init;
 pub mod game_timer;
 pub mod net_bridge;
 pub mod net_wrapper;
+pub mod replay;
 pub mod team_arena;
 
 pub use ddgame::DDGame;
 pub use ddgame_constructor::{
-    create_ddgame, ddgame_init_fields, ddgame_init_render_indices,
-    display_layer_color_init, init_constructor_addrs, ON_DDGAME_ALLOC,
-};
-pub use team_arena::{
-    CoordEntry, CoordList, CoordListEntry, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH,
-    RenderEntry, SoundQueueEntry, TeamArenaRef, TeamArenaState, TeamBlock, TeamHeader,
-    TeamIndexMap, TeamSlot0, TeamWeaponSlots, WeaponSlots, WormEntry,
+    create_ddgame, ddgame_init_fields, ddgame_init_render_indices, display_layer_color_init,
+    init_constructor_addrs, ON_DDGAME_ALLOC,
 };
 pub use ddgame_wrapper::DDGameWrapper;
 pub use game_info::GameInfo;
 pub use game_session::GameSession;
 pub use game_timer::GameTimer;
 pub use net_wrapper::DDNetGameWrapper;
+pub use team_arena::{
+    CoordEntry, CoordList, CoordListEntry, RenderEntry, SoundQueueEntry, TeamArenaRef,
+    TeamArenaState, TeamBlock, TeamHeader, TeamIndexMap, TeamSlot0, TeamWeaponSlots, WeaponSlots,
+    WormEntry, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH,
+};

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

@@ -7,13 +7,13 @@
 #[repr(i32)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ReplayError {
-    FileNotFound = -1,       // 0xFFFFFFFF
-    InvalidFormat = -2,      // 0xFFFFFFFE
-    VersionTooNew = -3,      // 0xFFFFFFFD
-    MallocFailure = -4,      // 0xFFFFFFFC
-    MapLoadFailure = -5,     // 0xFFFFFFFB
-    ArtClassLimit = -6,      // 0xFFFFFFFA
-    RepairWithTeams = -7,    // 0xFFFFFFF9
+    FileNotFound = -1,    // 0xFFFFFFFF
+    InvalidFormat = -2,   // 0xFFFFFFFE
+    VersionTooNew = -3,   // 0xFFFFFFFD
+    MallocFailure = -4,   // 0xFFFFFFFC
+    MapLoadFailure = -5,  // 0xFFFFFFFB
+    ArtClassLimit = -6,   // 0xFFFFFFFA
+    RepairWithTeams = -7, // 0xFFFFFFF9
     // -8 is unused (gap in error codes)
     NoScheme = -9,           // 0xFFFFFFF7
     SchemeSaveFailure = -10, // 0xFFFFFFF6

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

@@ -531,14 +531,21 @@ impl TeamArenaRef {
 // ── Snapshot impl ──────────────────────────────────────────
 
 impl crate::snapshot::Snapshot for WormEntry {
-    unsafe fn write_snapshot(&self, w: &mut dyn core::fmt::Write, indent: usize) -> core::fmt::Result {
+    unsafe fn write_snapshot(
+        &self,
+        w: &mut dyn core::fmt::Write,
+        indent: usize,
+    ) -> core::fmt::Result {
         use crate::snapshot::write_indent;
         let i = indent;
         let name = core::ffi::CStr::from_ptr(self.name.as_ptr() as *const core::ffi::c_char)
             .to_string_lossy();
         write_indent(w, i)?;
-        writeln!(w, "state=0x{:02X} active={} hp={}/{} name=\"{}\"",
-            self.state, self.active_flag, self.health, self.max_health, name)?;
+        writeln!(
+            w,
+            "state=0x{:02X} active={} hp={}/{} name=\"{}\"",
+            self.state, self.active_flag, self.health, self.max_health, name
+        )?;
         Ok(())
     }
 }

crates/openwa-core/src/fixed.rs

@@ -48,12 +48,20 @@ impl Fixed {
 
     #[inline]
     pub fn max(self, other: Self) -> Self {
-        if self > other { self } else { other }
+        if self > other {
+            self
+        } else {
+            other
+        }
     }
 
     #[inline]
     pub fn min(self, other: Self) -> Self {
-        if self < other { self } else { other }
+        if self < other {
+            self
+        } else {
+            other
+        }
     }
 
     #[inline]

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

@@ -184,19 +184,18 @@ impl SchemeFile {
     /// For V3 schemes, trailing extended options bytes that match the defaults
     /// are trimmed, matching WA's minimal file format.
     pub fn to_bytes(&self) -> Vec<u8> {
-        let payload = if self.version == SchemeVersion::V3
-            && self.payload.len() == SCHEME_PAYLOAD_V3
-        {
-            // Trim trailing extended options bytes that match defaults
-            let ext = &self.payload[EXTENDED_OPTIONS_OFFSET..];
-            let mut trim_len = EXTENDED_OPTIONS_SIZE;
-            while trim_len > 0 && ext[trim_len - 1] == EXTENDED_OPTIONS_DEFAULTS[trim_len - 1] {
-                trim_len -= 1;
-            }
-            &self.payload[..EXTENDED_OPTIONS_OFFSET + trim_len]
-        } else {
-            &self.payload
-        };
+        let payload =
+            if self.version == SchemeVersion::V3 && self.payload.len() == SCHEME_PAYLOAD_V3 {
+                // Trim trailing extended options bytes that match defaults
+                let ext = &self.payload[EXTENDED_OPTIONS_OFFSET..];
+                let mut trim_len = EXTENDED_OPTIONS_SIZE;
+                while trim_len > 0 && ext[trim_len - 1] == EXTENDED_OPTIONS_DEFAULTS[trim_len - 1] {
+                    trim_len -= 1;
+                }
+                &self.payload[..EXTENDED_OPTIONS_OFFSET + trim_len]
+            } else {
+                &self.payload
+            };
         let mut buf = Vec::with_capacity(SCHEME_HEADER_SIZE + payload.len());
         buf.extend_from_slice(&SCHEME_MAGIC);
         buf.push(self.version.to_byte());

crates/openwa-core/src/lib.rs

@@ -22,8 +22,8 @@ extern crate self as openwa_core;
 pub use inventory;
 
 // Re-export derive macros so users write `use openwa_core::FieldRegistry;`
-pub use openwa_derive::FieldRegistry;
 pub use openwa_derive::vtable;
+pub use openwa_derive::FieldRegistry;
 
 #[macro_use]
 pub mod macros;
@@ -37,13 +37,13 @@ pub mod input;
 pub mod render;
 
 pub mod address;
+pub mod field_format;
 pub mod fixed;
-pub mod registry;
 pub mod log;
 pub mod mem;
 pub mod rebase;
+pub mod registry;
 pub mod snapshot;
-pub mod field_format;
 pub mod task;
 pub mod vtable;
 pub mod wa;

crates/openwa-core/src/mem.rs

@@ -41,7 +41,11 @@ pub unsafe fn classify_pointer(value: u32, delta: u32) -> Option<PointerInfo> {
         let name = registry::format_va(ghidra_val);
         let detail = if can_read(value, 4) {
             let vt0 = *(value as *const u32);
-            Some(format!("{} vt[0]=ghidra:0x{:08X}", name, vt0.wrapping_sub(delta)))
+            Some(format!(
+                "{} vt[0]=ghidra:0x{:08X}",
+                name,
+                vt0.wrapping_sub(delta)
+            ))
         } else {
             Some(format!("{} (unreadable)", name))
         };
@@ -164,9 +168,7 @@ pub unsafe fn identify_pointer(value: u32, delta: u32) -> Option<PointerIdentity
                 registry::AddrKind::Vtable | registry::AddrKind::VtableMethod => {
                     PointerKind::Vtable
                 }
-                registry::AddrKind::Function | registry::AddrKind::Constructor => {
-                    PointerKind::Code
-                }
+                registry::AddrKind::Function | registry::AddrKind::Constructor => PointerKind::Code,
                 _ => PointerKind::Data,
             };
             let name = if resolved.offset == 0 {
@@ -241,11 +243,7 @@ pub unsafe fn identify_pointer(value: u32, delta: u32) -> Option<PointerIdentity
 ///
 /// Returns a vec of `PointerInfo` with offsets filled in relative to `base_offset`.
 #[cfg(target_os = "windows")]
-pub unsafe fn classify_region(
-    data: &[u8],
-    base_offset: u32,
-    delta: u32,
-) -> Vec<PointerInfo> {
+pub unsafe fn classify_region(data: &[u8], base_offset: u32, delta: u32) -> Vec<PointerInfo> {
     let mut pointers = Vec::new();
     let dword_count = data.len() / 4;
     for i in 0..dword_count {

crates/openwa-core/src/registry.rs

@@ -153,10 +153,7 @@ pub fn format_va(ghidra_va: u32) -> String {
             format!("{} (0x{:X})", r.entry.name, ghidra_va)
         }
         Some(r) => {
-            format!(
-                "{}+0x{:X} (0x{:X})",
-                r.entry.name, r.offset, ghidra_va
-            )
+            format!("{}+0x{:X} (0x{:X})", r.entry.name, r.offset, ghidra_va)
         }
         None => format!("0x{:08X}", ghidra_va),
     }
@@ -164,7 +161,10 @@ pub fn format_va(ghidra_va: u32) -> String {
 
 /// Iterate all entries of a given kind.
 pub fn entries_by_kind(kind: AddrKind) -> impl Iterator<Item = &'static AddrEntry> {
-    sorted_entries().iter().copied().filter(move |e| e.kind == kind)
+    sorted_entries()
+        .iter()
+        .copied()
+        .filter(move |e| e.kind == kind)
 }
 
 /// Iterate all registered entries (sorted by VA).
@@ -588,9 +588,27 @@ mod tests {
         static FIELDS: StructFields = StructFields {
             struct_name: "TestStruct",
             fields: &[
-                FieldEntry { offset: 0x00, name: "vtable", size: 4, kind: ValueKind::Pointer, doc: "" },
-                FieldEntry { offset: 0x10, name: "health", size: 4, kind: ValueKind::U32, doc: "" },
-                FieldEntry { offset: 0x20, name: "name", size: 16, kind: ValueKind::Raw, doc: "" },
+                FieldEntry {
+                    offset: 0x00,
+                    name: "vtable",
+                    size: 4,
+                    kind: ValueKind::Pointer,
+                    doc: "",
+                },
+                FieldEntry {
+                    offset: 0x10,
+                    name: "health",
+                    size: 4,
+                    kind: ValueKind::U32,
+                    doc: "",
+                },
+                FieldEntry {
+                    offset: 0x20,
+                    name: "name",
+                    size: 16,
+                    kind: ValueKind::Raw,
+                    doc: "",
+                },
             ],
         };
 
@@ -674,7 +692,11 @@ mod tests {
         let reg = CTask::field_registry();
         let vtable = reg.field_at(0x00).unwrap();
         // Doc comment should be non-empty (we have "0x00: Pointer to virtual method table")
-        assert!(!vtable.doc.is_empty(), "doc should be extracted: {:?}", vtable.doc);
+        assert!(
+            !vtable.doc.is_empty(),
+            "doc should be extracted: {:?}",
+            vtable.doc
+        );
     }
 
     #[test]
@@ -688,7 +710,10 @@ mod tests {
         assert!(ctask.is_some(), "CTask not found in struct registry");
 
         let session = struct_fields_for("GameSession");
-        assert!(session.is_some(), "GameSession not found in struct registry");
+        assert!(
+            session.is_some(),
+            "GameSession not found in struct registry"
+        );
 
         // Unknown struct returns None
         assert!(struct_fields_for("FooBarBaz").is_none());
@@ -700,7 +725,10 @@ mod tests {
 
         // DDGameWrapper vtable → "DDGameWrapper" → DDGameWrapper fields
         let fields = struct_fields_for_vtable(va::DDGAME_WRAPPER_VTABLE);
-        assert!(fields.is_some(), "DDGameWrapper fields not found via vtable");
+        assert!(
+            fields.is_some(),
+            "DDGameWrapper fields not found via vtable"
+        );
         assert_eq!(fields.unwrap().struct_name, "DDGameWrapper");
 
         // CTask vtable → "CTask" → CTask fields

crates/openwa-core/src/snapshot.rs

@@ -6,9 +6,9 @@
 
 use core::fmt;
 
+use crate::address::va;
 use crate::mem;
 use crate::rebase::rb;
-use crate::address::va;
 
 /// Trait for types that can write a canonicalized snapshot.
 ///
@@ -35,12 +35,20 @@ pub fn write_indent(w: &mut dyn fmt::Write, indent: usize) -> fmt::Result {
 
 /// Format a pointer field: `<ptr>` if non-null, `null` if null.
 pub fn fmt_ptr(ptr: *const u8) -> &'static str {
-    if ptr.is_null() { "null" } else { "<ptr>" }
+    if ptr.is_null() {
+        "null"
+    } else {
+        "<ptr>"
+    }
 }
 
 /// Format a pointer field for a raw u32 that might be a pointer.
 pub fn fmt_ptr32(val: u32) -> &'static str {
-    if val == 0 { "null" } else { "<ptr>" }
+    if val == 0 {
+        "null"
+    } else {
+        "<ptr>"
+    }
 }
 
 /// Dump a raw memory region as canonicalized hex lines.
@@ -121,12 +129,22 @@ pub unsafe fn hash_region_canonical(ptr: *const u8, len: usize) -> u32 {
     for i in (0..len).step_by(4) {
         let val = if i + 4 <= len {
             *(ptr.add(i) as *const u32)
-        } else { 0 };
-        let hash_val = if is_likely_pointer(val, delta) { 0u32 } else { val };
+        } else {
+            0
+        };
+        let hash_val = if is_likely_pointer(val, delta) {
+            0u32
+        } else {
+            val
+        };
         for byte in hash_val.to_le_bytes() {
             h ^= byte as u32;
             for _ in 0..8 {
-                h = if h & 1 != 0 { (h >> 1) ^ 0xEDB88320 } else { h >> 1 };
+                h = if h & 1 != 0 {
+                    (h >> 1) ^ 0xEDB88320
+                } else {
+                    h >> 1
+                };
             }
         }
     }
@@ -155,13 +173,21 @@ pub unsafe fn hash_pointer_targets(
 
     for off in (0..struct_size).step_by(4) {
         let val = *(base.add(off) as *const u32);
-        if val == 0 { continue; }
-        if !is_likely_pointer(val, delta) { continue; }
+        if val == 0 {
+            continue;
+        }
+        if !is_likely_pointer(val, delta) {
+            continue;
+        }
         // Skip WA code/data pointers — only follow heap pointers
         let ghidra = val.wrapping_sub(delta);
-        if (va::TEXT_START..va::DATA_END).contains(&ghidra) { continue; }
+        if (va::TEXT_START..va::DATA_END).contains(&ghidra) {
+            continue;
+        }
         // Verify target is readable
-        if !mem::can_read(val, target_window as u32) { continue; }
+        if !mem::can_read(val, target_window as u32) {
+            continue;
+        }
 
         let h = hash_region_canonical(val as *const u8, target_window);
         writeln!(w, "[HASH] {}+0x{:04X} hash={:08X}", name, off, h)?;

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

@@ -17,7 +17,8 @@ pub struct CTaskArrowVTable {
     /// HandleMessage — processes arrow messages.
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskArrow, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskArrow, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame arrow update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -116,7 +116,8 @@ pub struct CTaskVtable {
     pub free: fn(this: *mut CTask, flags: u8) -> *mut CTask,
     /// HandleMessage — broadcasts message to all children (base implementation).
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTask, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTask, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessChildren — iterates children with flags. Base at 0x562FA0.
     #[slot(5)]
     pub process_children: fn(this: *mut CTask, flags: u32),
@@ -246,15 +247,14 @@ pub unsafe trait Task {
         loop {
             // Scan for next non-null child
             let child = loop {
-                let watermark = core::ptr::read_volatile(
-                    core::ptr::addr_of!((*task_ptr).children_watermark),
-                ) as usize;
+                let watermark =
+                    core::ptr::read_volatile(core::ptr::addr_of!((*task_ptr).children_watermark))
+                        as usize;
                 if i >= watermark {
                     return;
                 }
-                let children = core::ptr::read_volatile(
-                    core::ptr::addr_of!((*task_ptr).children_data),
-                );
+                let children =
+                    core::ptr::read_volatile(core::ptr::addr_of!((*task_ptr).children_data));
                 let c = *children.add(i);
                 i += 1;
                 if !c.is_null() {
@@ -305,15 +305,14 @@ impl CTask {
         let mut i: usize = 0;
         loop {
             let child = loop {
-                let watermark = core::ptr::read_volatile(
-                    core::ptr::addr_of!((*task_ptr).children_watermark),
-                ) as usize;
+                let watermark =
+                    core::ptr::read_volatile(core::ptr::addr_of!((*task_ptr).children_watermark))
+                        as usize;
                 if i >= watermark {
                     return;
                 }
-                let children = core::ptr::read_volatile(
-                    core::ptr::addr_of!((*task_ptr).children_data),
-                );
+                let children =
+                    core::ptr::read_volatile(core::ptr::addr_of!((*task_ptr).children_data));
                 let c = *children.add(i);
                 i += 1;
                 if !c.is_null() {

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

@@ -18,7 +18,8 @@ pub struct CTaskCloudVTable {
     /// HandleMessage — processes cloud messages (wind updates, render).
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskCloud, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskCloud, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame cloud update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -18,7 +18,8 @@ pub struct CTaskFilterVTable {
     /// HandleMessage — checks subscription table, forwards matching messages.
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskFilter, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskFilter, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame filter update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -17,7 +17,8 @@ pub struct CTaskFireVTable {
     /// HandleMessage — processes fire messages.
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskFire, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskFire, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame fire update (countdown, spread, damage).
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -96,5 +96,6 @@ pub struct SoundEmitterVTable {
     pub destructor: fn(this: *mut SoundEmitter, flags: u32) -> *mut SoundEmitter,
     /// HandleMessage — sound queue manager
     #[slot(4)]
-    pub handle_message: fn(this: *mut SoundEmitter, sender: u32, msg_type: u32, size: u32, data: u32),
+    pub handle_message:
+        fn(this: *mut SoundEmitter, sender: u32, msg_type: u32, size: u32, data: u32),
 }

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

@@ -24,7 +24,8 @@ pub struct CTaskMineVTable {
     /// HandleMessage — processes mine messages (arm, trigger, detonate).
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskMine, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskMine, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame mine update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]
@@ -39,7 +40,8 @@ pub struct CTaskOilDrumVTable {
     /// HandleMessage — processes oil drum messages.
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskOilDrum, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskOilDrum, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame oil drum update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -20,7 +20,8 @@ pub struct CTaskMissileVTable {
     /// HandleMessage — processes missile messages.
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskMissile, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskMissile, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame missile update (physics, homing, detonation).
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]
@@ -206,48 +207,89 @@ pub enum MissileType {
 
 #[cfg(target_arch = "x86")]
 impl crate::snapshot::Snapshot for CTaskMissile {
-    unsafe fn write_snapshot(&self, w: &mut dyn core::fmt::Write, indent: usize) -> core::fmt::Result {
+    unsafe fn write_snapshot(
+        &self,
+        w: &mut dyn core::fmt::Write,
+        indent: usize,
+    ) -> core::fmt::Result {
         use crate::snapshot::{write_indent, write_raw_region};
         let i = indent;
         let b = &self.base; // CGameTask
 
-        write_indent(w, i)?; writeln!(w, "pos = ({}, {})", b.pos_x, b.pos_y)?;
-        write_indent(w, i)?; writeln!(w, "speed = ({}, {})", b.speed_x, b.speed_y)?;
-        write_indent(w, i)?; writeln!(w, "launch_seed = 0x{:08X}", self.launch_seed)?;
-        write_indent(w, i)?; writeln!(w, "slot_id = {}", self.slot_id)?;
+        write_indent(w, i)?;
+        writeln!(w, "pos = ({}, {})", b.pos_x, b.pos_y)?;
+        write_indent(w, i)?;
+        writeln!(w, "speed = ({}, {})", b.speed_x, b.speed_y)?;
+        write_indent(w, i)?;
+        writeln!(w, "launch_seed = 0x{:08X}", self.launch_seed)?;
+        write_indent(w, i)?;
+        writeln!(w, "slot_id = {}", self.slot_id)?;
 
         let sp = &self.spawn_params;
-        write_indent(w, i)?; writeln!(w, "spawn_params:")?;
-        write_indent(w, i + 1)?; writeln!(w, "owner={} spawn=({}, {}) speed=({}, {})",
-            sp.owner_id, sp.spawn_x, sp.spawn_y, sp.initial_speed_x, sp.initial_speed_y)?;
-        write_indent(w, i + 1)?; writeln!(w, "cursor=({}, {}) pellet={} fallback=({}, {})",
-            sp.cursor_x, sp.cursor_y, sp.pellet_index, sp.fallback_timer, sp.fallback_param)?;
+        write_indent(w, i)?;
+        writeln!(w, "spawn_params:")?;
+        write_indent(w, i + 1)?;
+        writeln!(
+            w,
+            "owner={} spawn=({}, {}) speed=({}, {})",
+            sp.owner_id, sp.spawn_x, sp.spawn_y, sp.initial_speed_x, sp.initial_speed_y
+        )?;
+        write_indent(w, i + 1)?;
+        writeln!(
+            w,
+            "cursor=({}, {}) pellet={} fallback=({}, {})",
+            sp.cursor_x, sp.cursor_y, sp.pellet_index, sp.fallback_timer, sp.fallback_param
+        )?;
 
-        write_indent(w, i)?; write!(w, "weapon_data =")?;
+        write_indent(w, i)?;
+        write!(w, "weapon_data =")?;
         for (j, v) in self.weapon_data.iter().enumerate() {
-            if j % 16 == 0 { writeln!(w)?; write_indent(w, i + 1)?; }
+            if j % 16 == 0 {
+                writeln!(w)?;
+                write_indent(w, i + 1)?;
+            }
             write!(w, " {:08X}", v)?;
         }
         writeln!(w)?;
 
-        write_indent(w, i)?; write!(w, "render_data =")?;
+        write_indent(w, i)?;
+        write!(w, "render_data =")?;
         for (j, v) in self.render_data.iter().enumerate() {
-            if j % 16 == 0 { writeln!(w)?; write_indent(w, i + 1)?; }
+            if j % 16 == 0 {
+                writeln!(w)?;
+                write_indent(w, i + 1)?;
+            }
             write!(w, " {:08X}", v)?;
         }
         writeln!(w)?;
 
-        write_indent(w, i)?; writeln!(w, "launch_speed_raw = {}", self.launch_speed_raw)?;
-        write_indent(w, i)?; writeln!(w, "homing_enabled = {}", self.homing_enabled)?;
-        write_indent(w, i)?; writeln!(w, "direction = {}", self.direction)?;
+        write_indent(w, i)?;
+        writeln!(w, "launch_speed_raw = {}", self.launch_speed_raw)?;
+        write_indent(w, i)?;
+        writeln!(w, "homing_enabled = {}", self.homing_enabled)?;
+        write_indent(w, i)?;
+        writeln!(w, "direction = {}", self.direction)?;
 
         // Unknown regions
-        write_indent(w, i)?; writeln!(w, "_unknown_fc ({} bytes):", self._unknown_fc.len())?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_fc ({} bytes):", self._unknown_fc.len())?;
         write_raw_region(w, self._unknown_fc.as_ptr(), self._unknown_fc.len(), i + 1)?;
-        write_indent(w, i)?; writeln!(w, "_unknown_37c ({} bytes):", self._unknown_37c.len())?;
-        write_raw_region(w, self._unknown_37c.as_ptr(), self._unknown_37c.len(), i + 1)?;
-        write_indent(w, i)?; writeln!(w, "_unknown_3cc ({} bytes):", self._unknown_3cc.len())?;
-        write_raw_region(w, self._unknown_3cc.as_ptr(), self._unknown_3cc.len(), i + 1)?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_37c ({} bytes):", self._unknown_37c.len())?;
+        write_raw_region(
+            w,
+            self._unknown_37c.as_ptr(),
+            self._unknown_37c.len(),
+            i + 1,
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_3cc ({} bytes):", self._unknown_3cc.len())?;
+        write_raw_region(
+            w,
+            self._unknown_3cc.as_ptr(),
+            self._unknown_3cc.len(),
+            i + 1,
+        )?;
 
         Ok(())
     }

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

@@ -15,7 +15,9 @@ pub mod turn_game;
 pub mod worm;
 
 pub use arrow::{CTaskArrow, CTaskArrowVTable};
-pub use base::{CTask, CTaskBfsIter, CTaskVtable, SharedDataIter, SharedDataNode, SharedDataTable, Task, Vtable};
+pub use base::{
+    CTask, CTaskBfsIter, CTaskVtable, SharedDataIter, SharedDataNode, SharedDataTable, Task, Vtable,
+};
 pub use cloud::{CTaskCloud, CTaskCloudVTable};
 pub use filter::{CTaskFilter, CTaskFilterVTable};
 pub use fire::{CTaskFire, CTaskFireVTable};

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

@@ -18,7 +18,8 @@ pub struct CTaskCrateVTable {
     /// HandleMessage — processes crate messages (collection, parachute, etc.).
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskCrate, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskCrate, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame crate update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -27,7 +27,8 @@ pub struct CTaskTeamVTable {
     /// surrender, worm selection, napalm strike, etc.)
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskTeam, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskTeam, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// GetEntityData — returns team data by query code.
     /// thiscall + 3 stack params, RET 0xC.
     #[slot(3)]
@@ -133,11 +134,7 @@ impl CTaskTeam {
     ///
     /// # Safety
     /// `this` must be a valid CTaskTeam pointer with valid ddgame.
-    pub unsafe fn on_surrender_fire(
-        this: *mut Self,
-        sender: *mut CTask,
-        msg_team_index: u32,
-    ) {
+    pub unsafe fn on_surrender_fire(this: *mut Self, sender: *mut CTask, msg_team_index: u32) {
         use crate::game::TaskMessage;
 
         let team_index = (*this).team_index;
@@ -157,19 +154,26 @@ impl CTaskTeam {
         let game_version = (*(*ddgame).game_info).game_version;
         if game_version > 0xF4 {
             CTask::broadcast_message_raw(
-                task_ptr, sender, TaskMessage::DetonateWeapon as u32, 4, buf.as_ptr(),
+                task_ptr,
+                sender,
+                TaskMessage::DetonateWeapon as u32,
+                4,
+                buf.as_ptr(),
             );
         }
 
         // 3. Set per-team napalm flag
         // Original: *(ddgame + team_index * 0x51C + 0x4618) = 1
-        let flag_ptr = (ddgame as *mut u8)
-            .add(team_index as usize * 0x51C + 0x4618) as *mut u32;
+        let flag_ptr = (ddgame as *mut u8).add(team_index as usize * 0x51C + 0x4618) as *mut u32;
         *flag_ptr = 1;
 
         // 4. Broadcast original message (0x2B) to children
         CTask::broadcast_message_raw(
-            task_ptr, sender, TaskMessage::Surrender as u32, 4, buf.as_ptr(),
+            task_ptr,
+            sender,
+            TaskMessage::Surrender as u32,
+            4,
+            buf.as_ptr(),
         );
     }
 }

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

@@ -98,7 +98,8 @@ pub struct CTaskTurnGameVTable {
     /// HandleMessage — processes messages for turn flow control
     /// thiscall + 4 stack params, RET 0x10.
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskTurnGame, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskTurnGame, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// ProcessFrame — per-frame turn update.
     /// thiscall + 1 stack param (flags), RET 0x4.
     #[slot(7)]

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

@@ -1,8 +1,8 @@
 use super::base::CTask;
 use super::game_task::CGameTask;
 use crate::fixed::Fixed;
-use crate::game::Weapon;
 use crate::game::weapon::WeaponEntry;
+use crate::game::Weapon;
 use crate::FieldRegistry;
 
 /// Worm state machine states.
@@ -173,7 +173,8 @@ pub struct CTaskWormVTable {
     pub free: fn(this: *mut CTaskWorm, flags: u8) -> *mut CTaskWorm,
     /// HandleMessage — processes all TaskMessages sent to this worm
     #[slot(2)]
-    pub handle_message: fn(this: *mut CTaskWorm, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    pub handle_message:
+        fn(this: *mut CTaskWorm, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
     /// GetEntityData — returns worm data by query code
     #[slot(3)]
     pub get_entity_data: fn(this: *mut CTaskWorm, query: u32, param: u32, out: *mut u32) -> u32,
@@ -451,32 +452,66 @@ impl CTaskWorm {
 
 #[cfg(target_arch = "x86")]
 impl crate::snapshot::Snapshot for CTaskWorm {
-    unsafe fn write_snapshot(&self, w: &mut dyn core::fmt::Write, indent: usize) -> core::fmt::Result {
+    unsafe fn write_snapshot(
+        &self,
+        w: &mut dyn core::fmt::Write,
+        indent: usize,
+    ) -> core::fmt::Result {
         use crate::snapshot::{write_indent, write_raw_region};
         let i = indent;
         let b = &self.base; // CGameTask
 
-        write_indent(w, i)?; writeln!(w, "pos = ({}, {})", b.pos_x, b.pos_y)?;
-        write_indent(w, i)?; writeln!(w, "speed = ({}, {})", b.speed_x, b.speed_y)?;
-        write_indent(w, i)?; writeln!(w, "angle = {}", b.angle)?;
-        write_indent(w, i)?; writeln!(w, "team_index = {}", self.team_index)?;
-        write_indent(w, i)?; writeln!(w, "worm_index = {}", self.worm_index)?;
-        write_indent(w, i)?; writeln!(w, "slot_id = {}", self.slot_id)?;
-        write_indent(w, i)?; writeln!(w, "selected_weapon = {:?}", self.selected_weapon)?;
-        write_indent(w, i)?; writeln!(w, "facing = {}", self.facing_direction)?;
-        write_indent(w, i)?; writeln!(w, "aim_angle = 0x{:08X}", self.aim_angle)?;
+        write_indent(w, i)?;
+        writeln!(w, "pos = ({}, {})", b.pos_x, b.pos_y)?;
+        write_indent(w, i)?;
+        writeln!(w, "speed = ({}, {})", b.speed_x, b.speed_y)?;
+        write_indent(w, i)?;
+        writeln!(w, "angle = {}", b.angle)?;
+        write_indent(w, i)?;
+        writeln!(w, "team_index = {}", self.team_index)?;
+        write_indent(w, i)?;
+        writeln!(w, "worm_index = {}", self.worm_index)?;
+        write_indent(w, i)?;
+        writeln!(w, "slot_id = {}", self.slot_id)?;
+        write_indent(w, i)?;
+        writeln!(w, "selected_weapon = {:?}", self.selected_weapon)?;
+        write_indent(w, i)?;
+        writeln!(w, "facing = {}", self.facing_direction)?;
+        write_indent(w, i)?;
+        writeln!(w, "aim_angle = 0x{:08X}", self.aim_angle)?;
 
-        write_indent(w, i)?; write!(w, "spawn_params =")?;
-        for v in &self.spawn_params { write!(w, " {:08X}", v)?; }
+        write_indent(w, i)?;
+        write!(w, "spawn_params =")?;
+        for v in &self.spawn_params {
+            write!(w, " {:08X}", v)?;
+        }
         writeln!(w)?;
 
         // Raw dump of unknown regions
-        write_indent(w, i)?; writeln!(w, "_unknown_1f0 ({} bytes):", self._unknown_1f0.len())?;
-        write_raw_region(w, self._unknown_1f0.as_ptr(), self._unknown_1f0.len(), i + 1)?;
-        write_indent(w, i)?; writeln!(w, "_unknown_28c ({} bytes):", self._unknown_28c.len())?;
-        write_raw_region(w, self._unknown_28c.as_ptr(), self._unknown_28c.len(), i + 1)?;
-        write_indent(w, i)?; writeln!(w, "_unknown_370 ({} bytes):", self._unknown_370.len())?;
-        write_raw_region(w, self._unknown_370.as_ptr(), self._unknown_370.len(), i + 1)?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_1f0 ({} bytes):", self._unknown_1f0.len())?;
+        write_raw_region(
+            w,
+            self._unknown_1f0.as_ptr(),
+            self._unknown_1f0.len(),
+            i + 1,
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_28c ({} bytes):", self._unknown_28c.len())?;
+        write_raw_region(
+            w,
+            self._unknown_28c.as_ptr(),
+            self._unknown_28c.len(),
+            i + 1,
+        )?;
+        write_indent(w, i)?;
+        writeln!(w, "_unknown_370 ({} bytes):", self._unknown_370.len())?;
+        write_raw_region(
+            w,
+            self._unknown_370.as_ptr(),
+            self._unknown_370.len(),
+            i + 1,
+        )?;
 
         Ok(())
     }

crates/openwa-debug-cli/src/main.rs

@@ -31,16 +31,20 @@ fn main() {
         match args[i].as_str() {
             "--port" => {
                 i += 1;
-                port = args.get(i)
-                    .and_then(|s| s.parse().ok())
-                    .unwrap_or_else(|| { eprintln!("Error: --port requires a number"); process::exit(1); });
+                port = args.get(i).and_then(|s| s.parse().ok()).unwrap_or_else(|| {
+                    eprintln!("Error: --port requires a number");
+                    process::exit(1);
+                });
             }
             "--format" => {
                 i += 1;
                 format = match args.get(i).map(|s| s.as_str()) {
                     Some("hex") => Format::Hex,
                     Some("raw") => Format::Raw,
-                    _ => { eprintln!("Error: --format must be 'hex' or 'raw'"); process::exit(1); }
+                    _ => {
+                        eprintln!("Error: --format must be 'hex' or 'raw'");
+                        process::exit(1);
+                    }
                 };
             }
             other => positional.push(other.to_string()),
@@ -58,36 +62,63 @@ fn main() {
             });
             // Detect shell eating '->' as redirect: address ends with '-'
             if addr_str.ends_with('-') {
-                eprintln!("Error: address '{}' looks truncated — did the shell eat '->'?", addr_str);
+                eprintln!(
+                    "Error: address '{}' looks truncated — did the shell eat '->'?",
+                    addr_str
+                );
                 eprintln!("  Hint: quote the argument: read \"0x7A0884->0xA0->0x0\"");
                 process::exit(1);
             }
             let expr = resolve_address_expr(addr_str, port);
-            let len = positional.get(2)
-                .map(|s| parse_u32(s))
-                .unwrap_or(256);
+            let len = positional.get(2).map(|s| parse_u32(s)).unwrap_or(256);
             match expr {
-                AddressExpr::Simple { addr, absolute } =>
-                    Request::Read { addr, len, absolute },
-                AddressExpr::Chain { addr, chain, absolute } =>
-                    Request::ReadChain { addr, chain, len, absolute },
+                AddressExpr::Simple { addr, absolute } => Request::Read {
+                    addr,
+                    len,
+                    absolute,
+                },
+                AddressExpr::Chain {
+                    addr,
+                    chain,
+                    absolute,
+                } => Request::ReadChain {
+                    addr,
+                    chain,
+                    len,
+                    absolute,
+                },
             }
         }
         Some("inspect") => {
-            let class_name = positional.get(1).unwrap_or_else(|| {
-                eprintln!("Usage: inspect <class_name> <addr>");
-                process::exit(1);
-            }).clone();
+            let class_name = positional
+                .get(1)
+                .unwrap_or_else(|| {
+                    eprintln!("Usage: inspect <class_name> <addr>");
+                    process::exit(1);
+                })
+                .clone();
             let addr_str = positional.get(2).unwrap_or_else(|| {
                 eprintln!("Usage: inspect <class_name> <addr>");
                 process::exit(1);
             });
             let expr = resolve_address_expr(addr_str, port);
             match expr {
-                AddressExpr::Simple { addr, absolute } =>
-                    Request::Inspect { class_name, addr, chain: vec![], absolute },
-                AddressExpr::Chain { addr, chain, absolute } =>
-                    Request::Inspect { class_name, addr, chain, absolute },
+                AddressExpr::Simple { addr, absolute } => Request::Inspect {
+                    class_name,
+                    addr,
+                    chain: vec![],
+                    absolute,
+                },
+                AddressExpr::Chain {
+                    addr,
+                    chain,
+                    absolute,
+                } => Request::Inspect {
+                    class_name,
+                    addr,
+                    chain,
+                    absolute,
+                },
             }
         }
         Some("objects") => Request::ListObjects,
@@ -99,9 +130,19 @@ fn main() {
         }
         Some("frame") => Request::Frame,
         Some("break") => {
-            let frame = positional.get(1)
-                .map(|s| if s == "clear" || s == "off" { -1 } else { parse_u32(s) as i32 })
-                .unwrap_or_else(|| { eprintln!("Usage: break <frame> | break clear"); process::exit(1); });
+            let frame = positional
+                .get(1)
+                .map(|s| {
+                    if s == "clear" || s == "off" {
+                        -1
+                    } else {
+                        parse_u32(s) as i32
+                    }
+                })
+                .unwrap_or_else(|| {
+                    eprintln!("Usage: break <frame> | break clear");
+                    process::exit(1);
+                });
             Request::Break { frame }
         }
         Some("snapshot") => Request::Snapshot,
@@ -149,39 +190,50 @@ fn print_response(response: &Response, format: Format) {
                 println!("  {} — {}", cmd.usage, cmd.description);
             }
         }
-        Response::ReadResult { ghidra_addr, runtime_addr, data, pointers } => {
-            match format {
-                Format::Hex => print_hex_read(*ghidra_addr, *runtime_addr, data, pointers),
-                Format::Raw => {
-                    let stdout = io::stdout();
-                    let mut out = stdout.lock();
-                    let _ = out.write_all(data);
-                }
+        Response::ReadResult {
+            ghidra_addr,
+            runtime_addr,
+            data,
+            pointers,
+        } => match format {
+            Format::Hex => print_hex_read(*ghidra_addr, *runtime_addr, data, pointers),
+            Format::Raw => {
+                let stdout = io::stdout();
+                let mut out = stdout.lock();
+                let _ = out.write_all(data);
             }
-        }
-        Response::ReadChainResult { steps, ghidra_addr, runtime_addr, data, pointers } => {
-            match format {
-                Format::Hex => {
-                    println!("Pointer chain ({} steps):", steps.len());
-                    for (i, step) in steps.iter().enumerate() {
-                        println!(
-                            "  [{}] *(ghidra:0x{:08X}) = 0x{:08X}  + 0x{:X} = 0x{:08X}",
-                            i, step.deref_addr, step.value, step.offset, step.result_addr
-                        );
-                    }
-                    println!();
-                    print_hex_read(*ghidra_addr, *runtime_addr, data, pointers);
-                }
-                Format::Raw => {
-                    let stdout = io::stdout();
-                    let mut out = stdout.lock();
-                    let _ = out.write_all(data);
+        },
+        Response::ReadChainResult {
+            steps,
+            ghidra_addr,
+            runtime_addr,
+            data,
+            pointers,
+        } => match format {
+            Format::Hex => {
+                println!("Pointer chain ({} steps):", steps.len());
+                for (i, step) in steps.iter().enumerate() {
+                    println!(
+                        "  [{}] *(ghidra:0x{:08X}) = 0x{:08X}  + 0x{:X} = 0x{:08X}",
+                        i, step.deref_addr, step.value, step.offset, step.result_addr
+                    );
                 }
+                println!();
+                print_hex_read(*ghidra_addr, *runtime_addr, data, pointers);
             }
-        }
+            Format::Raw => {
+                let stdout = io::stdout();
+                let mut out = stdout.lock();
+                let _ = out.write_all(data);
+            }
+        },
         Response::Suspended { frame } => println!("Suspended at frame {frame}"),
         Response::Resumed => println!("Resumed"),
-        Response::FrameInfo { frame, paused, breakpoint } => {
+        Response::FrameInfo {
+            frame,
+            paused,
+            breakpoint,
+        } => {
             let state = if *paused { "PAUSED" } else { "running" };
             print!("Frame {frame} [{state}]");
             if *breakpoint >= 0 {
@@ -200,7 +252,12 @@ fn print_response(response: &Response, format: Format) {
             println!("=== Snapshot at frame {frame} ===\n");
             print!("{text}");
         }
-        Response::InspectResult { class_name, ghidra_addr, runtime_addr, fields } => {
+        Response::InspectResult {
+            class_name,
+            ghidra_addr,
+            runtime_addr,
+            fields,
+        } => {
             println!(
                 "{} at ghidra:0x{:08X} (runtime:0x{:08X})\n",
                 class_name, ghidra_addr, runtime_addr
@@ -226,7 +283,10 @@ fn print_response(response: &Response, format: Format) {
             }
         }
         Response::AliasResult(alias) => {
-            println!("{} at runtime:0x{:08X}", alias.class_name, alias.runtime_addr);
+            println!(
+                "{} at runtime:0x{:08X}",
+                alias.class_name, alias.runtime_addr
+            );
         }
         Response::FieldResult(field) => {
             println!("offset:0x{:X} size:{}", field.offset, field.size);
@@ -241,7 +301,9 @@ fn print_response(response: &Response, format: Format) {
 fn print_hex_read(ghidra_addr: u32, runtime_addr: u32, data: &[u8], pointers: &[PointerInfo]) {
     println!(
         "Reading 0x{:X} bytes at ghidra:0x{:08X} (runtime:0x{:08X})\n",
-        data.len(), ghidra_addr, runtime_addr
+        data.len(),
+        ghidra_addr,
+        runtime_addr
     );
 
     // Hex dump with ASCII sidebar
@@ -252,13 +314,17 @@ fn print_hex_read(ghidra_addr: u32, runtime_addr: u32, data: &[u8], pointers: &[
         // Hex bytes
         for (i, byte) in chunk.iter().enumerate() {
             print!("{:02X} ", byte);
-            if i == 7 { print!(" "); }
+            if i == 7 {
+                print!(" ");
+            }
         }
         // Padding for short last line
         if chunk.len() < 16 {
             for i in chunk.len()..16 {
                 print!("   ");
-                if i == 7 { print!(" "); }
+                if i == 7 {
+                    print!(" ");
+                }
             }
         }
         // ASCII sidebar
@@ -284,7 +350,11 @@ fn print_hex_read(ghidra_addr: u32, runtime_addr: u32, data: &[u8], pointers: &[
                 PointerKind::Object => "OBJECT",
                 PointerKind::Heap => "HEAP",
             };
-            let detail_str = p.detail.as_deref().map(|d| format!("  {d}")).unwrap_or_default();
+            let detail_str = p
+                .detail
+                .as_deref()
+                .map(|d| format!("  {d}"))
+                .unwrap_or_default();
             println!(
                 "  +0x{:03X}  0x{:08X}  {:<7} ghidra:0x{:08X}{}",
                 p.offset, p.raw_value, kind_str, p.ghidra_value, detail_str
@@ -304,7 +374,11 @@ enum AddressExpr {
     /// Simple address (with optional offset already applied)
     Simple { addr: u32, absolute: bool },
     /// Pointer chain: start address + list of deref offsets
-    Chain { addr: u32, chain: Vec<u32>, absolute: bool },
+    Chain {
+        addr: u32,
+        chain: Vec<u32>,
+        absolute: bool,
+    },
 }
 
 /// Split a string on '+' or '[' into (base, offset_str). Returns (s, None) if no compound.
@@ -330,10 +404,13 @@ fn resolve_offset(s: &str, class: &Option<String>, port: u16) -> u32 {
 
     // Try as field name
     if let Some(cls) = class {
-        match send_request(port, &Request::ResolveField {
-            class_name: cls.clone(),
-            field_name: s.to_string(),
-        }) {
+        match send_request(
+            port,
+            &Request::ResolveField {
+                class_name: cls.clone(),
+                field_name: s.to_string(),
+            },
+        ) {
             Ok(Response::FieldResult(f)) => return f.offset,
             _ => {}
         }
@@ -344,7 +421,10 @@ fn resolve_offset(s: &str, class: &Option<String>, port: u16) -> u32 {
 }
 
 fn parse_hex(s: &str) -> u32 {
-    let s = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")).unwrap_or(s);
+    let s = s
+        .strip_prefix("0x")
+        .or_else(|| s.strip_prefix("0X"))
+        .unwrap_or(s);
     u32::from_str_radix(s, 16).unwrap_or_else(|_| {
         eprintln!("Error: invalid hex address '{s}'");
         process::exit(1);
@@ -408,7 +488,10 @@ fn resolve_address_expr(s: &str, port: u16) -> AddressExpr {
     let (base_addr, base_absolute, mut current_class) = resolve_base(base_part, absolute, port);
 
     if parts.len() == 1 {
-        return AddressExpr::Simple { addr: base_addr, absolute: base_absolute };
+        return AddressExpr::Simple {
+            addr: base_addr,
+            absolute: base_absolute,
+        };
     }
 
     // Resolve each chain segment, tracking whether it's a field name or hex.
@@ -443,7 +526,11 @@ fn resolve_address_expr(s: &str, port: u16) -> AddressExpr {
         }
     }
 
-    AddressExpr::Chain { addr: final_base, chain, absolute: base_absolute }
+    AddressExpr::Chain {
+        addr: final_base,
+        chain,
+        absolute: base_absolute,
+    }
 }
 
 /// Resolve the base address part — could be a hex literal, a named alias, or alias+offset.
@@ -457,11 +544,18 @@ fn resolve_base(s: &str, absolute: bool, port: u16) -> (u32, bool, Option<String
     }
 
     // Try resolving as a named alias
-    match send_request(port, &Request::ResolveAlias { name: base_str.to_string() }) {
+    match send_request(
+        port,
+        &Request::ResolveAlias {
+            name: base_str.to_string(),
+        },
+    ) {
         Ok(Response::AliasResult(alias)) => {
             // Resolved! Use runtime address (absolute)
             let class = Some(alias.class_name);
-            let extra = offset_str.map(|o| resolve_offset(o, &class, port)).unwrap_or(0);
+            let extra = offset_str
+                .map(|o| resolve_offset(o, &class, port))
+                .unwrap_or(0);
             (alias.runtime_addr.wrapping_add(extra), true, class)
         }
         _ => {
@@ -475,7 +569,9 @@ fn resolve_base(s: &str, absolute: bool, port: u16) -> (u32, bool, Option<String
 /// Resolve a chain segment, returning whether it was a field name or hex offset.
 fn resolve_chain_segment_typed(s: &str, current_class: &Option<String>, port: u16) -> ChainSegment {
     let (base_str, offset_str) = split_compound(s);
-    let extra = offset_str.map(|o| resolve_offset(o, current_class, port)).unwrap_or(0);
+    let extra = offset_str
+        .map(|o| resolve_offset(o, current_class, port))
+        .unwrap_or(0);
 
     // If it looks like hex, parse directly — standard chain semantics
     if looks_like_hex(base_str) {
@@ -484,10 +580,13 @@ fn resolve_chain_segment_typed(s: &str, current_class: &Option<String>, port: u1
 
     // Try resolving as a field name if we know the current class
     if let Some(class) = current_class {
-        match send_request(port, &Request::ResolveField {
-            class_name: class.clone(),
-            field_name: base_str.to_string(),
-        }) {
+        match send_request(
+            port,
+            &Request::ResolveField {
+                class_name: class.clone(),
+                field_name: base_str.to_string(),
+            },
+        ) {
             Ok(Response::FieldResult(f)) => {
                 return ChainSegment::FieldOffset(f.offset.wrapping_add(extra));
             }
@@ -501,7 +600,9 @@ fn resolve_chain_segment_typed(s: &str, current_class: &Option<String>, port: u1
 
 /// Check if a string looks like a hex number (starts with 0x or a digit).
 fn looks_like_hex(s: &str) -> bool {
-    s.starts_with("0x") || s.starts_with("0X") || s.chars().next().map_or(false, |c| c.is_ascii_digit())
+    s.starts_with("0x")
+        || s.starts_with("0X")
+        || s.chars().next().map_or(false, |c| c.is_ascii_digit())
 }
 
 fn print_usage() {

crates/openwa-debug-proto/src/lib.rs

@@ -65,30 +65,54 @@ pub struct ResolvedField {
 pub enum Request {
     Ping,
     Help,
-    Read { addr: u32, len: u32, #[serde(default)] absolute: bool },
+    Read {
+        addr: u32,
+        len: u32,
+        #[serde(default)]
+        absolute: bool,
+    },
     /// Walk a pointer chain: start at `addr`, then for each offset in `chain`,
     /// deref the current DWORD and add the offset. Read `len` bytes at the end.
-    ReadChain { addr: u32, chain: Vec<u32>, len: u32, absolute: bool },
+    ReadChain {
+        addr: u32,
+        chain: Vec<u32>,
+        len: u32,
+        absolute: bool,
+    },
     /// Pause the game at the next frame boundary.
     Suspend,
     /// Resume the game.
     Resume,
     /// Advance `count` frames, then pause.
-    Step { count: i32 },
+    Step {
+        count: i32,
+    },
     /// Query current frame number and pause state.
     Frame,
     /// Set a frame breakpoint (-1 to clear).
-    Break { frame: i32 },
+    Break {
+        frame: i32,
+    },
     /// Capture a canonicalized game state snapshot.
     Snapshot,
     /// Typed struct inspection: read all named fields at an address.
-    Inspect { class_name: String, addr: u32, chain: Vec<u32>, absolute: bool },
+    Inspect {
+        class_name: String,
+        addr: u32,
+        chain: Vec<u32>,
+        absolute: bool,
+    },
     /// List all tracked live objects.
     ListObjects,
     /// Resolve a named alias (e.g., "ddgame") to a runtime address.
-    ResolveAlias { name: String },
+    ResolveAlias {
+        name: String,
+    },
     /// Resolve a field name to its offset within a struct.
-    ResolveField { class_name: String, field_name: String },
+    ResolveField {
+        class_name: String,
+        field_name: String,
+    },
 }
 
 /// One step in a resolved pointer chain, for display.
@@ -114,7 +138,9 @@ pub struct CommandHelp {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Response {
     Pong,
-    Help { commands: Vec<CommandHelp> },
+    Help {
+        commands: Vec<CommandHelp>,
+    },
     ReadResult {
         ghidra_addr: u32,
         runtime_addr: u32,
@@ -134,15 +160,26 @@ pub enum Response {
         pointers: Vec<PointerInfo>,
     },
     /// Game is now suspended at this frame.
-    Suspended { frame: i32 },
+    Suspended {
+        frame: i32,
+    },
     /// Game resumed.
     Resumed,
     /// Current frame info.
-    FrameInfo { frame: i32, paused: bool, breakpoint: i32 },
+    FrameInfo {
+        frame: i32,
+        paused: bool,
+        breakpoint: i32,
+    },
     /// Breakpoint set/cleared.
-    BreakSet { frame: i32 },
+    BreakSet {
+        frame: i32,
+    },
     /// Game state snapshot.
-    Snapshot { frame: i32, text: String },
+    Snapshot {
+        frame: i32,
+        text: String,
+    },
     /// Typed struct inspection result.
     InspectResult {
         class_name: String,
@@ -151,12 +188,16 @@ pub enum Response {
         fields: Vec<FieldValue>,
     },
     /// List of tracked live objects.
-    ObjectList { objects: Vec<LiveObjectInfo> },
+    ObjectList {
+        objects: Vec<LiveObjectInfo>,
+    },
     /// Resolved named alias.
     AliasResult(ResolvedAlias),
     /// Resolved field offset.
     FieldResult(ResolvedField),
-    Error { message: String },
+    Error {
+        message: String,
+    },
 }
 
 // --- Length-prefixed framing ---
@@ -188,6 +229,5 @@ pub fn read_frame<R: Read, T: for<'de> Deserialize<'de>>(reader: &mut R) -> io::
     }
     let mut payload = vec![0u8; len];
     reader.read_exact(&mut payload)?;
-    rmp_serde::from_slice(&payload)
-        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    rmp_serde::from_slice(&payload).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
 }

crates/openwa-debugui/src/app.rs

@@ -408,8 +408,7 @@ unsafe fn show_game_task_raw_fields(
                             // Pointer identification via registry
                             use openwa_core::mem;
                             let ptr_label = if val >= 0x10000 {
-                                mem::identify_pointer(val, delta)
-                                    .and_then(|id| id.name)
+                                mem::identify_pointer(val, delta).and_then(|id| id.name)
                             } else {
                                 None
                             };
@@ -569,23 +568,17 @@ impl DebugApp {
 
                     // --- CTaskMine-specific fields ---
                     if name == "CTaskMine" {
-                        show_game_task_raw_fields(
-                            ui, addr, "CTaskMine", 0x128,
-                        );
+                        show_game_task_raw_fields(ui, addr, "CTaskMine", 0x128);
                     }
 
                     // --- CTaskOilDrum-specific fields ---
                     if name == "CTaskOilDrum" {
-                        show_game_task_raw_fields(
-                            ui, addr, "CTaskOilDrum", 0x110,
-                        );
+                        show_game_task_raw_fields(ui, addr, "CTaskOilDrum", 0x110);
                     }
 
                     // --- CTaskCrate-specific fields ---
                     if name == "CTaskCrate" {
-                        show_game_task_raw_fields(
-                            ui, addr, "CTaskCrate", 0x4B0,
-                        );
+                        show_game_task_raw_fields(ui, addr, "CTaskCrate", 0x4B0);
                     }
 
                     // --- CTaskCloud-specific fields ---
@@ -803,9 +796,7 @@ impl DebugApp {
                         ));
                         ui.separator();
 
-                        show_game_task_raw_fields(
-                            ui, addr, "CTaskWorm", 0x3FC,
-                        );
+                        show_game_task_raw_fields(ui, addr, "CTaskWorm", 0x3FC);
                     }
 
                     // --- CTaskMissile-specific fields ---
@@ -821,9 +812,7 @@ impl DebugApp {
                         ));
                         ui.separator();
 
-                        show_game_task_raw_fields(
-                            ui, addr, "CTaskMissile", 0x41C,
-                        );
+                        show_game_task_raw_fields(ui, addr, "CTaskMissile", 0x41C);
                     }
                 }
             });

crates/openwa-derive/src/lib.rs

@@ -110,9 +110,10 @@ fn vtable_impl(
     let mut has_implicit_slot = false;
 
     for (field_idx, field) in fields.iter().enumerate() {
-        let ident = field.ident.as_ref().ok_or_else(|| {
-            syn::Error::new_spanned(field, "Vtable fields must be named")
-        })?;
+        let ident = field
+            .ident
+            .as_ref()
+            .ok_or_else(|| syn::Error::new_spanned(field, "Vtable fields must be named"))?;
 
         let explicit_index = parse_slot_attr(&field.attrs, ident)?;
 
@@ -513,9 +514,9 @@ fn parse_vtable_attr_args(
 
     syn::parse::Parser::parse2(parser, attr)?;
 
-    let size = args.size.ok_or_else(|| {
-        syn::Error::new_spanned(span, "vtable attribute requires `size = N`")
-    })?;
+    let size = args
+        .size
+        .ok_or_else(|| syn::Error::new_spanned(span, "vtable attribute requires `size = N`"))?;
 
     Ok((size, args.va, args.class))
 }
@@ -586,9 +587,12 @@ pub fn derive_field_registry(input: TokenStream) -> TokenStream {
             }
         },
         _ => {
-            return syn::Error::new_spanned(struct_name, "FieldRegistry can only be used on structs")
-                .to_compile_error()
-                .into();
+            return syn::Error::new_spanned(
+                struct_name,
+                "FieldRegistry can only be used on structs",
+            )
+            .to_compile_error()
+            .into();
         }
     };
 
@@ -616,8 +620,8 @@ pub fn derive_field_registry(input: TokenStream) -> TokenStream {
         let size_ty = substitute_generics(field_ty, &generic_defaults);
 
         // Determine ValueKind: check for #[field(kind = "...")] override, else infer
-        let kind = parse_field_kind_attr(&field.attrs)
-            .unwrap_or_else(|| infer_value_kind(field_ty));
+        let kind =
+            parse_field_kind_attr(&field.attrs).unwrap_or_else(|| infer_value_kind(field_ty));
 
         entries.push(quote! {
             openwa_core::registry::FieldEntry {

crates/openwa-test-runner/src/main.rs

@@ -194,7 +194,14 @@ fn find_launcher() -> Option<PathBuf> {
 fn build() -> Result<Duration, String> {
     let start = Instant::now();
     let status = Command::new("cargo")
-        .args(["build", "--release", "-p", "openwa-wormkit", "-p", "openwa-launcher"])
+        .args([
+            "build",
+            "--release",
+            "-p",
+            "openwa-wormkit",
+            "-p",
+            "openwa-launcher",
+        ])
         .status()
         .map_err(|e| format!("Failed to run cargo: {e}"))?;
 
@@ -227,7 +234,6 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
         .creation_flags(CREATE_NO_WINDOW)
         .status();
 
-
     let duration = start.elapsed();
 
     match result {
@@ -262,8 +268,10 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                     passed: false,
                     duration,
                     diff_lines: Vec::new(),
-                    error: Some(format!("No output log generated (exit code: {})",
-                        status.code().unwrap_or(-1))),
+                    error: Some(format!(
+                        "No output log generated (exit code: {})",
+                        status.code().unwrap_or(-1)
+                    )),
                 };
             }
 
@@ -286,7 +294,8 @@ fn run_test(test: &TestCase, launcher: &Path, wa_exe: &Path, run_dir: &Path) ->
                 if diff.is_empty() {
                     diff.push(format!(
                         "  (byte-level difference: expected {} bytes, actual {} bytes)",
-                        expected.len(), actual.len()
+                        expected.len(),
+                        actual.len()
                     ));
                 }
                 let _ = fs::remove_file(&test.output_log);
@@ -407,7 +416,11 @@ fn run_tests_parallel(
 // ─── Output ─────────────────────────────────────────────────────────────────
 
 fn print_result(result: &TestResult) {
-    let status = if result.passed { "\x1b[32m  PASS\x1b[0m" } else { "\x1b[31m  FAIL\x1b[0m" };
+    let status = if result.passed {
+        "\x1b[32m  PASS\x1b[0m"
+    } else {
+        "\x1b[31m  FAIL\x1b[0m"
+    };
     let secs = result.duration.as_secs_f64();
     println!("{status}  {:<28} ({secs:.1}s)", result.name);
 
@@ -443,7 +456,12 @@ fn write_summary(results: &[TestResult], wall_time: Duration, path: &Path) {
     let mut s = String::new();
     for r in results {
         let status = if r.passed { "PASS" } else { "FAIL" };
-        let _ = writeln!(s, "{status}  {:<28} ({:.1}s)", r.name, r.duration.as_secs_f64());
+        let _ = writeln!(
+            s,
+            "{status}  {:<28} ({:.1}s)",
+            r.name,
+            r.duration.as_secs_f64()
+        );
         if let Some(err) = &r.error {
             let _ = writeln!(s, "        {err}");
         }
@@ -453,8 +471,12 @@ fn write_summary(results: &[TestResult], wall_time: Duration, path: &Path) {
     }
     let passed = results.iter().filter(|r| r.passed).count();
     let failed = results.len() - passed;
-    let _ = writeln!(s, "\n{} tests: {passed} passed, {failed} failed (wall {:.1}s)",
-        results.len(), wall_time.as_secs_f64());
+    let _ = writeln!(
+        s,
+        "\n{} tests: {passed} passed, {failed} failed (wall {:.1}s)",
+        results.len(),
+        wall_time.as_secs_f64()
+    );
 
     let _ = fs::write(path, s);
 }
@@ -469,10 +491,7 @@ fn cleanup_temp_files(wa_exe: &Path) {
         None => return,
     };
 
-    let patterns = [
-        (game_dir, "mono_", ".tmp"),
-        (game_dir, "cur_", ".thm"),
-    ];
+    let patterns = [(game_dir, "mono_", ".tmp"), (game_dir, "cur_", ".thm")];
     let data_dir = game_dir.join("DATA");
     let data_patterns = [
         ("land_", ".dat"),

crates/openwa-wormkit/src/debug_server.rs

@@ -110,11 +110,22 @@ fn handle_request(request: Request) -> Response {
                 },
             ],
         },
-        Request::Read { addr, len, absolute } => handle_read(addr, len, absolute),
-        Request::ReadChain { addr, chain, len, absolute } => handle_read_chain(addr, &chain, len, absolute),
+        Request::Read {
+            addr,
+            len,
+            absolute,
+        } => handle_read(addr, len, absolute),
+        Request::ReadChain {
+            addr,
+            chain,
+            len,
+            absolute,
+        } => handle_read_chain(addr, &chain, len, absolute),
         Request::Suspend => {
             crate::debug_sync::suspend();
-            Response::Suspended { frame: crate::debug_sync::current_frame() }
+            Response::Suspended {
+                frame: crate::debug_sync::current_frame(),
+            }
         }
         Request::Resume => {
             crate::debug_sync::resume();
@@ -124,7 +135,9 @@ fn handle_request(request: Request) -> Response {
             crate::debug_sync::step(count);
             // Wait briefly for the step to complete, then report
             std::thread::sleep(Duration::from_millis(100));
-            Response::Suspended { frame: crate::debug_sync::current_frame() }
+            Response::Suspended {
+                frame: crate::debug_sync::current_frame(),
+            }
         }
         Request::Frame => Response::FrameInfo {
             frame: crate::debug_sync::current_frame(),
@@ -140,14 +153,18 @@ fn handle_request(request: Request) -> Response {
             let frame = crate::debug_sync::current_frame();
             Response::Snapshot { frame, text }
         }
-        Request::Inspect { class_name, addr, chain, absolute } => {
-            handle_inspect(&class_name, addr, &chain, absolute)
-        }
+        Request::Inspect {
+            class_name,
+            addr,
+            chain,
+            absolute,
+        } => handle_inspect(&class_name, addr, &chain, absolute),
         Request::ListObjects => handle_list_objects(),
         Request::ResolveAlias { name } => handle_resolve_alias(&name),
-        Request::ResolveField { class_name, field_name } => {
-            handle_resolve_field(&class_name, &field_name)
-        }
+        Request::ResolveField {
+            class_name,
+            field_name,
+        } => handle_resolve_field(&class_name, &field_name),
     }
 }
 
@@ -189,11 +206,7 @@ fn handle_read(addr: u32, len: u32, absolute: bool) -> Response {
 
         // Copy the memory region
         let mut data = vec![0u8; len as usize];
-        std::ptr::copy_nonoverlapping(
-            runtime_addr as *const u8,
-            data.as_mut_ptr(),
-            len as usize,
-        );
+        std::ptr::copy_nonoverlapping(runtime_addr as *const u8, data.as_mut_ptr(), len as usize);
 
         // Classify pointers in the copied data
         let pointers = mem::classify_region(&data, 0, delta);
@@ -230,10 +243,7 @@ fn handle_inspect(class_name: &str, addr: u32, chain: &[u32], absolute: bool) ->
             unsafe {
                 if !mem::can_read(current, 4) {
                     return Response::Error {
-                        message: format!(
-                            "Chain broke: cannot read at runtime:0x{:08X}",
-                            current
-                        ),
+                        message: format!("Chain broke: cannot read at runtime:0x{:08X}", current),
                     };
                 }
                 let value = *(current as *const u32);
@@ -370,8 +380,12 @@ fn handle_resolve_field(class_name: &str, field_name: &str) -> Response {
     }
 
     Response::Error {
-        message: format!("No field '{}' in '{}' (searched: {})", field_name, class_name,
-            search_chain.join(" -> ")),
+        message: format!(
+            "No field '{}' in '{}' (searched: {})",
+            field_name,
+            class_name,
+            search_chain.join(" -> ")
+        ),
     }
 }
 

crates/openwa-wormkit/src/debug_sync.rs

@@ -36,9 +36,7 @@ fn event() -> HANDLE {
 
 /// Initialize the sync primitives. Call once from DLL init.
 pub fn init() {
-    let handle = unsafe {
-        CreateEventA(core::ptr::null(), 1, 1, core::ptr::null())
-    };
+    let handle = unsafe { CreateEventA(core::ptr::null(), 1, 1, core::ptr::null()) };
     assert!(!handle.is_null(), "debug_sync: CreateEventA failed");
     RESUME_EVENT.store(handle as usize, Ordering::Relaxed);
 
@@ -77,7 +75,9 @@ pub fn on_frame_start(frame: i32) {
 
     // Block if paused
     if PAUSED.load(Ordering::Acquire) {
-        unsafe { WaitForSingleObject(event(), 0xFFFFFFFF); }
+        unsafe {
+            WaitForSingleObject(event(), 0xFFFFFFFF);
+        }
     }
 }
 
@@ -94,7 +94,9 @@ pub fn suspend() {
 pub fn resume() {
     PAUSED.store(false, Ordering::Release);
     STEP_REMAINING.store(-1, Ordering::Relaxed);
-    unsafe { SetEvent(event()); }
+    unsafe {
+        SetEvent(event());
+    }
     let _ = log_line("[DebugSync] Resumed");
 }
 
@@ -102,7 +104,9 @@ pub fn resume() {
 pub fn step(count: i32) {
     STEP_REMAINING.store(count.max(1), Ordering::Relaxed);
     PAUSED.store(false, Ordering::Release);
-    unsafe { SetEvent(event()); }
+    unsafe {
+        SetEvent(event());
+    }
 }
 
 /// Set a frame breakpoint. -1 to clear.
@@ -129,5 +133,7 @@ pub fn breakpoint() -> i32 {
 
 fn do_suspend() {
     PAUSED.store(true, Ordering::Release);
-    unsafe { ResetEvent(event()); }
+    unsafe {
+        ResetEvent(event());
+    }
 }

crates/openwa-wormkit/src/debug_watchpoint.rs

@@ -33,9 +33,7 @@ use windows_sys::Win32::System::Diagnostics::Debug::{
 /// Offsets to watch. Hardware limit: 4 watchpoints (DR0–DR3).
 /// Change these to investigate different fields.
 /// NOTE: The base pointer is set by `on_ddgame_alloc()` — can be DDGame or DDGameWrapper.
-const WATCH_OFFSETS: [(u32, &str); 1] = [
-    (0x3A40, "display+0x3A40"),
-];
+const WATCH_OFFSETS: [(u32, &str); 1] = [(0x3A40, "display+0x3A40")];
 
 /// DDGame base address (set when allocation is reported).
 static DDGAME_BASE: AtomicU32 = AtomicU32::new(0);
@@ -160,7 +158,10 @@ unsafe extern "system" fn veh_handler(info: *mut EXCEPTION_POINTERS) -> i32 {
 
                     let _ = log_line(&format!(
                         "[Watchpoint] {} = 0x{:08X}  eip={} stack=[{}]",
-                        name, val, openwa_core::registry::format_va(ghidra_eip), trace,
+                        name,
+                        val,
+                        openwa_core::registry::format_va(ghidra_eip),
+                        trace,
                     ));
                 }
             }
@@ -208,8 +209,7 @@ unsafe extern "cdecl" fn malloc_hook(size: u32) -> *mut u8 {
     if size == DDGAME_ALLOC_SIZE && !result.is_null() {
         let _ = log_line(&format!(
             "[Watchpoint] Intercepted wa_malloc(0x{:X}) = 0x{:08X}",
-            size,
-            result as u32,
+            size, result as u32,
         ));
         on_ddgame_alloc(result);
     }

crates/openwa-wormkit/src/lib.rs

@@ -66,8 +66,8 @@ fn clear_log() -> std::io::Result<()> {
 
 fn run() -> Result<(), String> {
     let _ = clear_log();
-    let validation_path = std::env::var_os("OPENWA_VALIDATION_LOG_PATH")
-        .unwrap_or("OpenWA_validation.log".into());
+    let validation_path =
+        std::env::var_os("OPENWA_VALIDATION_LOG_PATH").unwrap_or("OpenWA_validation.log".into());
     let _ = std::fs::write(validation_path, "");
 
     // Install panic hook that writes to our log file
@@ -132,7 +132,10 @@ fn signal_hooks_ready() {
         if !handle.is_null() {
             SetEvent(handle);
             CloseHandle(handle);
-            let _ = log_line(&format!("=== Signalled {}{} ===", HOOKS_READY_EVENT_PREFIX, pid));
+            let _ = log_line(&format!(
+                "=== Signalled {}{} ===",
+                HOOKS_READY_EVENT_PREFIX, pid
+            ));
         }
         // If handle is null, we weren't launched by our launcher — that's fine.
     }

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

@@ -96,9 +96,8 @@ pub fn install() -> Result<(), String> {
     }
 
     unsafe {
-        let module = windows_sys::Win32::System::LibraryLoader::GetModuleHandleA(
-            b"kernel32.dll\0".as_ptr(),
-        );
+        let module =
+            windows_sys::Win32::System::LibraryLoader::GetModuleHandleA(b"kernel32.dll\0".as_ptr());
         if module.is_null() {
             return Err("kernel32.dll not loaded".to_string());
         }

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

@@ -47,9 +47,16 @@ unsafe extern "stdcall" fn call_init_replay(_game_info: *mut GameInfo, _this: *m
 /// Temp: bridge to original DDGame__Constructor for comparison.
 #[unsafe(naked)]
 unsafe extern "C" fn call_original_ddgame_ctor(
-    _wrapper: *mut DDGameWrapper, _display: *mut DDDisplay, _sound: *mut DSSound,
-    _keyboard: *mut u8, _palette: *mut Palette, _music: *mut u8,
-    _timer: *mut u8, _net_game: *mut u8, _game_info: *mut GameInfo, _input_ctrl: *mut u8,
+    _wrapper: *mut DDGameWrapper,
+    _display: *mut DDDisplay,
+    _sound: *mut DSSound,
+    _keyboard: *mut u8,
+    _palette: *mut Palette,
+    _music: *mut u8,
+    _timer: *mut u8,
+    _net_game: *mut u8,
+    _game_info: *mut GameInfo,
+    _input_ctrl: *mut u8,
 ) {
     core::arch::naked_asm!(
         "mov ecx, [esp+40]",
@@ -123,8 +130,16 @@ pub(crate) unsafe fn construct_ddgame_wrapper(
     let use_original = std::env::var("OPENWA_USE_ORIG_CTOR").is_ok();
     if use_original {
         call_original_ddgame_ctor(
-            this, display, sound, keyboard, palette, streaming_audio,
-            timer_obj, net_game, game_info, input_ctrl,
+            this,
+            display,
+            sound,
+            keyboard,
+            palette,
+            streaming_audio,
+            timer_obj,
+            net_game,
+            game_info,
+            input_ctrl,
         );
     } else {
         create_ddgame(
@@ -139,7 +154,6 @@ pub(crate) unsafe fn construct_ddgame_wrapper(
             game_info,
             input_ctrl as u32,
         );
-
     }
 
     // Disarm display watchpoint
@@ -152,10 +166,10 @@ pub(crate) unsafe fn construct_ddgame_wrapper(
         core::mem::transmute(rb(va::DDGAME_INIT_GAME_STATE) as usize);
     init_state(this);
 
-
     let _ = log_line(&format!(
         "[GameSession] DDGameWrapper::Constructor done: wrapper=0x{:08X}  ddgame=0x{:08X}",
-        this as u32, (*this).ddgame as u32,
+        this as u32,
+        (*this).ddgame as u32,
     ));
 
     // Register live objects for pointer identification in debug tools.

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

@@ -188,7 +188,8 @@ unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
         crate::debug_sync::on_frame_start(game_frame);
 
         // Hardware watchpoint: arm once at the watch frame
-        static WATCH_ARMED: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
+        static WATCH_ARMED: core::sync::atomic::AtomicBool =
+            core::sync::atomic::AtomicBool::new(false);
         if !WATCH_ARMED.load(Ordering::Relaxed) {
             if let Ok(val) = std::env::var("OPENWA_WATCH_FRAME") {
                 let target: i32 = val.parse().unwrap_or(0);
@@ -280,7 +281,9 @@ pub fn write_gameplay_report() {
             frames
         ));
     } else {
-        let _ = log_validation("[GAMEPLAY FAIL] Game initialized - no frames processed (game may not have started)");
+        let _ = log_validation(
+            "[GAMEPLAY FAIL] Game initialized - no frames processed (game may not have started)",
+        );
     }
 
     // Milestone 2: Match started (multiple teams with alive worms)
@@ -291,7 +294,8 @@ pub fn write_gameplay_report() {
             teams
         ));
     } else if frames > 0 {
-        let _ = log_validation("[GAMEPLAY FAIL] Match started - never detected multiple alive teams");
+        let _ =
+            log_validation("[GAMEPLAY FAIL] Match started - never detected multiple alive teams");
     } else {
         let _ = log_validation("[GAMEPLAY FAIL] Match started - game never initialized");
     }
@@ -300,13 +304,18 @@ pub fn write_gameplay_report() {
     if completed {
         let end_frame = COMPLETION_FRAME.load(Ordering::Relaxed);
         let alive = ALIVE_AT_END.load(Ordering::Relaxed);
-        let outcome = if alive == 1 { "winner decided" } else { "draw (all eliminated)" };
+        let outcome = if alive == 1 {
+            "winner decided"
+        } else {
+            "draw (all eliminated)"
+        };
         let _ = log_validation(&format!(
             "[GAMEPLAY PASS] Match completed - {} at frame {}",
             outcome, end_frame
         ));
     } else if started {
-        let _ = log_validation("[GAMEPLAY FAIL] Match completed - match started but never finished");
+        let _ =
+            log_validation("[GAMEPLAY FAIL] Match completed - match started but never finished");
     } else {
         let _ = log_validation("[GAMEPLAY FAIL] Match completed - match never started");
     }

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

@@ -413,11 +413,10 @@ unsafe extern "stdcall" fn draw_bungee_trail_impl(task_ptr: u32, style: u32, fil
         let seg_angle = *(seg_data.add(4 + i as usize * 8) as *const i32);
 
         // Include vertex if: first segment, or segment has nonzero angle, or fill mode
-        if (i == 0 || seg_angle != 0 || fill != 0)
-            && vert_count < MAX_VERTICES {
-                verts[vert_count] = [x, y, 0];
-                vert_count += 1;
-            }
+        if (i == 0 || seg_angle != 0 || fill != 0) && vert_count < MAX_VERTICES {
+            verts[vert_count] = [x, y, 0];
+            vert_count += 1;
+        }
 
         accumulated_angle = accumulated_angle.wrapping_add(seg_angle as u32);
 

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

@@ -7,8 +7,8 @@ use crate::hook;
 use crate::log_line;
 use openwa_core::address::va;
 use openwa_core::engine::game_info::GameInfo;
-use openwa_core::frontend::MapView;
 use openwa_core::engine::replay::{self, ReplayError, ReplayStream, ReplayTeamEntry};
+use openwa_core::frontend::MapView;
 use openwa_core::rebase::rb;
 use openwa_core::wa_alloc::{wa_free, wa_malloc};
 
@@ -48,10 +48,16 @@ unsafe fn wa_file_to_rust(file: *mut FILE) -> Option<ManuallyDrop<File>> {
         core::mem::transmute(rb(va::WA_GET_OSFHANDLE));
 
     let fd = fileno(file);
-    if fd < 0 { return None; }
+    if fd < 0 {
+        return None;
+    }
     let handle = get_osfhandle(fd);
-    if handle == -1 || handle == -2 { return None; }
-    Some(ManuallyDrop::new(File::from_raw_handle(handle as *mut core::ffi::c_void)))
+    if handle == -1 || handle == -2 {
+        return None;
+    }
+    Some(ManuallyDrop::new(File::from_raw_handle(
+        handle as *mut core::ffi::c_void,
+    )))
 }
 
 /// Load a WA string resource by ID (stdcall). Returns null-terminated C string.
@@ -71,10 +77,16 @@ static mut REPLAY_TIMESTAMP: u32 = 0;
 
 // ─── RAII cleanup guard (for wa_malloc'd payload) ───────────────────────────
 
-struct PayloadGuard { payload: *mut u8 }
+struct PayloadGuard {
+    payload: *mut u8,
+}
 impl Drop for PayloadGuard {
     fn drop(&mut self) {
-        unsafe { if !self.payload.is_null() { wa_free(self.payload); } }
+        unsafe {
+            if !self.payload.is_null() {
+                wa_free(self.payload);
+            }
+        }
     }
 }
 
@@ -96,7 +108,9 @@ unsafe extern "stdcall" fn hook_replay_loader(state: *mut GameInfo, mode: i32) -
 
 unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
     let artclass_counter = *(rb(va::G_ARTCLASS_COUNTER) as *const i32);
-    if artclass_counter >= 0x34 { return Err(ReplayError::ArtClassLimit); }
+    if artclass_counter >= 0x34 {
+        return Err(ReplayError::ArtClassLimit);
+    }
     (*gi).replay_active = 1;
     (*gi).replay_field_ef60 = 0;
 
@@ -113,22 +127,29 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
         }
     };
 
-    let mut file = File::open(&replay_path)
-        .map_err(|_| ReplayError::FileNotFound)?;
-    let file_size = file.metadata().map_err(|_| ReplayError::FileNotFound)?.len();
+    let mut file = File::open(&replay_path).map_err(|_| ReplayError::FileNotFound)?;
+    let file_size = file
+        .metadata()
+        .map_err(|_| ReplayError::FileNotFound)?
+        .len();
 
     // Helper: read exact bytes from file into a typed value
     fn read_u32(f: &mut File) -> Result<u32, ReplayError> {
         let mut buf = [0u8; 4];
-        f.read_exact(&mut buf).map_err(|_| ReplayError::InvalidFormat)?;
+        f.read_exact(&mut buf)
+            .map_err(|_| ReplayError::InvalidFormat)?;
         Ok(u32::from_le_bytes(buf))
     }
 
     // Header
     let header = read_u32(&mut file)?;
-    if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 { return Err(ReplayError::InvalidFormat); }
+    if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 {
+        return Err(ReplayError::InvalidFormat);
+    }
     let version = header >> 16;
-    if version == 0 || version > 20 { return Err(ReplayError::VersionTooNew); }
+    if version == 0 || version > 20 {
+        return Err(ReplayError::VersionTooNew);
+    }
 
     (*gi).replay_format_version = version;
     (*gi).replay_format_version_2 = version;
@@ -136,12 +157,17 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
 
     // First payload
     let payload_size = read_u32(&mut file)?;
-    if (payload_size as u64 + 8) > file_size { return Err(ReplayError::InvalidFormat); }
+    if (payload_size as u64 + 8) > file_size {
+        return Err(ReplayError::InvalidFormat);
+    }
     let payload = wa_malloc(payload_size);
-    if payload.is_null() { return Err(ReplayError::MallocFailure); }
+    if payload.is_null() {
+        return Err(ReplayError::MallocFailure);
+    }
     let mut guard = PayloadGuard { payload };
     let payload_slice = core::slice::from_raw_parts_mut(payload, payload_size as usize);
-    file.read_exact(payload_slice).map_err(|_| ReplayError::FileNotFound)?;
+    file.read_exact(payload_slice)
+        .map_err(|_| ReplayError::FileNotFound)?;
 
     let first_dword = *(payload as *const i32);
     (*gi).replay_map_type = first_dword;
@@ -156,24 +182,25 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
                 *(payload.add(8) as *const i32);
         } else if first_dword == -2 {
             let n = payload_size.saturating_sub(8) as usize;
-            if n > 0x20 { return Err(ReplayError::InvalidFormat); }
-            ptr::copy_nonoverlapping(
-                payload.add(8),
-                (*gi).replay_payload_extra.as_mut_ptr(),
-                n,
-            );
+            if n > 0x20 {
+                return Err(ReplayError::InvalidFormat);
+            }
+            ptr::copy_nonoverlapping(payload.add(8), (*gi).replay_payload_extra.as_mut_ptr(), n);
             // Null-terminate: write 0 at replay_map_type + payload_size offset
             // (the original uses base+0xDB1C+payload_size which spans into replay_payload_extra)
             *((gi as *mut u8).add(0xDB1C + payload_size as usize)) = 0;
         }
     }
-    wa_free(payload); guard.payload = ptr::null_mut();
+    wa_free(payload);
+    guard.payload = ptr::null_mut();
 
     // Clear global buffers
     ptr::write_bytes(rb(va::G_TEAM_HEADER_DATA) as *mut u8, 0, 0x5728);
     ptr::write_bytes(rb(va::G_TEAM_SECONDARY_DATA) as *mut u8, 0, 0xD9DC);
 
-    let _ = log_line(&format!("[Replay] Header: ver={version} payload={payload_size} sub={first_dword}"));
+    let _ = log_line(&format!(
+        "[Replay] Header: ver={version} payload={payload_size} sub={first_dword}"
+    ));
 
     if version == 1 {
         drop(file);
@@ -183,18 +210,24 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
     // ─── Version 2+: read second payload ─────────────────────────────────
 
     let second_size = read_u32(&mut file)?;
-    if (4u64 + 4 + payload_size as u64 + 4 + second_size as u64) > file_size { return Err(ReplayError::InvalidFormat); }
+    if (4u64 + 4 + payload_size as u64 + 4 + second_size as u64) > file_size {
+        return Err(ReplayError::InvalidFormat);
+    }
     let p2 = wa_malloc(second_size);
-    if p2.is_null() { return Err(ReplayError::MallocFailure); }
+    if p2.is_null() {
+        return Err(ReplayError::MallocFailure);
+    }
     guard.payload = p2;
     let p2_slice = core::slice::from_raw_parts_mut(p2, second_size as usize);
-    file.read_exact(p2_slice).map_err(|_| ReplayError::InvalidFormat)?;
+    file.read_exact(p2_slice)
+        .map_err(|_| ReplayError::InvalidFormat)?;
     drop(file); // Done reading — close replay file
 
     // Parse and write to globals
     let data = core::slice::from_raw_parts(p2, second_size as usize);
     let result = parse_and_write_v2plus(gi, data, version);
-    wa_free(p2); guard.payload = ptr::null_mut();
+    wa_free(p2);
+    guard.payload = ptr::null_mut();
 
     match result {
         Ok(()) => {
@@ -209,7 +242,9 @@ unsafe fn replay_loader_play(gi: *mut GameInfo) -> Result<(), ReplayError> {
             Ok(())
         }
         Err(e) => {
-            let _ = log_line(&format!("[Replay] Parse failed ({e:?}), falling back to original"));
+            let _ = log_line(&format!(
+                "[Replay] Parse failed ({e:?}), falling back to original"
+            ));
             delegate_to_original(gi)
         }
     }
@@ -220,22 +255,33 @@ unsafe fn parse_version1(gi: *mut GameInfo) -> Result<(), ReplayError> {
 }
 
 unsafe fn delegate_to_original(gi: *mut GameInfo) -> Result<(), ReplayError> {
-    let orig: unsafe extern "stdcall" fn(*mut GameInfo, i32) -> u32 = core::mem::transmute(REPLAY_LOADER_ORIG);
+    let orig: unsafe extern "stdcall" fn(*mut GameInfo, i32) -> u32 =
+        core::mem::transmute(REPLAY_LOADER_ORIG);
     let result = orig(gi, 1);
-    if result == 0 { Ok(()) } else { Err(ReplayError::FileNotFound) }
+    if result == 0 {
+        Ok(())
+    } else {
+        Err(ReplayError::FileNotFound)
+    }
 }
 
 // ─── Version 2+ parser that writes to globals ───────────────────────────────
 
 /// Helper: write byte to rebased global address.
 #[inline]
-unsafe fn wb(addr: u32, val: u8) { *(rb(addr) as *mut u8) = val; }
+unsafe fn wb(addr: u32, val: u8) {
+    *(rb(addr) as *mut u8) = val;
+}
 /// Helper: write u32 to rebased global address.
 #[inline]
-unsafe fn wd(addr: u32, val: u32) { *(rb(addr) as *mut u32) = val; }
+unsafe fn wd(addr: u32, val: u32) {
+    *(rb(addr) as *mut u32) = val;
+}
 
 unsafe fn parse_and_write_v2plus(
-    gi: *mut GameInfo, data: &[u8], version: u32,
+    gi: *mut GameInfo,
+    data: &[u8],
+    version: u32,
 ) -> Result<(), ReplayError> {
     let mut s = ReplayStream::new(data);
 
@@ -250,7 +296,9 @@ unsafe fn parse_and_write_v2plus(
     if version >= 10 {
         let sub_format = s.read_u16()?;
         wd(va::G_REPLAY_SUB_FORMAT, sub_format as u32);
-        if sub_format != 0 { return Err(ReplayError::VersionTooNew); }
+        if sub_format != 0 {
+            return Err(ReplayError::VersionTooNew);
+        }
 
         if version >= 12 {
             if version < 18 {
@@ -260,7 +308,8 @@ unsafe fn parse_and_write_v2plus(
                 let raw = s.read_u8_validated(0, 3)?;
                 if (2..=3).contains(&raw) {
                     wb(va::G_REPLAY_GAME_MODE, raw - 1);
-                    wb(va::G_REPLAY_VER_FLAG_A, 1); wb(va::G_REPLAY_VER_FLAG_B, 1);
+                    wb(va::G_REPLAY_VER_FLAG_A, 1);
+                    wb(va::G_REPLAY_VER_FLAG_B, 1);
                 } else {
                     wb(va::G_REPLAY_VER_FLAG_A, (raw != 0) as u8);
                     wb(va::G_REPLAY_GAME_MODE, 0);
@@ -284,7 +333,9 @@ unsafe fn parse_and_write_v2plus(
             let obs_data: [u32; 4] = [team_id, 0, obs_type as u32, 0];
             // RegisterObserver: usercall(ESI=0x88C35C) + stdcall(1 param = &data). RET 0x4.
             call_register_observer(
-                rb(va::G_OBSERVER_ARRAY), obs_data.as_ptr() as u32, rb(va::REPLAY_REGISTER_OBSERVER),
+                rb(va::G_OBSERVER_ARRAY),
+                obs_data.as_ptr() as u32,
+                rb(va::REPLAY_REGISTER_OBSERVER),
             );
             if obs_type == 0 {
                 // The terminating entry's team_id is the replay timestamp (time_t)
@@ -296,7 +347,9 @@ unsafe fn parse_and_write_v2plus(
 
     let game_version_id = s.read_i32()?;
     wd(va::G_REPLAY_VERSION_ID, game_version_id as u32);
-    if (game_version_id.wrapping_add(4) as u32) > 0x1F8 { return Err(ReplayError::VersionTooNew); }
+    if (game_version_id.wrapping_add(4) as u32) > 0x1F8 {
+        return Err(ReplayError::VersionTooNew);
+    }
     let use_fixed_names = game_version_id < 10;
 
     // ── Scheme presence ──────────────────────────────────────────────────
@@ -331,7 +384,9 @@ unsafe fn parse_and_write_v2plus(
         // SCHM magic + version
         let magic = s.read_u32()?;
         let scheme_version = s.read_u8()?;
-        if magic != 0x4D484353 { return Err(ReplayError::InvalidFormat); }
+        if magic != 0x4D484353 {
+            return Err(ReplayError::InvalidFormat);
+        }
 
         let scheme_data_size = match scheme_version {
             1 => 0xD8_usize,
@@ -343,7 +398,8 @@ unsafe fn parse_and_write_v2plus(
                 // Copy defaults first for v3
                 ptr::copy_nonoverlapping(
                     rb(va::SCHEME_V3_DEFAULTS) as *const u8,
-                    rb(va::G_SCHEME_V3_DATA) as *mut u8, 0x6E,
+                    rb(va::G_SCHEME_V3_DATA) as *mut u8,
+                    0x6E,
                 );
                 (scheme_size_indicator as usize) - 5
             }
@@ -352,7 +408,11 @@ unsafe fn parse_and_write_v2plus(
 
         // Copy scheme data from stream to global 0x88DAE0
         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);
+        ptr::copy_nonoverlapping(
+            scheme_slice.as_ptr(),
+            rb(va::G_SCHEME_DATA) as *mut u8,
+            scheme_data_size,
+        );
 
         let header_val = *(rb(va::G_SCHEME_HEADER) as *const i8);
 
@@ -366,7 +426,8 @@ unsafe fn parse_and_write_v2plus(
             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,
+                    rb(va::G_SCHEME_V3_DATA) as *mut u8,
+                    0x6E,
                 );
             }
         }
@@ -376,7 +437,9 @@ unsafe fn parse_and_write_v2plus(
             let validate: unsafe extern "cdecl" fn() -> i32 =
                 core::mem::transmute(rb(va::SCHEME_VALIDATE_EXTENDED));
             let r = validate();
-            if r != 0 { return Err(ReplayError::InvalidFormat); }
+            if r != 0 {
+                return Err(ReplayError::InvalidFormat);
+            }
         }
 
         // Random seed: the stream value REPLACES the current seed.
@@ -415,22 +478,36 @@ unsafe fn parse_and_write_v2plus(
         let base = va::G_PLAYER_ARRAY + 0x74 + i * 0x78; // player[i].flag
         let flag = s.read_u8()?;
         wb(base, flag);
-        if flag == 0 { continue; }
+        if flag == 0 {
+            continue;
+        }
 
         // NOTE: original checks if i == host_player_index here (sets a local flag, unused)
         player_count += 1;
 
         let mut name = [0u8; 0x11];
         s.read_prefixed_string(&mut name)?;
-        ptr::copy_nonoverlapping(name.as_ptr(), rb(va::G_PLAYER_ARRAY + i * 0x78) as *mut u8, 0x11);
+        ptr::copy_nonoverlapping(
+            name.as_ptr(),
+            rb(va::G_PLAYER_ARRAY + i * 0x78) as *mut u8,
+            0x11,
+        );
 
         let mut display = [0u8; 0x31];
         s.read_prefixed_string(&mut display)?;
-        ptr::copy_nonoverlapping(display.as_ptr(), rb(va::G_PLAYER_ARRAY + 0x11 + i * 0x78) as *mut u8, 0x31);
+        ptr::copy_nonoverlapping(
+            display.as_ptr(),
+            rb(va::G_PLAYER_ARRAY + 0x11 + i * 0x78) as *mut u8,
+            0x31,
+        );
 
         let mut config = [0u8; 0x29];
         s.read_prefixed_string(&mut config)?;
-        ptr::copy_nonoverlapping(config.as_ptr(), rb(va::G_PLAYER_ARRAY + 0x42 + i * 0x78) as *mut u8, 0x29);
+        ptr::copy_nonoverlapping(
+            config.as_ptr(),
+            rb(va::G_PLAYER_ARRAY + 0x42 + i * 0x78) as *mut u8,
+            0x29,
+        );
 
         let u16_val = s.read_u16()?;
         // Ghidra shows (&DAT[i*0x3C]) with u16 elements → byte offset = i*0x3C*2 = i*0x78
@@ -460,11 +537,15 @@ unsafe fn parse_and_write_v2plus(
         let team = &mut *teams.add(team_idx);
         let team_flag = s.read_u8()?;
         team.flag = team_flag;
-        if team_flag == 0 { continue; }
+        if team_flag == 0 {
+            continue;
+        }
         team_count += 1;
-    
+
         let team_type = s.read_u8()? as i8;
-        if !replay::validate_team_type(team_type) { return Err(ReplayError::InvalidFormat); }
+        if !replay::validate_team_type(team_type) {
+            return Err(ReplayError::InvalidFormat);
+        }
         team.team_type = team_type as u8;
         team.alliance = s.read_u8_validated(0, 5)?;
         team.unknown_02 = s.read_u8()?;
@@ -496,7 +577,9 @@ unsafe fn parse_and_write_v2plus(
         s.read_prefixed_string(&mut team.config_name)?;
 
         let worm_count = s.read_u8()?;
-        if worm_count == 0 || worm_count > 8 { return Err(ReplayError::InvalidFormat); }
+        if worm_count == 0 || worm_count > 8 {
+            return Err(ReplayError::InvalidFormat);
+        }
         team.worm_count = worm_count;
         team.color = s.read_u8()?;
         team.flag2 = s.read_u8()?;
@@ -515,7 +598,9 @@ unsafe fn parse_and_write_v2plus(
         ptr::copy_nonoverlapping(w4.as_ptr(), team.weapons.as_mut_ptr().add(0x954), 0x300);
     }
 
-    if team_count == 0 { return Err(ReplayError::InvalidFormat); }
+    if team_count == 0 {
+        return Err(ReplayError::InvalidFormat);
+    }
 
     wb(va::G_TEAM_COUNT, team_count);
 
@@ -538,7 +623,10 @@ unsafe fn parse_and_write_v2plus(
     if map_seed != 0 {
         // Per-team weapon config reads from stream — not yet implemented in Rust.
         // Fall back to the original parser which handles this from scratch.
-        let _ = log_line(&format!("[Replay] Non-zero map_seed (0x{:04X}), delegating to original", map_seed));
+        let _ = log_line(&format!(
+            "[Replay] Non-zero map_seed (0x{:04X}), delegating to original",
+            map_seed
+        ));
         return Err(ReplayError::InvalidFormat); // triggers delegate_to_original
     }
 
@@ -554,8 +642,8 @@ unsafe fn parse_and_write_v2plus(
     srand(current_seed);
     let r1 = rand_fn() as u32;
     let r2 = rand_fn() as u32;
-    wd(va::G_RANDOM_SEED, r2 + (r1 << 16));       // new seed
-    wd(va::G_SAVED_RANDOM_SEED, current_seed);     // save old seed
+    wd(va::G_RANDOM_SEED, r2 + (r1 << 16)); // new seed
+    wd(va::G_SAVED_RANDOM_SEED, current_seed); // save old seed
 
     let ver = *(rb(va::G_REPLAY_VERSION_ID) as *const i32);
     if ver != 0x22 && !(0x29..=0x2A).contains(&ver) && ver < 0x2D {
@@ -610,8 +698,6 @@ unsafe fn parse_and_write_v2plus(
 
 // ─── Log output formatting ──────────────────────────────────────────────────
 
-
-
 /// Write the /getlog replay header to the log file.
 unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(), ReplayError> {
     use std::io::Write as IoWrite;
@@ -635,9 +721,15 @@ unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(
         if !tm.is_null() {
             let tm = &*tm;
             let mut s = heapless::String::<128>::new();
-            let _ = writeln!(s,
+            let _ = writeln!(
+                s,
                 "Game Started at {:04}-{:02}-{:02} {:02}:{:02}:{:02} GMT",
-                tm[5] + 1900, tm[4] + 1, tm[3], tm[2], tm[1], tm[0]
+                tm[5] + 1900,
+                tm[4] + 1,
+                tm[3],
+                tm[2],
+                tm[1],
+                tm[0]
             );
             let _ = log_file.write_all(s.as_bytes());
         }
@@ -657,7 +749,7 @@ unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(
             -4 => rb(0x650EAC) as *const u8, // "1.0"
             -2 => rb(0x650EB0) as *const u8, // "3.0"
             -1 => rb(0x650EB4) as *const u8, // "3.5 Beta 1"
-            _  => wa_load_string(0x0F),       // "Unknown"
+            _ => wa_load_string(0x0F),       // "Unknown"
         }
     } else {
         let table = rb(va::VERSION_STRING_TABLE) as *const u32;
@@ -684,7 +776,7 @@ unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(
     // ── "Exported with Version" line ─────────────────────────────────────
     {
         let label_exported = wa_load_string(0x6E9); // "Exported with Version"
-        // Current WA version from version table: 0x699814[DAT_00697702]
+                                                    // Current WA version from version table: 0x699814[DAT_00697702]
         let ver_byte = *(rb(va::G_VERSION_BYTE) as *const u8) as u32;
         // "3.8.1" literal at 0x641C60 + suffix from version table
         let ver_literal = rb(va::STR_VERSION_381) as *const u8; // "3.8.1"
@@ -699,7 +791,6 @@ unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(
         let _ = log_file.write_all(s.as_bytes());
     }
 
-
     // ── Team listing ─────────────────────────────────────────────────────
     // For each team: "Color: "TeamName" [CPU X.XX]\n" or similar
 
@@ -718,24 +809,36 @@ unsafe fn write_replay_log(gi: *const GameInfo, log_file: &mut File) -> Result<(
     let mut max_name_len = 0usize;
     for slot in 0..6usize {
         let team = &*teams.add(slot);
-        if team.flag == 0 { continue; }
+        if team.flag == 0 {
+            continue;
+        }
         let ci = team.alliance as usize;
         if ci < 6 {
             let len = c_strlen(color_names[ci]);
-            if len > max_color_len { max_color_len = len; }
+            if len > max_color_len {
+                max_color_len = len;
+            }
         }
         let name_len = c_strlen(team.config_abbrev.as_ptr());
-        if name_len > max_name_len { max_name_len = name_len; }
+        if name_len > max_name_len {
+            max_name_len = name_len;
+        }
     }
 
     for slot in 0..6usize {
         let team = &*teams.add(slot);
-        if team.flag == 0 { continue; }
+        if team.flag == 0 {
+            continue;
+        }
 
         let team_type = team.team_type as i8;
         let color_idx = team.alliance as usize;
 
-        let color = if color_idx < 6 { color_names[color_idx] } else { color_names[0] };
+        let color = if color_idx < 6 {
+            color_names[color_idx]
+        } else {
+            color_names[0]
+        };
         let clen = c_strlen(color);
 
         // The displayed team name comes from the config_abbrev field
@@ -798,7 +901,9 @@ unsafe fn push_cstr<const N: usize>(s: &mut heapless::String<N>, cstr: *const u8
 /// Length of a null-terminated C string.
 unsafe fn c_strlen(s: *const u8) -> usize {
     let mut len = 0;
-    while *s.add(len) != 0 { len += 1; }
+    while *s.add(len) != 0 {
+        len += 1;
+    }
     len
 }
 
@@ -808,8 +913,8 @@ unsafe fn c_strlen(s: *const u8) -> usize {
 #[unsafe(naked)]
 unsafe extern "cdecl" fn call_usercall_eax(_eax_val: *mut GameInfo, _func: u32) {
     core::arch::naked_asm!(
-        "mov eax, [esp+4]",      // eax_val
-        "mov ecx, [esp+8]",      // func_addr
+        "mov eax, [esp+4]", // eax_val
+        "mov ecx, [esp+8]", // func_addr
         "call ecx",
         "ret",
     );
@@ -821,8 +926,8 @@ unsafe extern "cdecl" fn call_usercall_esi(_esi_val: u32, _func: u32) {
     core::arch::naked_asm!(
         "push esi",
         "push edi",
-        "mov esi, [esp+12]",     // esi_val
-        "mov eax, [esp+16]",     // func_addr
+        "mov esi, [esp+12]", // esi_val
+        "mov eax, [esp+16]", // func_addr
         "call eax",
         "pop edi",
         "pop esi",
@@ -833,16 +938,14 @@ unsafe extern "cdecl" fn call_usercall_esi(_esi_val: u32, _func: u32) {
 /// Bridge for RegisterObserver: usercall(ESI=array) + stdcall(1 param=data_ptr).
 /// cdecl(esi_val, data_ptr, func_addr).
 #[unsafe(naked)]
-unsafe extern "cdecl" fn call_register_observer(
-    _esi_val: u32, _data_ptr: u32, _func: u32,
-) {
+unsafe extern "cdecl" fn call_register_observer(_esi_val: u32, _data_ptr: u32, _func: u32) {
     core::arch::naked_asm!(
         "push esi",
         "push edi",
-        "mov esi, [esp+12]",     // esi_val (0x88C35C rebased)
-        "push [esp+16]",         // data_ptr → stdcall param
-        "mov eax, [esp+24]",     // func_addr (shifted by push)
-        "call eax",              // stdcall cleans 1 param (4 bytes)
+        "mov esi, [esp+12]", // esi_val (0x88C35C rebased)
+        "push [esp+16]",     // data_ptr → stdcall param
+        "mov eax, [esp+24]", // func_addr (shifted by push)
+        "call eax",          // stdcall cleans 1 param (4 bytes)
         "pop edi",
         "pop esi",
         "ret",
@@ -860,7 +963,12 @@ unsafe fn call_process_scheme_defaults(gi: *mut GameInfo, func: u32) {
 
 unsafe extern "stdcall" fn hook_parse_replay_position(input: *const u8) -> i32 {
     let mut len = 0usize;
-    while *input.add(len) != 0 { len += 1; if len > 256 { break; } }
+    while *input.add(len) != 0 {
+        len += 1;
+        if len > 256 {
+            break;
+        }
+    }
     let slice = core::slice::from_raw_parts(input, len + 1);
     replay::parse_replay_position(slice)
 }
@@ -869,8 +977,16 @@ unsafe extern "stdcall" fn hook_parse_replay_position(input: *const u8) -> i32 {
 
 pub fn install() -> Result<(), String> {
     unsafe {
-        REPLAY_LOADER_ORIG = hook::install("ReplayLoader", va::REPLAY_LOADER, hook_replay_loader as *const ())? as *const ();
-        PARSE_POSITION_ORIG = hook::install("ParseReplayPosition", va::PARSE_REPLAY_POSITION, hook_parse_replay_position as *const ())? as *const ();
+        REPLAY_LOADER_ORIG = hook::install(
+            "ReplayLoader",
+            va::REPLAY_LOADER,
+            hook_replay_loader as *const (),
+        )? as *const ();
+        PARSE_POSITION_ORIG = hook::install(
+            "ParseReplayPosition",
+            va::PARSE_REPLAY_POSITION,
+            hook_parse_replay_position as *const (),
+        )? as *const ();
     }
     Ok(())
 }

crates/openwa-wormkit/src/replacements/task/cloud.rs

@@ -69,7 +69,8 @@ unsafe extern "thiscall" fn cloud_handle_message(
             if (*ddgame).render_phase == 5 {
                 // Compute parallax X offset: (vel_x + wind * 10) * parallax_scale
                 let scroll_speed = (*this).vel_x.0 + (*this).wind_accel.0 * 10;
-                let parallax_x = ((scroll_speed as i64 * (*ddgame).parallax_scale as i64) >> 16) as i32;
+                let parallax_x =
+                    ((scroll_speed as i64 * (*ddgame).parallax_scale as i64) >> 16) as i32;
                 let x = parallax_x + (*this).pos_x.0;
 
                 let rq = &mut *(*ddgame).render_queue;

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

@@ -98,7 +98,10 @@ fn is_weapon_category_a(weapon: Weapon) -> bool {
 /// FUN_00565920: weapon category B — fire/napalm weapons.
 fn is_weapon_category_b(weapon: Weapon) -> bool {
     use Weapon::*;
-    matches!(weapon, NapalmStrike | FlameThrower | PetrolBomb | SheepStrike)
+    matches!(
+        weapon,
+        NapalmStrike | FlameThrower | PetrolBomb | SheepStrike
+    )
 }
 
 // ── Main implementation ─────────────────────────────────────
@@ -152,7 +155,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
     let special_subtype = (*entry).special_subtype;
     let fire_method = (*entry).fire_method;
 
-    use openwa_core::game::weapon::{FireType, FireMethod};
+    use openwa_core::game::weapon::{FireMethod, FireType};
 
     // ── 3. Spawn offset calculation ─────────────────────────
     let scale = w.landscape_scale;
@@ -243,11 +246,7 @@ unsafe extern "cdecl" fn weapon_release_impl(
     write_u32(&mut msg_buf, 0x0C, w.shot_data_2);
     write_u32(&mut msg_buf, 0x10, w.fire_sync_frame_1 as u32);
     write_u32(&mut msg_buf, 0x14, w.fire_sync_frame_2 as u32);
-    write_u32(
-        &mut msg_buf,
-        0x18,
-        if w._unknown_2cc != 0 { 1 } else { 0 },
-    );
+    write_u32(&mut msg_buf, 0x18, if w._unknown_2cc != 0 { 1 } else { 0 });
     write_u32(&mut msg_buf, 0x1C, weapon as u32);
 
     let team = weapon::lookup_turn_game(worm);
@@ -292,47 +291,63 @@ unsafe extern "cdecl" fn weapon_release_impl(
     let entry = w.active_weapon_entry;
 
     match FireType::try_from((*entry).fire_type) {
-        Ok(FireType::Projectile) => {
-            match (*entry).special_subtype {
-                1 => {
-                    if w.sound_handle == 0 {
-                        sound::play_worm_sound(worm, SoundId(0x1004E), Fixed::ONE);
-                    }
-                    do_effect = true;
-                    effect_state = 0x73;
-                }
-                2 => {
-                    sound::play_sound_local(task, KnownSoundId::ThrowRelease, 3, Fixed::ONE, Fixed::ONE);
-                    sound::stop_worm_sound(worm);
+        Ok(FireType::Projectile) => match (*entry).special_subtype {
+            1 => {
+                if w.sound_handle == 0 {
+                    sound::play_worm_sound(worm, SoundId(0x1004E), Fixed::ONE);
                 }
-                3 | 7 | 0xB | 0xC => {
-                    sound::play_sound_local(task, KnownSoundId::RocketRelease, 3, Fixed::ONE, Fixed::ONE);
-                    sound::stop_worm_sound(worm);
-                }
-                4 => {
-                    if w.sound_handle == 0 {
-                        sound::play_worm_sound(worm, SoundId(0x1004F), Fixed::ONE);
-                    }
-                    do_effect = true;
-                    effect_state = 0x73;
-                }
-                5 => {
-                    sound::play_sound_local(task, KnownSoundId::ShotgunFire, 3, Fixed::ONE, Fixed::ONE);
-                    do_effect = true;
-                    effect_state = 0x75;
-                }
-                6 => {
-                    sound::play_sound_local(task, KnownSoundId::HandgunFire, 3, Fixed::ONE, Fixed::ONE);
-                    do_effect = true;
-                    effect_state = 0x73;
-                }
-                10 => {
-                    sound::play_sound_local(task, KnownSoundId::LongbowRelease, 3, Fixed::ONE, Fixed::ONE);
-                    sound::stop_worm_sound(worm);
+                do_effect = true;
+                effect_state = 0x73;
+            }
+            2 => {
+                sound::play_sound_local(
+                    task,
+                    KnownSoundId::ThrowRelease,
+                    3,
+                    Fixed::ONE,
+                    Fixed::ONE,
+                );
+                sound::stop_worm_sound(worm);
+            }
+            3 | 7 | 0xB | 0xC => {
+                sound::play_sound_local(
+                    task,
+                    KnownSoundId::RocketRelease,
+                    3,
+                    Fixed::ONE,
+                    Fixed::ONE,
+                );
+                sound::stop_worm_sound(worm);
+            }
+            4 => {
+                if w.sound_handle == 0 {
+                    sound::play_worm_sound(worm, SoundId(0x1004F), Fixed::ONE);
                 }
-                _ => {}
+                do_effect = true;
+                effect_state = 0x73;
             }
-        }
+            5 => {
+                sound::play_sound_local(task, KnownSoundId::ShotgunFire, 3, Fixed::ONE, Fixed::ONE);
+                do_effect = true;
+                effect_state = 0x75;
+            }
+            6 => {
+                sound::play_sound_local(task, KnownSoundId::HandgunFire, 3, Fixed::ONE, Fixed::ONE);
+                do_effect = true;
+                effect_state = 0x73;
+            }
+            10 => {
+                sound::play_sound_local(
+                    task,
+                    KnownSoundId::LongbowRelease,
+                    3,
+                    Fixed::ONE,
+                    Fixed::ONE,
+                );
+                sound::stop_worm_sound(worm);
+            }
+            _ => {}
+        },
         Ok(FireType::Rope) => {
             if w._unknown_2cc == 0 || w._unknown_2c8 == 1 {
                 let team_sound_raw = (*w.ddgame()).team_sound_id(team_id);
@@ -345,19 +360,41 @@ unsafe extern "cdecl" fn weapon_release_impl(
             match S::try_from((*entry).special_subtype) {
                 Ok(S::BaseballBat) => {
                     sound::play_sound_local(
-                        task, KnownSoundId::BaseballBatRelease, 3, Fixed::ONE, Fixed::ONE,
+                        task,
+                        KnownSoundId::BaseballBatRelease,
+                        3,
+                        Fixed::ONE,
+                        Fixed::ONE,
                     );
                 }
                 Ok(S::DragonBall) => {
-                    sound::play_sound_local(task, SoundId((*entry).fire_method as u32), 3, Fixed::ONE, Fixed::ONE);
+                    sound::play_sound_local(
+                        task,
+                        SoundId((*entry).fire_method as u32),
+                        3,
+                        Fixed::ONE,
+                        Fixed::ONE,
+                    );
                 }
                 Ok(S::Kamikaze) => {
                     // Sound ID from fire_params.spread (polymorphic use of field)
-                    sound::play_sound_local(task, SoundId((*entry).fire_params.spread as u32), 3, Fixed::ONE, Fixed::ONE);
+                    sound::play_sound_local(
+                        task,
+                        SoundId((*entry).fire_params.spread as u32),
+                        3,
+                        Fixed::ONE,
+                        Fixed::ONE,
+                    );
                 }
                 Ok(S::Teleport) => {
                     if w._unknown_208 == 0 {
-                        sound::play_sound_local(task, KnownSoundId::Teleport, 3, Fixed::ONE, Fixed::ONE);
+                        sound::play_sound_local(
+                            task,
+                            KnownSoundId::Teleport,
+                            3,
+                            Fixed::ONE,
+                            Fixed::ONE,
+                        );
                     }
                 }
                 Ok(S::Blowtorch) => {
@@ -390,8 +427,16 @@ unsafe extern "cdecl" fn weapon_release_impl(
         let state_flag = facing_flag + effect_state;
 
         spawn_effect(
-            worm, 0x80000, speed_x, speed_y, rng_scaled, rng1_offset, palette, state_flag,
-            Fixed(0xA0000), Fixed(0x1999),
+            worm,
+            0x80000,
+            speed_x,
+            speed_y,
+            rng_scaled,
+            rng1_offset,
+            palette,
+            state_flag,
+            Fixed(0xA0000),
+            Fixed(0x1999),
         );
     }
 
@@ -454,9 +499,8 @@ pub(crate) unsafe fn spawn_effect(
     let entity = table.lookup(0, 0x1A);
     if !entity.is_null() {
         let vtable = *(entity as *const *const usize);
-        let handle_msg: unsafe extern "thiscall" fn(
-            *mut u8, *mut u8, u32, u32, *const u8,
-        ) = core::mem::transmute(*vtable.add(2));
+        let handle_msg: unsafe extern "thiscall" fn(*mut u8, *mut u8, u32, u32, *const u8) =
+            core::mem::transmute(*vtable.add(2));
         handle_msg(
             entity as *mut u8,
             worm as *mut u8,

crates/openwa-wormkit/src/snapshot.rs

@@ -60,19 +60,23 @@ pub unsafe fn capture() -> String {
     // ── Team blocks + worm entries ──
     let team_count = (*ddgame).team_arena.team_count as usize;
     let _ = writeln!(out, "[Teams] count={}", team_count);
-    let arena = openwa_core::engine::ddgame::TeamArenaRef::from_ptr(
-        &raw mut (*ddgame).team_arena,
-    );
+    let arena = openwa_core::engine::ddgame::TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
     let blocks = arena.blocks();
     for t in 0..team_count {
         let header = arena.team_header(t);
-        let name = core::ffi::CStr::from_ptr(header.team_name.as_ptr() as *const _)
-            .to_string_lossy();
+        let name =
+            core::ffi::CStr::from_ptr(header.team_name.as_ptr() as *const _).to_string_lossy();
         let _ = writeln!(out, "\n  [Team {}] \"{}\"", t, name);
-        let _ = writeln!(out, "    eliminated={} alliance={} worm_count={} active_worm={}",
-            header.eliminated, header.alliance, header.worm_count, header.active_worm);
-        let _ = writeln!(out, "    weapon_alliance={} turn_action_flags=0x{:08X}",
-            header.weapon_alliance, header.turn_action_flags);
+        let _ = writeln!(
+            out,
+            "    eliminated={} alliance={} worm_count={} active_worm={}",
+            header.eliminated, header.alliance, header.worm_count, header.active_worm
+        );
+        let _ = writeln!(
+            out,
+            "    weapon_alliance={} turn_action_flags=0x{:08X}",
+            header.weapon_alliance, header.turn_action_flags
+        );
 
         // Worms are in block[t+1].worms[0..worm_count] (1-indexed blocks)
         let worm_count = header.worm_count.max(0) as usize;
@@ -107,8 +111,11 @@ pub unsafe fn capture() -> String {
         }
         root = parent;
     }
-    let _ = writeln!(out, "[Entities] root vt=0x{:08X}",
-        (*(root as *const u32)).wrapping_sub(delta));
+    let _ = writeln!(
+        out,
+        "[Entities] root vt=0x{:08X}",
+        (*(root as *const u32)).wrapping_sub(delta)
+    );
 
     let iter = CTaskBfsIter::new(root);
 
@@ -150,7 +157,8 @@ pub unsafe fn capture() -> String {
                 let class = vtable_name(vt);
                 if class != "Unknown" {
                     if let Some(fields) = openwa_core::registry::struct_fields_for(class) {
-                        let _ = write_registry_fields(&mut out, task as *const u8, fields, delta, 2);
+                        let _ =
+                            write_registry_fields(&mut out, task as *const u8, fields, delta, 2);
                     } else {
                         let _ = write_raw_region(&mut out, task as *const u8, 0x100, 2);
                     }
@@ -187,7 +195,11 @@ unsafe fn write_registry_fields(
     let pad = "  ".repeat(indent);
     for field in fields.fields {
         let addr = base as u32 + field.offset;
-        write!(w, "{}+0x{:04X}  {:<16} [{:>2}]  ", pad, field.offset, field.name, field.size)?;
+        write!(
+            w,
+            "{}+0x{:04X}  {:<16} [{:>2}]  ",
+            pad, field.offset, field.name, field.size
+        )?;
         if openwa_core::mem::can_read(addr, field.size) {
             let ptr = base.add(field.offset as usize);
             let data = core::slice::from_raw_parts(ptr, field.size as usize);

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

@@ -109,14 +109,13 @@ fn validate_addresses(result: &mut ValidationResult) {
     let _ = log_validation("--- Address Validation ---");
 
     // Auto-discover all registered vtables from the address registry
-    let vtables: Vec<(&str, u32)> = openwa_core::registry::entries_by_kind(
-        openwa_core::registry::AddrKind::Vtable,
-    )
-    .map(|e| {
-        let name = e.class_name.map_or(e.name, |c| c);
-        (name, e.va)
-    })
-    .collect();
+    let vtables: Vec<(&str, u32)> =
+        openwa_core::registry::entries_by_kind(openwa_core::registry::AddrKind::Vtable)
+            .map(|e| {
+                let name = e.class_name.map_or(e.name, |c| c);
+                (name, e.va)
+            })
+            .collect();
 
     let _ = log_validation("");
     let _ = log_validation(&format!(
@@ -287,7 +286,11 @@ fn validate_typed_vtable_slots(result: &mut ValidationResult) {
                     &format!(
                         "0x{:08X} {}",
                         actual,
-                        if in_text { "in .text" } else { "NOT in .text — hooked or corrupt?" }
+                        if in_text {
+                            "in .text"
+                        } else {
+                            "NOT in .text — hooked or corrupt?"
+                        }
                     ),
                 );
             }
@@ -1010,8 +1013,7 @@ fn dump_entity_census() {
         groups.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
 
         for (vt_ghidra, ptrs) in &groups {
-            let name = openwa_core::registry::vtable_class_name(*vt_ghidra)
-                .unwrap_or("UNKNOWN");
+            let name = openwa_core::registry::vtable_class_name(*vt_ghidra).unwrap_or("UNKNOWN");
             let _ = log_validation(&format!(
                 "  {:>3}x  {:<20}  (vtable 0x{:08X})",
                 ptrs.len(),