refactor: rename TeamArenaState to TeamArena, use raw pointers for soundness

- TeamArenaState → TeamArena; accessor methods now take *mut/*const Self
instead of returning &mut from &self (unsound aliasing)
- Move unrelated DDGame sub-structs out of team_arena.rs:
CoordEntry/CoordList → engine/coord.rs,
RenderEntry → render/mod.rs,
SoundQueueEntry → audio/sound_queue.rs

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

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

@@ -4,6 +4,7 @@ pub mod known_sound_id;
 pub mod music;
 pub mod sound_id;
 pub mod sound_ops;
+pub mod sound_queue;
 pub mod speech;
 pub mod speech_ops;
 pub mod wav_player;
@@ -20,4 +21,5 @@ pub use dssound::{ChannelDescriptor, DSSound, DSSoundVtable};
 pub use known_sound_id::KnownSoundId;
 pub use music::{Music, MusicVtable, StreamingAudio};
 pub use sound_id::SoundId;
+pub use sound_queue::SoundQueueEntry;
 pub use speech::{SpeechLineId, SpeechLineTableEntry, SpeechSlotTable, SPEECH_LINE_TABLE_COUNT};

crates/openwa-core/src/audio/sound_ops.rs

@@ -13,8 +13,9 @@
 //! - DispatchGlobalSound (0x526270)
 //! - PlaySoundPooled_Direct (0x546B50)
 
+use crate::audio::SoundQueueEntry;
 use crate::audio::{play_sound, play_sound_pooled, SoundId};
-use crate::engine::{DDGame, DDGameWrapper, SoundQueueEntry};
+use crate::engine::{DDGame, DDGameWrapper};
 use crate::fixed::Fixed;
 use crate::task::worm::CTaskWorm;
 use crate::task::{CGameTask, CTask, SoundEmitter};

crates/openwa-core/src/audio/sound_queue.rs

@@ -0,0 +1,33 @@
+// ============================================================
+// Sound queue entry — 16 entries at DDGame + 0x7F00
+// ============================================================
+
+/// Sound queue entry (0x24 = 36 bytes, stride between consecutive entries).
+///
+/// DDGame maintains a 16-slot sound queue at offset 0x7F00. PlaySoundGlobal
+/// appends entries; PlaySoundLocal additionally marks entries as local and
+/// stores position via the task's secondary vtable.
+#[repr(C)]
+pub struct SoundQueueEntry {
+    /// Sound effect ID (SoundId enum value).
+    pub sound_id: u32,
+    /// Flags / priority (e.g. 3=weapon, 7=explosion).
+    pub flags: u32,
+    /// Volume (Fixed-point, 0x10000 = 1.0).
+    pub volume: u32,
+    /// Pitch (Fixed-point, 0x10000 = 1.0).
+    pub pitch: u32,
+    /// Reserved, always 0.
+    pub reserved: u32,
+    /// 0 = global, 1 = local (has position tracking).
+    pub is_local: u8,
+    pub _pad: [u8; 3],
+    /// Position X (filled by secondary vtable GetPosition for local sounds).
+    pub pos_x: u32,
+    /// Position Y (filled by secondary vtable GetPosition for local sounds).
+    pub pos_y: u32,
+    /// Pointer to task's secondary vtable (at task+0xE8) for position updates.
+    pub secondary_vtable: u32,
+}
+
+const _: () = assert!(core::mem::size_of::<SoundQueueEntry>() == 0x24);

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

@@ -0,0 +1,49 @@
+// ============================================================
+// Coordinate types — DDGame sub-structs for screen and terrain coords
+// ============================================================
+
+/// Coordinate entry used in DDGame screen coordinate tables (stride 0x10).
+///
+/// InitFields zeroes x and y; at runtime they contain fixed-point screen
+/// coordinates used for camera tracking and rendering regions.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CoordEntry {
+    pub x: i32,
+    pub y: i32,
+    pub _unknown: [u8; 8],
+}
+
+const _: () = assert!(core::mem::size_of::<CoordEntry>() == 0x10);
+
+// ============================================================
+// CoordList — dynamic array of packed terrain coordinates
+// ============================================================
+
+/// Packed terrain coordinate entry (8 bytes).
+///
+/// `coord` packs x and y as `x * 0x10000 + y` (fixed-point).
+/// `flag` is always 1 for populated entries.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CoordListEntry {
+    pub coord: u32,
+    pub flag: u32,
+}
+const _: () = assert!(core::mem::size_of::<CoordListEntry>() == 8);
+
+/// Dynamic coordinate array header (12 bytes).
+///
+/// Allocated at DDGame+0x50C during `init_graphics_and_resources`.
+/// Data buffer is a separate allocation of `capacity * 8` bytes.
+/// Used for terrain coordinate lookups (spawning, aiming, collision).
+#[repr(C)]
+pub struct CoordList {
+    /// Number of entries currently stored.
+    pub count: u32,
+    /// Maximum number of entries (600).
+    pub capacity: u32,
+    /// Pointer to the data buffer (`capacity * sizeof(CoordListEntry)` bytes).
+    pub data: *mut CoordListEntry,
+}
+const _: () = assert!(core::mem::size_of::<CoordList>() == 12);

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

@@ -2,19 +2,19 @@ use crate::audio::active_sound::ActiveSoundTable;
 use crate::audio::dssound::DSSound;
 use crate::audio::music::Music;
 use crate::audio::speech::SpeechSlotTable;
+use crate::audio::SoundQueueEntry;
 use crate::bitgrid::{CollisionBitGrid, DisplayBitGrid};
 use crate::display::dd_display::DDDisplay;
 use crate::display::palette::Palette;
 use crate::engine::game_info::GameInfo;
-use crate::engine::{
-    CoordEntry, CoordList, RenderEntry, SoundQueueEntry, TeamArenaState, TeamIndexMap,
-};
+use crate::engine::{CoordEntry, CoordList, TeamArena, TeamIndexMap};
 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::render::RenderEntry;
 use crate::FieldRegistry;
 
 /// DDGame — the main game engine object.
@@ -183,7 +183,7 @@ pub struct DDGame {
     /// 0x4628: Team arena state — per-team data, ammo, delays, alliance tracking.
     /// Note: fields previously named init_field_64d8 (= team_count at arena+0x1EB0)
     /// and init_field_72a4 (= weapon_slots entry at arena+0x2A7C) are inside this struct.
-    pub team_arena: TeamArenaState,
+    pub team_arena: TeamArena,
     /// 0x7270-0x72A3: Unknown
     pub _unknown_7270: [u8; 0x72A4 - 0x7270],
     /// 0x72A4: Object pool counter. Incremented by +7 per CTaskMissile, +2 per CTaskArrow.
@@ -610,7 +610,7 @@ pub mod offsets {
     pub const WEAPON_PANEL: usize = 0x548;
 
     // === Team weapon state (DDGame + 0x4628) ===
-    /// Base of TeamArenaState sub-struct within DDGame.
+    /// Base of TeamArena sub-struct within DDGame.
     /// Callers pass DDGame + TEAM_ARENA_STATE as base pointer to
     /// GetAmmo/AddAmmo/SubtractAmmo.
     pub const TEAM_ARENA_STATE: usize = 0x4628;
@@ -621,7 +621,7 @@ pub mod offsets {
     /// Runtime-confirmed: block[0] is zeroed preamble, blocks[1-6] hold team data.
     pub const TEAM_BLOCKS: usize = 0x4090;
 
-    /// Byte offset from TeamArenaState base back to TeamBlock array start.
+    /// Byte offset from TeamArena base back to TeamBlock array start.
     /// `blocks_ptr = (tws_base as *const c_char).sub(ARENA_TO_BLOCKS) as *const TeamBlock`
     ///
     /// entry_ptr(0) = DDGame+0x4628 = TEAM_BLOCKS + 0x598.
@@ -772,7 +772,7 @@ impl crate::snapshot::Snapshot for DDGame {
         write_indent(w, i)?;
         writeln!(w, "task_land = {}", fmt_ptr(self.task_land))?;
 
-        // TeamArenaState summary
+        // TeamArena summary
         write_indent(w, i)?;
         writeln!(w, "team_arena.team_count = {}", self.team_arena.team_count)?;
         write_indent(w, i)?;

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

@@ -16,10 +16,10 @@ use crate::bitgrid::{BitGrid, BitGridBaseVtable, CollisionBitGrid, DisplayBitGri
 use crate::display::dd_display::DDDisplay;
 use crate::display::gradient::compute_complex_gradient;
 use crate::display::palette::Palette;
+use crate::engine::coord::{CoordList, CoordListEntry};
 use crate::engine::ddgame_wrapper::DDGameWrapper;
 use crate::engine::game_info::GameInfo;
 use crate::engine::net_bridge::NetBridge;
-use crate::engine::team_arena::{CoordList, CoordListEntry};
 use crate::input::keyboard::DDKeyboard;
 use crate::rebase::rb;
 use crate::render::gfx_dir::{
@@ -63,7 +63,7 @@ pub unsafe fn ddgame_init_fields(ddgame: *mut DDGame) {
         *(base.add(off) as *mut u32) = 0;
     }
 
-    // init_field_64d8 = TeamArenaState.team_count (arena+0x1EB0)
+    // init_field_64d8 = TeamArena.team_count (arena+0x1EB0)
     (*ddgame).team_arena.team_count = 0;
     // init_field_72a4 = weapon_slots flat[754] = alliance 5, ammo[44]
     (*ddgame).team_arena.weapon_slots.teams[5].ammo[44] = 0;

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

@@ -1,3 +1,4 @@
+pub mod coord;
 pub mod ddgame;
 pub mod ddgame_constructor;
 pub mod ddgame_load_fonts;
@@ -12,6 +13,7 @@ pub mod replay;
 pub mod team_arena;
 pub mod team_ops;
 
+pub use coord::{CoordEntry, CoordList, CoordListEntry};
 pub use ddgame::DDGame;
 pub use ddgame_constructor::{
     create_ddgame, ddgame_init_fields, ddgame_init_render_indices, display_layer_color_init,
@@ -23,7 +25,6 @@ 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,
+    TeamArena, TeamBlock, TeamHeader, TeamIndexMap, TeamSlot0, TeamWeaponSlots, WeaponSlots,
     WormEntry, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH,
 };

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

@@ -2,26 +2,14 @@
 // Team arena state — sub-struct at DDGame + 0x4628
 // ============================================================
 //
-// Extracted from ddgame.rs: team/worm data structures, TeamArenaRef,
+// Extracted from ddgame.rs: team/worm data structures, TeamArena,
 // and related helper structs used as DDGame fields.
 
 use core::ffi::CStr;
 
-use super::ddgame::offsets;
+use crate::snapshot::Snapshot;
 
-/// Coordinate entry used in DDGame screen coordinate tables (stride 0x10).
-///
-/// InitFields zeroes x and y; at runtime they contain fixed-point screen
-/// coordinates used for camera tracking and rendering regions.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct CoordEntry {
-    pub x: i32,
-    pub y: i32,
-    pub _unknown: [u8; 8],
-}
-
-const _: () = assert!(core::mem::size_of::<CoordEntry>() == 0x10);
+use super::ddgame::offsets;
 
 /// Team index permutation map (0x64 = 100 bytes).
 ///
@@ -42,86 +30,6 @@ pub struct TeamIndexMap {
 }
 const _: () = assert!(core::mem::size_of::<TeamIndexMap>() == 0x64);
 
-/// Render table entry (0x14 = 20 bytes).
-///
-/// 14 entries live at DDGame+0x73B0 (stride 0x14). Only the first u32
-/// is zeroed during construction; the rest is uninitialized/unknown.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct RenderEntry {
-    /// Active/state flag (zeroed on init).
-    pub active: u32,
-    /// Unknown data.
-    pub _unknown: [u8; 16],
-}
-const _: () = assert!(core::mem::size_of::<RenderEntry>() == 0x14);
-
-// ============================================================
-// CoordList — dynamic array of packed terrain coordinates
-// ============================================================
-
-/// Packed terrain coordinate entry (8 bytes).
-///
-/// `coord` packs x and y as `x * 0x10000 + y` (fixed-point).
-/// `flag` is always 1 for populated entries.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct CoordListEntry {
-    pub coord: u32,
-    pub flag: u32,
-}
-const _: () = assert!(core::mem::size_of::<CoordListEntry>() == 8);
-
-/// Dynamic coordinate array header (12 bytes).
-///
-/// Allocated at DDGame+0x50C during `init_graphics_and_resources`.
-/// Data buffer is a separate allocation of `capacity * 8` bytes.
-/// Used for terrain coordinate lookups (spawning, aiming, collision).
-#[repr(C)]
-pub struct CoordList {
-    /// Number of entries currently stored.
-    pub count: u32,
-    /// Maximum number of entries (600).
-    pub capacity: u32,
-    /// Pointer to the data buffer (`capacity * sizeof(CoordListEntry)` bytes).
-    pub data: *mut CoordListEntry,
-}
-const _: () = assert!(core::mem::size_of::<CoordList>() == 12);
-
-// ============================================================
-// Sound queue entry — 16 entries at DDGame + 0x7F00
-// ============================================================
-
-/// Sound queue entry (0x24 = 36 bytes, stride between consecutive entries).
-///
-/// DDGame maintains a 16-slot sound queue at offset 0x7F00. PlaySoundGlobal
-/// appends entries; PlaySoundLocal additionally marks entries as local and
-/// stores position via the task's secondary vtable.
-#[repr(C)]
-pub struct SoundQueueEntry {
-    /// Sound effect ID (SoundId enum value).
-    pub sound_id: u32,
-    /// Flags / priority (e.g. 3=weapon, 7=explosion).
-    pub flags: u32,
-    /// Volume (Fixed-point, 0x10000 = 1.0).
-    pub volume: u32,
-    /// Pitch (Fixed-point, 0x10000 = 1.0).
-    pub pitch: u32,
-    /// Reserved, always 0.
-    pub reserved: u32,
-    /// 0 = global, 1 = local (has position tracking).
-    pub is_local: u8,
-    pub _pad: [u8; 3],
-    /// Position X (filled by secondary vtable GetPosition for local sounds).
-    pub pos_x: u32,
-    /// Position Y (filled by secondary vtable GetPosition for local sounds).
-    pub pos_y: u32,
-    /// Pointer to task's secondary vtable (at task+0xE8) for position updates.
-    pub secondary_vtable: u32,
-}
-
-const _: () = assert!(core::mem::size_of::<SoundQueueEntry>() == 0x24);
-
 // ============================================================
 // Per-worm and per-team block structs
 // ============================================================
@@ -131,7 +39,7 @@ const _: () = assert!(core::mem::size_of::<SoundQueueEntry>() == 0x24);
 /// WA supports up to 8 playable worms per team. The original code accesses
 /// worms via raw pointer arithmetic from the team entry pointer, using
 /// stride 0x9C. This means the 8th worm crosses the TeamBlock boundary
-/// into the next block's header slot — see `TeamArenaRef::team_worm()`.
+/// into the next block's header slot — see `TeamArena::team_worm()`.
 ///
 /// Field offsets confirmed by runtime memory dump (validator DLL):
 /// - state at 0x00: 0x67 = active/selected, 0x65 = idle, 0x80+ = special
@@ -179,7 +87,7 @@ const _: () = assert!(core::mem::size_of::<WormEntry>() == 0x9C);
 /// offsets (0x00-0x5F) may contain data from the previous team's 8th worm
 /// when that team has 8 worms — they are treated as opaque padding.
 ///
-/// Accessed via `TeamArenaRef::team_header()` and `team_header_b()`.
+/// Accessed via `TeamArena::team_header()` and `team_header_b()`.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct TeamHeader {
@@ -235,10 +143,10 @@ pub union TeamSlot0 {
 /// The remaining 7 worm slots follow, then 0x3C bytes of metadata.
 ///
 /// **Block indexing**: Block 0 is unused (preamble, all zeros). Actual team
-/// data starts at block 1. Worms are accessed via `TeamArenaRef::team_worm()`
+/// data starts at block 1. Worms are accessed via `TeamArena::team_worm()`
 /// which uses raw pointer arithmetic and naturally crosses block boundaries.
 ///
-/// **Header access**: Use `TeamArenaRef::team_header(idx)` to get the
+/// **Header access**: Use `TeamArena::team_header(idx)` to get the
 /// `TeamHeader` for a team (reads from `blocks[idx+1].header.team`).
 #[repr(C)]
 pub struct TeamBlock {
@@ -286,13 +194,13 @@ const _: () = assert!(core::mem::size_of::<WeaponSlots>() == 852 * 4);
 /// `weapon_slots.teams[alliance].ammo[weapon]` and
 /// `weapon_slots.teams[alliance].delay[weapon]`.
 #[repr(C)]
-pub struct TeamArenaState {
+pub struct TeamArena {
     /// 0x0000-0x1EAF: Per-team data region (opaque).
     ///
     /// This region contains 7 team entries at stride 0x51C (1-indexed, index 0
     /// is preamble). The original WA.exe accesses team data via raw pointer
     /// arithmetic relative to the arena base. In our Rust code, team data is
-    /// accessed through `TeamArenaRef`, `TeamBlock`, and `TeamHeader`,
+    /// accessed through `TeamArena`, `TeamBlock`, and `TeamHeader`,
     /// so this region is treated as opaque padding.
     ///
     /// The 7th entry (team 6, 1-indexed) only has 8 bytes before team_count;
@@ -333,7 +241,7 @@ pub struct TeamArenaState {
     pub last_active_alliance: i32,
 }
 
-const _: () = assert!(core::mem::size_of::<TeamArenaState>() == 0x2C48);
+const _: () = assert!(core::mem::size_of::<TeamArena>() == 0x2C48);
 
 /// Worm state constants and helpers.
 /// TODO: Replace this module with the WormState enum
@@ -361,11 +269,11 @@ pub mod worm {
     }
 }
 
-/// Game phase thresholds (stored in TeamArenaState::game_phase).
+/// Game phase thresholds (stored in TeamArena::game_phase).
 pub const GAME_PHASE_SUDDEN_DEATH: i32 = 0x1E4; // 484
 pub const GAME_PHASE_NORMAL_MIN: i32 = -2;
 
-impl TeamArenaState {
+impl TeamArena {
     /// Get ammo count for a weapon by alliance and weapon ID.
     pub fn get_ammo(&self, alliance: usize, weapon_id: usize) -> i32 {
         self.weapon_slots.teams[alliance].ammo[weapon_id]
@@ -380,82 +288,44 @@ impl TeamArenaState {
     pub fn get_delay(&self, alliance: usize, weapon_id: usize) -> i32 {
         self.weapon_slots.teams[alliance].delay[weapon_id]
     }
-}
 
-/// Typed handle to a TeamArenaState pointer received from WA.exe.
-///
-/// Wraps the raw `base: u32` from trampoline register captures and provides
-/// accessor methods that encapsulate the backward pointer arithmetic to reach
-/// TeamBlock worm data. The TeamBlock array lives 0x598 bytes before
-/// the TeamArenaState in DDGame memory.
-///
-/// # Safety
-/// Must only be constructed from a valid DDGame + TEAM_ARENA_STATE pointer.
-/// `repr(transparent)` ensures identical ABI to `*const u8` / `u32` on i686,
-/// so it can be received directly from usercall trampoline register captures.
-#[repr(transparent)]
-#[derive(Clone, Copy)]
-pub struct TeamArenaRef {
-    base: *mut u8,
-}
+    // ── Raw-pointer accessors (safe from noalias miscompilation) ──
 
-impl TeamArenaRef {
-    /// Wrap a raw integer pointer (for usercall trampoline register captures).
+    /// Get pointer to the TeamBlock array base.
     ///
-    /// # Safety
-    /// `base` must point to a valid TeamArenaState (DDGame + 0x4628).
+    /// The TeamBlock array lives 0x598 bytes before TeamArena in DDGame memory.
     #[inline]
-    pub unsafe fn from_raw(base: u32) -> Self {
-        Self {
-            base: base as *mut u8,
-        }
+    pub unsafe fn blocks_mut(this: *mut Self) -> *mut TeamBlock {
+        (this as *mut u8).sub(offsets::ARENA_TO_BLOCKS) as *mut TeamBlock
     }
 
-    /// Wrap a typed pointer to TeamArenaState.
+    /// Get pointer to the TeamBlock array base (read-only).
     ///
-    /// # Safety
-    /// `arena` must point to a valid TeamArenaState within a live DDGame.
-    #[inline]
-    pub unsafe fn from_ptr(arena: *mut TeamArenaState) -> Self {
-        Self {
-            base: arena as *mut u8,
-        }
-    }
-
-    /// Access the TeamArenaState fields (read-only).
+    /// The TeamBlock array lives 0x598 bytes before TeamArena in DDGame memory.
     #[inline]
-    pub unsafe fn state(&self) -> &TeamArenaState {
-        &*(self.base as *const TeamArenaState)
+    pub unsafe fn blocks(this: *const Self) -> *const TeamBlock {
+        (this as *const u8).sub(offsets::ARENA_TO_BLOCKS) as *const TeamBlock
     }
 
-    /// Access the TeamArenaState fields (mutable).
-    #[inline]
-    pub unsafe fn state_mut(&self) -> &mut TeamArenaState {
-        &mut *(self.base as *mut TeamArenaState)
-    }
-
-    /// Get pointer to the TeamBlock array base.
-    #[inline]
-    pub unsafe fn blocks(&self) -> *mut TeamBlock {
-        self.base.sub(offsets::ARENA_TO_BLOCKS) as *mut TeamBlock
-    }
-
-    /// Get the team header (metadata) for a team.
+    /// Get pointer to team header (metadata) for a team.
     ///
-    /// Returns `&block[team_idx+1].header.team`, which holds team metadata:
+    /// Returns `blocks[team_idx+1].header.team`, which holds team metadata:
     /// worm_count, eliminated flag, weapon_alliance, team_name.
     #[inline]
-    pub unsafe fn team_header(&self, team_idx: usize) -> &TeamHeader {
-        &(*self.blocks().add(team_idx + 1)).header.team
+    pub unsafe fn team_header_mut(this: *mut Self, team_idx: usize) -> *mut TeamHeader {
+        &raw mut (*Self::blocks_mut(this).add(team_idx + 1)).header.team as *mut TeamHeader
     }
 
-    /// Get a mutable team header for a team.
+    /// Get pointer to team header (metadata) for a team.
+    ///
+    /// Returns `blocks[team_idx+1].header.team`, which holds team metadata:
+    /// worm_count, eliminated flag, weapon_alliance, team_name.
     #[inline]
-    pub unsafe fn team_header_mut(&self, team_idx: usize) -> &mut TeamHeader {
-        &mut (*self.blocks().add(team_idx + 1)).header.team
+    pub unsafe fn team_header(this: *const Self, team_idx: usize) -> *const TeamHeader {
+        &raw const (*Self::blocks(this).add(team_idx + 1)).header.team as *const TeamHeader
     }
 
-    /// Get a playable worm entry by 1-indexed worm number (1..=8).
+    /// Get pointer to a playable worm entry by 1-indexed worm number (1..=8).
     ///
     /// Uses raw pointer arithmetic matching the original WA code:
     /// `base + team_idx * 0x51C + worm_num * 0x9C - 0x598`.
@@ -464,56 +334,60 @@ impl TeamArenaRef {
     /// next block's header slot. The header metadata lives at high offsets
     /// (0x6C+) that don't conflict with worm data (0x00-0x5F).
     #[inline]
-    pub unsafe fn team_worm(&self, team_idx: usize, worm_num: usize) -> &WormEntry {
-        let ptr = self
-            .base
-            .add(team_idx * 0x51C)
-            .add(worm_num * 0x9C)
-            .sub(0x598);
-        &*(ptr as *const WormEntry)
+    pub unsafe fn team_worm_mut(
+        this: *mut Self,
+        team_idx: usize,
+        worm_num: usize,
+    ) -> *mut WormEntry {
+        let base = this as *mut u8;
+        base.add(team_idx * 0x51C).add(worm_num * 0x9C).sub(0x598) as *mut WormEntry
     }
 
-    /// Get a mutable reference to a specific worm entry.
-    pub unsafe fn team_worm_mut(&self, team_idx: usize, worm_num: usize) -> &mut WormEntry {
-        let ptr = self
-            .base
-            .add(team_idx * 0x51C)
-            .add(worm_num * 0x9C)
-            .sub(0x598);
-        &mut *(ptr as *mut WormEntry)
+    #[inline]
+    pub unsafe fn team_worm(
+        this: *const Self,
+        team_idx: usize,
+        worm_num: usize,
+    ) -> *const WormEntry {
+        let base = this as *const u8;
+        base.add(team_idx * 0x51C).add(worm_num * 0x9C).sub(0x598) as *const WormEntry
     }
 
-    /// Get a team's block and its header in one call.
+    /// Get a team's block pointer and its header pointer in one call.
     ///
-    /// Returns `(block[team_idx], &block[team_idx+1].header.team)`.
+    /// Returns `(blocks[team_idx], blocks[team_idx+1].header.team)`.
     /// The block contains worm data, and the header (slot 0 of the next block)
     /// holds team metadata (worm_count, eliminated flag).
     ///
     /// **Note**: For accessing worms, prefer `team_worm()` which handles
     /// 8-worm teams correctly via cross-boundary pointer arithmetic.
     #[inline]
-    pub unsafe fn team_and_header(&self, team_idx: usize) -> (&TeamBlock, &TeamHeader) {
-        let blocks = self.blocks();
-        let block = &*blocks.add(team_idx);
-        let header = &(*blocks.add(team_idx + 1)).header.team;
+    pub unsafe fn team_and_header(
+        this: *mut Self,
+        team_idx: usize,
+    ) -> (*mut TeamBlock, *mut TeamHeader) {
+        let blocks = Self::blocks_mut(this);
+        let block = blocks.add(team_idx);
+        let header = &raw mut (*blocks.add(team_idx + 1)).header.team as *mut TeamHeader;
         (block, header)
     }
 
-    /// Get team header for Pattern B access (alliance/active_worm at +0x70/+0x74).
+    /// Get team header pointer for Pattern B access (alliance/active_worm at +0x70/+0x74).
     ///
     /// Pattern B indexes from block[i+2] for 0-indexed team `i`:
     /// `base + 0x510 + i*0x51C` = `blocks[i+2].header.team + 0x70`.
     #[inline]
-    pub unsafe fn team_header_b(&self, team_idx: usize) -> &TeamHeader {
-        &(*self.blocks().add(team_idx + 2)).header.team
+    pub unsafe fn team_header_b_mut(this: *mut Self, team_idx: usize) -> *mut TeamHeader {
+        &raw mut (*Self::blocks_mut(this).add(team_idx + 2)).header.team as *mut TeamHeader
     }
 
-    /// Get mutable team header for Pattern B access.
+    /// Get team header pointer for Pattern B access (alliance/active_worm at +0x70/+0x74).
+    ///
+    /// Pattern B indexes from block[i+2] for 0-indexed team `i`:
+    /// `base + 0x510 + i*0x51C` = `blocks[i+2].header.team + 0x70`.
     #[inline]
-    pub unsafe fn team_header_b_mut(&self, team_idx: usize) -> &mut TeamHeader {
-        &mut (*(self.blocks() as *mut TeamBlock).add(team_idx + 2))
-            .header
-            .team
+    pub unsafe fn team_header_b(this: *const Self, team_idx: usize) -> *const TeamHeader {
+        &raw const (*Self::blocks(this).add(team_idx + 2)).header.team as *const TeamHeader
     }
 
     /// Compute the flat index for ammo/delay table access.
@@ -521,21 +395,21 @@ impl TeamArenaRef {
     /// Reads the weapon alliance ID from the team header for the given
     /// 1-indexed team, then computes `alliance_id * 142 + weapon_id`.
     ///
-    /// The weapon_slots array is interleaved: per alliance, 71 ammo slots
-    /// then 71 delay slots (stride 142 per alliance).
-    /// Ammo: `weapon_slots[alliance_id * 142 + weapon_id]`
-    /// Delay: `weapon_slots[alliance_id * 142 + 71 + weapon_id]`
-    /// Returns (alliance_id, weapon_id) for accessing weapon slots.
+    /// Returns (alliance_id, weapon_id) for accessing weapon_slots.
     #[inline]
-    pub unsafe fn weapon_slot_key(&self, team_index: usize, weapon_id: u32) -> (usize, usize) {
-        let alliance_id = self.team_header(team_index).weapon_alliance as usize;
+    pub unsafe fn weapon_slot_key(
+        this: *const Self,
+        team_index: usize,
+        weapon_id: u32,
+    ) -> (usize, usize) {
+        let alliance_id = (*Self::team_header(this, team_index)).weapon_alliance as usize;
         (alliance_id, weapon_id as usize)
     }
 }
 
 // ── Snapshot impl ──────────────────────────────────────────
 
-impl crate::snapshot::Snapshot for WormEntry {
+impl Snapshot for WormEntry {
     unsafe fn write_snapshot(
         &self,
         w: &mut dyn core::fmt::Write,

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

@@ -1,6 +1,6 @@
 //! Team and worm state accessor functions.
 //!
-//! Pure Rust reimplementations of WA.exe functions that access the TeamArenaState
+//! Pure Rust reimplementations of WA.exe functions that access the TeamArena
 //! area (DDGame + 0x4628). Called from hook trampolines in openwa-dll.
 //!
 //! Original WA functions:
@@ -15,29 +15,28 @@
 
 use crate::engine::team_arena::worm;
 
-use super::team_arena::TeamArenaRef;
+use super::team_arena::TeamArena;
 
 /// Count teams by alliance membership — port of 0x522030.
 ///
 /// Updates `state.active_team_count`, `same_alliance_count`, `enemy_team_count`.
 /// Uses Pattern B header fields (+0x70/+0x74) for alliance and active_worm.
-pub unsafe fn count_teams_by_alliance(arena: TeamArenaRef, alliance_id: i32) {
-    let state = arena.state_mut();
-    state.current_alliance = alliance_id;
-    state.active_team_count = 0;
-    state.same_alliance_count = 0;
-    state.enemy_team_count = 0;
-
-    for i in 0..state.team_count as usize {
-        let header = arena.team_header_b(i);
-        let team_alliance = header.alliance;
-        let active_worm = header.active_worm;
+pub unsafe fn count_teams_by_alliance(arena: *mut TeamArena, alliance_id: i32) {
+    (*arena).current_alliance = alliance_id;
+    (*arena).active_team_count = 0;
+    (*arena).same_alliance_count = 0;
+    (*arena).enemy_team_count = 0;
+
+    for i in 0..(*arena).team_count as usize {
+        let header = TeamArena::team_header_b(arena, i);
+        let team_alliance = (*header).alliance;
+        let active_worm = (*header).active_worm;
         if active_worm != 0 && team_alliance >= 0 {
-            state.active_team_count += 1;
+            (*arena).active_team_count += 1;
             if team_alliance == alliance_id {
-                state.same_alliance_count += 1;
+                (*arena).same_alliance_count += 1;
             } else {
-                state.enemy_team_count += 1;
+                (*arena).enemy_team_count += 1;
             }
         }
     }
@@ -46,17 +45,17 @@ pub unsafe fn count_teams_by_alliance(arena: TeamArenaRef, alliance_id: i32) {
 /// Sum worm health for a team — port of 0x5224D0.
 ///
 /// Returns 0 if the team is eliminated.
-pub unsafe fn get_team_total_health(team_index: u32, arena: TeamArenaRef) -> i32 {
-    let header = arena.team_header(team_index as usize);
+pub unsafe fn get_team_total_health(team_index: u32, arena: *const TeamArena) -> i32 {
+    let header = TeamArena::team_header(arena, team_index as usize);
 
-    if header.eliminated != 0 {
+    if (*header).eliminated != 0 {
         return 0;
     }
 
-    let worm_count = header.worm_count;
+    let worm_count = (*header).worm_count;
     let mut total = 0i32;
     for w in 1..=worm_count as usize {
-        total += arena.team_worm(team_index as usize, w).health;
+        total += (*TeamArena::team_worm(arena, team_index as usize, w)).health;
     }
     total
 }
@@ -67,12 +66,10 @@ pub unsafe fn get_team_total_health(team_index: u32, arena: TeamArenaRef) -> i32
 pub unsafe fn is_worm_in_special_state(
     team_index: u32,
     worm_index: u32,
-    arena: TeamArenaRef,
+    arena: *const TeamArena,
 ) -> u32 {
     if worm::is_special_state(
-        arena
-            .team_worm(team_index as usize, worm_index as usize)
-            .state,
+        (*TeamArena::team_worm(arena, team_index as usize, worm_index as usize)).state,
     ) {
         1
     } else {
@@ -87,29 +84,27 @@ pub unsafe fn is_worm_in_special_state(
 pub unsafe fn get_worm_position(
     team_index: u32,
     worm_index: u32,
-    arena: TeamArenaRef,
+    arena: *const TeamArena,
     out_x: *mut i32,
     out_y: *mut i32,
 ) {
-    let worm = arena.team_worm(team_index as usize, worm_index as usize);
-    *out_x = *(worm._unknown_90.as_ptr() as *const i32);
-    *out_y = *(worm._unknown_90.as_ptr().add(4) as *const i32);
+    let worm = TeamArena::team_worm(arena, team_index as usize, worm_index as usize);
+    *out_x = *((*worm)._unknown_90.as_ptr() as *const i32);
+    *out_y = *((*worm)._unknown_90.as_ptr().add(4) as *const i32);
 }
 
 /// Check if any worm on any team has state 0x64 — port of 0x5228D0.
 ///
 /// Iterates real teams (1-indexed). 11 xrefs in gameplay code.
-pub unsafe fn check_worm_state_0x64(arena: TeamArenaRef) -> u32 {
-    let state = arena.state();
-
-    for i in 1..=state.team_count as usize {
-        let header = arena.team_header(i);
-        if header.eliminated != 0 {
+pub unsafe fn check_worm_state_0x64(arena: *const TeamArena) -> u32 {
+    for i in 1..=(*arena).team_count as usize {
+        let header = TeamArena::team_header(arena, i);
+        if (*header).eliminated != 0 {
             continue;
         }
-        let worm_count = header.worm_count;
+        let worm_count = (*header).worm_count;
         for w in 1..=worm_count as usize {
-            if arena.team_worm(i, w).state == 0x64 {
+            if (*TeamArena::team_worm(arena, i, w)).state == 0x64 {
                 return 1;
             }
         }
@@ -120,16 +115,16 @@ pub unsafe fn check_worm_state_0x64(arena: TeamArenaRef) -> u32 {
 /// Check if any worm on a specific team has state 0x64 — port of 0x522930.
 ///
 /// Per-team version. 1 xref (FUN_00556ad0).
-pub unsafe fn check_team_worm_state_0x64(arena: TeamArenaRef, team_idx: u32) -> u32 {
-    let header = arena.team_header(team_idx as usize);
+pub unsafe fn check_team_worm_state_0x64(arena: *const TeamArena, team_idx: u32) -> u32 {
+    let header = TeamArena::team_header(arena, team_idx as usize);
 
-    if header.eliminated != 0 {
+    if (*header).eliminated != 0 {
         return 0;
     }
 
-    let worm_count = header.worm_count;
+    let worm_count = (*header).worm_count;
     for w in 1..=worm_count as usize {
-        if arena.team_worm(team_idx as usize, w).state == 0x64 {
+        if (*TeamArena::team_worm(arena, team_idx as usize, w)).state == 0x64 {
             return 1;
         }
     }
@@ -139,17 +134,15 @@ pub unsafe fn check_team_worm_state_0x64(arena: TeamArenaRef, team_idx: u32) ->
 /// Scan all teams for state 0x8b — port of 0x522970.
 ///
 /// 1 xref (FUN_00557310).
-pub unsafe fn check_any_worm_state_0x8b(arena: TeamArenaRef) -> u32 {
-    let state = arena.state();
-
-    for i in 1..=state.team_count as usize {
-        let header = arena.team_header(i);
-        if header.eliminated != 0 {
+pub unsafe fn check_any_worm_state_0x8b(arena: *const TeamArena) -> u32 {
+    for i in 1..=(*arena).team_count as usize {
+        let header = TeamArena::team_header(arena, i);
+        if (*header).eliminated != 0 {
             continue;
         }
-        let worm_count = header.worm_count;
+        let worm_count = (*header).worm_count;
         for w in 1..=worm_count as usize {
-            if arena.team_worm(i, w).state == 0x8b {
+            if (*TeamArena::team_worm(arena, i, w)).state == 0x8b {
                 return 1;
             }
         }
@@ -163,45 +156,43 @@ pub unsafe fn check_any_worm_state_0x8b(arena: TeamArenaRef) -> u32 {
 /// Called on turn transitions and worm selection (Tab).
 /// Updates active counters and records last_active_team/alliance.
 /// Uses Pattern B headers (0-indexed from `team_idx - 1`).
-pub unsafe fn set_active_worm(arena: TeamArenaRef, team_idx: u32, worm_index: i32) {
-    let state = arena.state_mut();
-
+pub unsafe fn set_active_worm(arena: *mut TeamArena, team_idx: u32, worm_index: i32) {
     // Pattern B header: team_idx is 1-indexed, team_header_b is 0-indexed
     // team_idx=1 → team_header_b(0) → blocks[2].header
-    let header = arena.team_header_b(team_idx as usize - 1);
+    let header = TeamArena::team_header_b_mut(arena, team_idx as usize - 1);
 
     if worm_index == 0 {
         // Deactivate team
-        if header.active_worm != 0 {
-            state.active_worm_count -= 1;
-            let alliance = header.alliance;
+        if (*header).active_worm != 0 {
+            (*arena).active_worm_count -= 1;
+            let alliance = (*header).alliance;
             if alliance >= 0 {
-                state.active_team_count -= 1;
-                if alliance == state.current_alliance {
-                    state.same_alliance_count -= 1;
+                (*arena).active_team_count -= 1;
+                if alliance == (*arena).current_alliance {
+                    (*arena).same_alliance_count -= 1;
                 } else {
-                    state.enemy_team_count -= 1;
+                    (*arena).enemy_team_count -= 1;
                 }
             }
-            arena.team_header_b_mut(team_idx as usize - 1).active_worm = 0;
+            (*header).active_worm = 0;
         }
     } else {
         // Activate team — only update counters if not already active
-        if header.active_worm == 0 {
-            state.active_worm_count += 1;
-            state.last_active_team = team_idx as i32;
-            let alliance = header.alliance;
-            state.last_active_alliance = alliance;
+        if (*header).active_worm == 0 {
+            (*arena).active_worm_count += 1;
+            (*arena).last_active_team = team_idx as i32;
+            let alliance = (*header).alliance;
+            (*arena).last_active_alliance = alliance;
             if alliance >= 0 {
-                state.active_team_count += 1;
-                if alliance == state.current_alliance {
-                    state.same_alliance_count += 1;
+                (*arena).active_team_count += 1;
+                if alliance == (*arena).current_alliance {
+                    (*arena).same_alliance_count += 1;
                 } else {
-                    state.enemy_team_count += 1;
+                    (*arena).enemy_team_count += 1;
                 }
             }
         }
         // Always write worm_index (original writes ESI unconditionally)
-        arena.team_header_b_mut(team_idx as usize - 1).active_worm = worm_index;
+        (*header).active_worm = worm_index;
     }
 }

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

@@ -11,7 +11,7 @@
 
 use crate::address::va;
 use crate::audio::{KnownSoundId, SoundId};
-use crate::engine::{TeamArenaRef, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH};
+use crate::engine::{TeamArena, GAME_PHASE_NORMAL_MIN, GAME_PHASE_SUDDEN_DEATH};
 use crate::fixed::Fixed;
 use crate::game::weapon::{WeaponEntry, WeaponFireParams, WeaponSpawnData};
 use crate::game::Weapon;
@@ -48,15 +48,14 @@ const _: () = assert!(core::mem::size_of::<WeaponReleaseContext>() == 0x2C);
 // __usercall: EAX = team_index, EDX = amount, [ESP+4] = team_info_base, [ESP+8] = weapon_id
 // RET 0x8
 
-pub unsafe fn add_ammo(team_index: u32, amount: i32, arena: TeamArenaRef, weapon_id: u32) {
-    let (alliance, wid) = arena.weapon_slot_key(team_index as usize, weapon_id);
-    let state = arena.state_mut();
-    let ammo = state.get_ammo(alliance, wid);
+pub unsafe fn add_ammo(team_index: u32, amount: i32, arena: *mut TeamArena, weapon_id: u32) {
+    let (alliance, wid) = TeamArena::weapon_slot_key(arena, team_index as usize, weapon_id);
+    let ammo = (*arena).get_ammo(alliance, wid);
     if ammo >= 0 {
         if amount < 0 {
-            *state.ammo_mut(alliance, wid) = -1;
+            *(*arena).ammo_mut(alliance, wid) = -1;
         } else {
-            *state.ammo_mut(alliance, wid) = ammo + amount;
+            *(*arena).ammo_mut(alliance, wid) = ammo + amount;
         }
     }
 }
@@ -67,12 +66,11 @@ pub unsafe fn add_ammo(team_index: u32, amount: i32, arena: TeamArenaRef, weapon
 // __usercall: EAX = team_index, ECX = team_info_base, [ESP+4] = weapon_id
 // RET 0x4
 
-pub unsafe fn subtract_ammo(team_index: u32, arena: TeamArenaRef, weapon_id: u32) {
-    let (alliance, wid) = arena.weapon_slot_key(team_index as usize, weapon_id);
-    let state = arena.state_mut();
-    let ammo = state.get_ammo(alliance, wid);
+pub unsafe fn subtract_ammo(team_index: u32, arena: *mut TeamArena, weapon_id: u32) {
+    let (alliance, wid) = TeamArena::weapon_slot_key(arena, team_index as usize, weapon_id);
+    let ammo = (*arena).get_ammo(alliance, wid);
     if ammo > 0 {
-        *state.ammo_mut(alliance, wid) = ammo - 1;
+        *(*arena).ammo_mut(alliance, wid) = ammo - 1;
     }
 }
 
@@ -82,31 +80,30 @@ pub unsafe fn subtract_ammo(team_index: u32, arena: TeamArenaRef, weapon_id: u32
 // __usercall: EAX = team_index, ESI = team_info_base, EDX = weapon_id
 // plain RET, returns EAX = ammo count
 
-pub unsafe fn get_ammo(team_index: u32, arena: TeamArenaRef, weapon_id: u32) -> u32 {
-    let (alliance, wid) = arena.weapon_slot_key(team_index as usize, weapon_id);
-    let state = arena.state();
+pub unsafe fn get_ammo(team_index: u32, arena: *mut TeamArena, weapon_id: u32) -> u32 {
+    let (alliance, wid) = TeamArena::weapon_slot_key(arena, team_index as usize, weapon_id);
 
     // Check weapon delay
-    if state.get_delay(alliance, wid) != 0 {
-        if state.game_mode_flag == 0 {
+    if (*arena).get_delay(alliance, wid) != 0 {
+        if (*arena).game_mode_flag == 0 {
             return 0;
         }
         // In sudden death (phase >= 484), delayed weapons return 0
         // unless it's Teleport (weapon 0x28)
-        if state.game_phase >= GAME_PHASE_SUDDEN_DEATH && weapon_id != Weapon::Teleport as u32 {
+        if (*arena).game_phase >= GAME_PHASE_SUDDEN_DEATH && weapon_id != Weapon::Teleport as u32 {
             return 0;
         }
     }
 
     // SelectWorm (0x3B) requires >1 alive worm on the team
-    if state.game_phase >= GAME_PHASE_NORMAL_MIN
+    if (*arena).game_phase >= GAME_PHASE_NORMAL_MIN
         && weapon_id == Weapon::SelectWorm as u32
         && count_alive_worms(team_index, arena) == 0
     {
         return 0;
     }
 
-    state.get_ammo(alliance, wid) as u32
+    (*arena).get_ammo(alliance, wid) as u32
 }
 
 // ============================================================
@@ -115,12 +112,12 @@ pub unsafe fn get_ammo(team_index: u32, arena: TeamArenaRef, weapon_id: u32) ->
 // __usercall: EAX = team_index, ECX = base
 // plain RET, returns EAX = bool (1 if >1 worm alive on team)
 
-pub unsafe fn count_alive_worms(team_index: u32, arena: TeamArenaRef) -> u32 {
-    let header = arena.team_header(team_index as usize);
-    let worm_count = header.worm_count;
+pub unsafe fn count_alive_worms(team_index: u32, arena: *const TeamArena) -> u32 {
+    let header = TeamArena::team_header(arena, team_index as usize);
+    let worm_count = (*header).worm_count;
     let mut alive = 0i32;
     for w in 1..=worm_count as usize {
-        if arena.team_worm(team_index as usize, w).health > 0 {
+        if (*TeamArena::team_worm(arena, team_index as usize, w)).health > 0 {
             alive += 1;
         }
     }
@@ -470,14 +467,14 @@ unsafe fn fire_skip_go(worm: *const CTaskWorm, entry: *const WeaponEntry) {
     let bit_index = ((*entry).fire_params.shot_count & 0x1F) as u32;
     let bit = 1u32 << bit_index;
 
-    let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
-    let header = arena.team_header_mut(team_index);
-    let flags = header.turn_action_flags;
+    let arena = &raw mut (*ddgame).team_arena;
+    let header = TeamArena::team_header_mut(arena, team_index);
+    let flags = (*header).turn_action_flags;
 
     if game_version > 0x1C && (flags & bit) != 0 {
-        header.turn_action_flags = flags & !bit;
+        (*header).turn_action_flags = flags & !bit;
     } else {
-        header.turn_action_flags = flags | bit;
+        (*header).turn_action_flags = flags | bit;
     }
 }
 
@@ -489,11 +486,11 @@ unsafe fn fire_freeze(worm: *mut CTaskWorm) {
     fire_send_team_message(worm, 0x29);
 
     let ddgame = CTask::ddgame_raw(worm as *const CTask);
-    let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
+    let arena = &raw mut (*ddgame).team_arena;
     let team_index = (*worm).team_index as usize;
     let worm_index = (*worm).worm_index as usize;
-    let entry = arena.team_worm_mut(team_index, worm_index);
-    entry.turn_action_counter_Maybe += 14;
+    let entry = TeamArena::team_worm_mut(arena, team_index, worm_index);
+    (*entry).turn_action_counter_Maybe += 14;
 }
 
 /// Mail/Mine/Mole (subtype 14) — pure Rust replacement for 0x51E670.
@@ -524,11 +521,11 @@ unsafe fn fire_mail_mine_mole(worm: *mut CTaskWorm) {
 
     fire_send_team_message(worm, 0x28);
 
-    let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
+    let arena = &raw mut (*ddgame).team_arena;
     let team_index = (*worm).team_index as usize;
     let worm_index = (*worm).worm_index as usize;
-    let entry = arena.team_worm_mut(team_index, worm_index);
-    entry.turn_action_counter_Maybe += 7;
+    let entry = TeamArena::team_worm_mut(arena, team_index, worm_index);
+    (*entry).turn_action_counter_Maybe += 7;
 }
 
 /// Teleport (subtype 10) — pure Rust port of 0x51E710.
@@ -983,12 +980,12 @@ unsafe fn fire_girder(worm: *mut CTaskWorm) {
         girder_visual(landscape, girder_x >> 16, girder_y >> 16, sprite1, sprite2);
 
         // Increment WormEntry counters
-        let arena = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
+        let arena = &raw mut (*ddgame).team_arena;
         let team_index = (*worm).team_index as usize;
         let worm_index = (*worm).worm_index as usize;
-        let entry = arena.team_worm_mut(team_index, worm_index);
-        entry.turn_action_counter_Maybe += 3;
-        entry.effect_counter_04_Maybe += 10;
+        let entry = TeamArena::team_worm_mut(arena, team_index, worm_index);
+        (*entry).turn_action_counter_Maybe += 3;
+        (*entry).effect_counter_04_Maybe += 10;
     }
 }
 

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

@@ -16,3 +16,17 @@ pub use sprite::{Sprite, SpriteFrame, SpriteId};
 pub use turn_order::{
     AnimatedItemList, TurnOrderAllianceGroup, TurnOrderTeamEntry, TurnOrderWidget,
 };
+
+/// Render table entry (0x14 = 20 bytes).
+///
+/// 14 entries live at DDGame+0x73B0 (stride 0x14). Only the first u32
+/// is zeroed during construction; the rest is uninitialized/unknown.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct RenderEntry {
+    /// Active/state flag (zeroed on init).
+    pub active: u32,
+    /// Unknown data.
+    pub _unknown: [u8; 16],
+}
+const _: () = assert!(core::mem::size_of::<RenderEntry>() == 0x14);

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

@@ -66,7 +66,7 @@ pub struct CTaskTeam {
     pub _secondary_vtable: u32,
     /// 0x34: Unknown — observed to hold the same value as `team_index` in all runs.
     pub _unknown_34: u32,
-    /// 0x38: Team number, **1-based**.  Matches TeamArenaState slot index.
+    /// 0x38: Team number, **1-based**.  Matches TeamArena slot index.
     pub team_index: u32,
     /// 0x3C: Unknown — observed 0 for team 1, 1 for team 2.
     pub _unknown_3c: u32,

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

@@ -152,9 +152,9 @@ pub struct CTaskTurnGame {
     pub current_team: u32,
     /// 0x130: active worm index within the current team, **0-based** (stride 0x9C).
     pub current_worm: u32,
-    /// 0x134: arena team index used for TeamArenaState lookups.
+    /// 0x134: arena team index used for TeamArena lookups.
     pub arena_team: u32,
-    /// 0x138: arena worm index used for TeamArenaState lookups.
+    /// 0x138: arena worm index used for TeamArena lookups.
     pub arena_worm: u32,
     pub _unknown_13c: u32,
     /// 0x140: set to 1 at construction; role unclear.

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

@@ -9,7 +9,7 @@ use crate::FieldRegistry;
 ///
 /// CTaskWorm's `SetState` (vtable slot 14) transitions between these.
 /// The state byte lives at CTaskWorm+0x44 (inside `base.subclass_data`).
-/// Also stored in WormEntry.state in the TeamArenaState.
+/// Also stored in WormEntry.state in the TeamArena.
 ///
 /// States 0x68..=0x8A are the "weapon/action active" range — checked by
 /// `(state - 0x68) < 0x23` in HandleMessage. States 0x80+ are dying/dead.

crates/openwa-dll/src/replacements/replay_test.rs

@@ -13,10 +13,9 @@
 use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering};
 
 use crate::log_line;
-use openwa_core::engine::ddgame::offsets;
 use openwa_core::engine::game_session;
 use openwa_core::engine::DDGame;
-use openwa_core::engine::TeamArenaRef;
+use openwa_core::engine::TeamArena;
 
 // ---------------------------------------------------------------------------
 // Fast-forward
@@ -69,9 +68,8 @@ pub unsafe fn on_frame(frame: u32) {
 ///
 /// Returns (alive_team_count, total_team_count).
 unsafe fn count_alive_teams(ddgame: *const DDGame) -> (i32, i32) {
-    let arena_base = (ddgame as u32) + offsets::TEAM_ARENA_STATE as u32;
-    let arena = TeamArenaRef::from_raw(arena_base);
-    let team_count = arena.state().team_count;
+    let arena = &raw const (*ddgame).team_arena;
+    let team_count = (*arena).team_count;
     if team_count <= 0 || team_count > 6 {
         return (0, 0);
     }
@@ -80,8 +78,7 @@ unsafe fn count_alive_teams(ddgame: *const DDGame) -> (i32, i32) {
     for t in 1..=team_count as usize {
         let mut team_has_alive = false;
         for w in 1..=8usize {
-            let worm = arena.team_worm(t, w);
-            if worm.health > 0 {
+            if (*TeamArena::team_worm(arena, t, w)).health > 0 {
                 team_has_alive = true;
                 break;
             }

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

@@ -4,13 +4,13 @@
 //! This file contains only usercall trampolines and hook installation.
 
 use openwa_core::engine::team_ops;
-use openwa_core::{address::va, engine::TeamArenaRef};
+use openwa_core::{address::va, engine::TeamArena};
 
 use crate::hook::{self, usercall_trampoline};
 
 // ── CountTeamsByAlliance (0x522030): usercall(EAX=base, EDI=alliance_id) ──
 
-unsafe extern "cdecl" fn count_teams_by_alliance_impl(arena: TeamArenaRef, alliance_id: i32) {
+unsafe extern "cdecl" fn count_teams_by_alliance_impl(arena: *mut TeamArena, alliance_id: i32) {
     team_ops::count_teams_by_alliance(arena, alliance_id);
 }
 
@@ -19,7 +19,7 @@ usercall_trampoline!(fn trampoline_count_teams_by_alliance; impl_fn = count_team
 
 // ── GetTeamTotalHealth (0x5224D0): fastcall(ECX=team_index, EDX=base) ──
 
-unsafe extern "cdecl" fn get_team_total_health_impl(team_index: u32, arena: TeamArenaRef) -> i32 {
+unsafe extern "cdecl" fn get_team_total_health_impl(team_index: u32, arena: *mut TeamArena) -> i32 {
     team_ops::get_team_total_health(team_index, arena)
 }
 
@@ -31,7 +31,7 @@ usercall_trampoline!(fn trampoline_get_team_total_health; impl_fn = get_team_tot
 unsafe extern "cdecl" fn is_worm_in_special_state_impl(
     team_index: u32,
     worm_index: u32,
-    arena: TeamArenaRef,
+    arena: *mut TeamArena,
 ) -> u32 {
     team_ops::is_worm_in_special_state(team_index, worm_index, arena)
 }
@@ -44,7 +44,7 @@ usercall_trampoline!(fn trampoline_is_worm_in_special_state; impl_fn = is_worm_i
 unsafe extern "cdecl" fn get_worm_position_impl(
     team_index: u32,
     worm_index: u32,
-    arena: TeamArenaRef,
+    arena: *mut TeamArena,
     out_x: *mut i32,
     out_y: *mut i32,
 ) {
@@ -56,7 +56,7 @@ usercall_trampoline!(fn trampoline_get_worm_position; impl_fn = get_worm_positio
 
 // ── CheckWormState0x64 (0x5228D0): usercall(EAX=base) ──
 
-unsafe extern "cdecl" fn check_worm_state_0x64_impl(arena: TeamArenaRef) -> u32 {
+unsafe extern "cdecl" fn check_worm_state_0x64_impl(arena: *mut TeamArena) -> u32 {
     team_ops::check_worm_state_0x64(arena)
 }
 
@@ -66,7 +66,7 @@ usercall_trampoline!(fn trampoline_check_worm_state_0x64; impl_fn = check_worm_s
 // ── CheckTeamWormState0x64 (0x522930): usercall(ECX=base, EAX=team_idx) ──
 
 unsafe extern "cdecl" fn check_team_worm_state_0x64_impl(
-    arena: TeamArenaRef,
+    arena: *mut TeamArena,
     team_idx: u32,
 ) -> u32 {
     team_ops::check_team_worm_state_0x64(arena, team_idx)
@@ -77,7 +77,7 @@ usercall_trampoline!(fn trampoline_check_team_worm_state_0x64; impl_fn = check_t
 
 // ── CheckAnyWormState0x8b (0x522970): usercall(EAX=base) ──
 
-unsafe extern "cdecl" fn check_any_worm_state_0x8b_impl(arena: TeamArenaRef) -> u32 {
+unsafe extern "cdecl" fn check_any_worm_state_0x8b_impl(arena: *mut TeamArena) -> u32 {
     team_ops::check_any_worm_state_0x8b(arena)
 }
 
@@ -86,7 +86,11 @@ usercall_trampoline!(fn trampoline_check_any_worm_state_0x8b; impl_fn = check_an
 
 // ── SetActiveWorm_Maybe (0x522500): usercall(EAX=base, EDX=team_idx, ESI=worm) ──
 
-unsafe extern "cdecl" fn set_active_worm_impl(arena: TeamArenaRef, team_idx: u32, worm_index: i32) {
+unsafe extern "cdecl" fn set_active_worm_impl(
+    arena: *mut TeamArena,
+    team_idx: u32,
+    worm_index: i32,
+) {
     team_ops::set_active_worm(arena, team_idx, worm_index);
 }
 

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

@@ -16,7 +16,7 @@ use openwa_core::game::weapon::WeaponFireParams;
 use openwa_core::game::weapon_fire;
 use openwa_core::log::log_line;
 use openwa_core::task::worm::CTaskWorm;
-use openwa_core::{address::va, engine::TeamArenaRef};
+use openwa_core::{address::va, engine::TeamArena};
 
 use crate::hook::{self, usercall_trampoline};
 
@@ -25,7 +25,7 @@ use crate::hook::{self, usercall_trampoline};
 unsafe extern "cdecl" fn add_ammo_impl(
     team_index: u32,
     amount: i32,
-    arena: TeamArenaRef,
+    arena: *mut TeamArena,
     weapon_id: u32,
 ) {
     weapon_fire::add_ammo(team_index, amount, arena, weapon_id);
@@ -36,7 +36,11 @@ usercall_trampoline!(fn trampoline_add_ammo; impl_fn = add_ammo_impl;
 
 // ── SubtractAmmo (0x522680): usercall(EAX=team, ECX=arena, stack=weapon_id) ──
 
-unsafe extern "cdecl" fn subtract_ammo_impl(team_index: u32, arena: TeamArenaRef, weapon_id: u32) {
+unsafe extern "cdecl" fn subtract_ammo_impl(
+    team_index: u32,
+    arena: *mut TeamArena,
+    weapon_id: u32,
+) {
     weapon_fire::subtract_ammo(team_index, arena, weapon_id);
 }
 
@@ -47,7 +51,7 @@ usercall_trampoline!(fn trampoline_subtract_ammo; impl_fn = subtract_ammo_impl;
 
 unsafe extern "cdecl" fn get_ammo_impl(
     team_index: u32,
-    arena: TeamArenaRef,
+    arena: *mut TeamArena,
     weapon_id: u32,
 ) -> u32 {
     weapon_fire::get_ammo(team_index, arena, weapon_id)
@@ -58,7 +62,7 @@ usercall_trampoline!(fn trampoline_get_ammo; impl_fn = get_ammo_impl;
 
 // ── CountAliveWorms (0x5225A0): usercall(EAX=team, ECX=arena) ──
 
-unsafe extern "cdecl" fn count_alive_worms_impl(team_index: u32, arena: TeamArenaRef) -> u32 {
+unsafe extern "cdecl" fn count_alive_worms_impl(team_index: u32, arena: *mut TeamArena) -> u32 {
     weapon_fire::count_alive_worms(team_index, arena)
 }
 

crates/openwa-dll/src/snapshot.rs

@@ -19,7 +19,7 @@ use openwa_core::task::{CTask, CTaskBfsIter, CTaskMissile, CTaskWorm};
 /// Must be called from the DLL while the game is paused (frame breakpoint).
 #[cfg(target_arch = "x86")]
 pub unsafe fn capture() -> String {
-    use openwa_core::engine::TeamArenaRef;
+    use openwa_core::engine::TeamArena;
 
     let mut out = String::with_capacity(128 * 1024);
 
@@ -62,26 +62,30 @@ 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 = TeamArenaRef::from_ptr(&raw mut (*ddgame).team_arena);
-    let blocks = arena.blocks();
+    let arena = &raw mut (*ddgame).team_arena;
+    let blocks = TeamArena::blocks_mut(arena);
     for t in 0..team_count {
-        let header = arena.team_header(t);
+        let header = TeamArena::team_header_mut(arena, t);
         let name =
-            core::ffi::CStr::from_ptr(header.team_name.as_ptr() as *const _).to_string_lossy();
+            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
+            (*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
+            (*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;
+        let worm_count = (*header).worm_count.max(0) as usize;
         let block = &*blocks.add(t + 1);
         for wi in 0..worm_count.min(7) {
             let worm = &block.worms[wi];