Merge branch 'init-game-state': hook all InitGameState sub-functions

19 hooks on DDGame__InitGameState sub-functions:
- 7 usercall functions ported to pure Rust (no asm bridges)
- 12 stdcall constructors with passthrough hooks (verified conventions)
- 1 bridged function (InitFeatureFlags, 600 lines, deferred)

New files: engine/game_state_init.rs, replacements/game_state_hooks.rs
Headful + headless replay tests pass throughout.

crates/openwa-core/src/address.rs

@@ -350,6 +350,46 @@ pub mod va {
     /// PaletteContext__Init (0x5411A0): initialize palette context free-list.
     /// usercall(EAX=context), plain RET.
     pub const PALETTE_CONTEXT_INIT: u32 = 0x0054_11A0;
+    /// SpriteGfxTable__Init (0x541620): fastcall(ECX=base, EDX=count), plain RET.
+    pub const SPRITE_GFX_TABLE_INIT: u32 = 0x0054_1620;
+    /// RingBuffer__Init (0x541060): usercall(EAX=capacity, ESI=struct), plain RET.
+    pub const RING_BUFFER_INIT: u32 = 0x0054_1060;
+    /// CGameTask__InitTeamScoring (0x528510): fastcall(ECX=wrapper), plain RET.
+    pub const INIT_TEAM_SCORING: u32 = 0x0052_8510;
+    /// CGameTask__InitAllianceData (0x5262D0): usercall(EAX=wrapper), plain RET.
+    pub const INIT_ALLIANCE_DATA: u32 = 0x0052_62D0;
+    /// DDGame__IsSuperWeapon (0x565960): usercall(EAX=weapon_index) + 1 stack param, plain RET.
+    pub const IS_SUPER_WEAPON: u32 = 0x0056_5960;
+    /// DDGame__CheckWeaponAvail (0x53FFC0): fastcall(ECX=ddgame) + unaff_ESI, plain RET.
+    pub const CHECK_WEAPON_AVAIL: u32 = 0x0053_FFC0;
+    /// CGameTask__InitTurnState (0x528690): usercall(EAX=wrapper), plain RET.
+    pub const INIT_TURN_STATE: u32 = 0x0052_8690;
+    /// CGameTask__InitLandscapeFlags (0x528480): usercall(EAX=wrapper), plain RET.
+    pub const INIT_LANDSCAPE_FLAGS: u32 = 0x0052_8480;
+    /// HudPanel__Constructor (0x524070): stdcall(this), RET 0x4.
+    pub const HUD_PANEL_CONSTRUCTOR: u32 = 0x0052_4070;
+    /// DDGame__InitTeamsFromSetup (0x5220B0): stdcall(team_arena, setup_data), RET 0x8.
+    pub const INIT_TEAMS_FROM_SETUP: u32 = 0x0052_20B0;
+    /// TeamManager__Constructor (0x563D40): stdcall(this, wrapper), RET 0x8.
+    pub const TEAM_MANAGER_CONSTRUCTOR: u32 = 0x0056_3D40;
+    /// CTaskTurnGame__Constructor (0x55B280): stdcall(this, setup_data), RET 0x8.
+    pub const TURN_GAME_CONSTRUCTOR: u32 = 0x0055_B280;
+    /// CTaskGameState__Constructor (0x532330): stdcall(this, param), RET 0x8.
+    pub const GAME_STATE_CONSTRUCTOR: u32 = 0x0053_2330;
+    /// DisplayGfx__ConstructFull (0x563FC0): stdcall(5 params), RET 0x14.
+    pub const DISPLAYGFX_CONSTRUCT_FULL: u32 = 0x0056_3FC0;
+    /// DDDisplay__ConstructTextbox (0x4FAF00): stdcall(3 params), RET 0xC.
+    pub const CONSTRUCT_TEXTBOX: u32 = 0x004F_AF00;
+    /// FUN_567770 (0x567770): stdcall(1 param = wrapper), RET 0x4.
+    pub const FUN_567770: u32 = 0x0056_7770;
+    /// FUN_545FD0 (0x545FD0): stdcall(3 params), RET 0xC. Buffer object constructor.
+    pub const BUFFER_OBJECT_CONSTRUCTOR: u32 = 0x0054_5FD0;
+    /// FUN_4FB490 (0x4FB490): stdcall(1 param), RET 0x4. GameStateStream sub-init.
+    pub const GAME_STATE_STREAM_INIT: u32 = 0x004F_B490;
+    /// FUN_540440 (0x540440): stdcall(2 params), RET 0x8. Display object constructor.
+    pub const DISPLAY_OBJECT_CONSTRUCTOR: u32 = 0x0054_0440;
+    /// DDGame__InitFeatureFlags (0x524700): stdcall(wrapper), RET 0x4.
+    pub const DDGAME_INIT_FEATURE_FLAGS: u32 = 0x0052_4700;
     /// DDGame__InitDisplayFinal_Maybe (0x56A830): display finalization for non-headless.
     pub const DDGAME_INIT_DISPLAY_FINAL: u32 = 0x0056_A830;
     /// PCLandscape__Constructor (0x57ACB0): constructs 0xB44-byte landscape object.

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

@@ -0,0 +1,598 @@
+//! Pure Rust implementations of DDGame__InitGameState sub-functions.
+//!
+//! Each function is hooked individually so it works regardless of whether
+//! InitGameState itself is Rust or the original WA code.
+
+use crate::wa_alloc::wa_malloc;
+
+/// Pure Rust implementation of SpriteGfxTable__Init (0x541620).
+///
+/// Convention: fastcall(ECX=base, EDX=count), plain RET.
+///
+/// Initializes two parallel arrays:
+/// - `base[0..count]`: identity permutation (index[i] = i)
+/// - `base+0x2000[0..count]`: all 0xFFFFFFFF (unused markers)
+/// Plus 3 trailer fields at +0x3000/+0x3004/+0x3008.
+pub unsafe fn sprite_gfx_table_init(base: *mut u8, count: u32) {
+    for i in 0..count {
+        // Index table: base + i*4 = i
+        *((base as *mut u32).add(i as usize)) = i;
+        // Lookup table: base + 0x2000 + i*4 = 0xFFFFFFFF
+        *((base.add(0x2000) as *mut u32).add(i as usize)) = 0xFFFF_FFFF;
+    }
+    *(base.add(0x3000) as *mut u32) = count;
+    *(base.add(0x3004) as *mut u32) = 0;
+    *(base.add(0x3008) as *mut u32) = count;
+}
+
+/// Pure Rust implementation of RingBuffer__Init (0x541060).
+///
+/// Convention: usercall(EAX=capacity, ESI=struct_ptr), plain RET.
+///
+/// Allocates a zero-filled buffer of `capacity` bytes (aligned + 0x20 header),
+/// then initializes the ring buffer struct (7 DWORDs):
+/// - [0]: data pointer
+/// - [1]: capacity
+/// - [2]-[6]: zeroed (head, tail, count, etc.)
+pub unsafe fn ring_buffer_init(struct_ptr: *mut u8, capacity: u32) {
+    let alloc_size = ((capacity + 3) & !3) + 0x20;
+    let data = wa_malloc(alloc_size);
+    if !data.is_null() {
+        core::ptr::write_bytes(data, 0, capacity as usize);
+    }
+
+    let s = struct_ptr as *mut u32;
+    *s.add(0) = data as u32; // data pointer
+    *s.add(1) = capacity; // capacity
+    *s.add(2) = 0; // field 2
+    *s.add(3) = 0; // field 3
+    *s.add(4) = 0; // field 4
+    *s.add(5) = 0; // field 5
+    *s.add(6) = 0; // field 6
+}
+
+/// Maximum number of teams (13 slots: 6 real + sentinels/padding).
+const MAX_TEAMS: usize = 13;
+
+/// Team entry stride in GameInfo (3000 bytes per team slot).
+const TEAM_ENTRY_STRIDE: usize = 3000;
+
+/// Helper: read the GameInfo pointer from a DDGameWrapper pointer.
+///
+/// Chain: wrapper+0x488 → DDGame, DDGame+0x24 → GameInfo.
+#[inline]
+unsafe fn game_info_from_wrapper(wrapper: *mut u8) -> *mut u8 {
+    let ddgame = *(wrapper.add(0x488) as *const *mut u8);
+    *(ddgame.add(0x24) as *const *mut u8)
+}
+
+/// Helper: read the DDGame pointer from a DDGameWrapper pointer.
+#[inline]
+unsafe fn ddgame_from_wrapper(wrapper: *mut u8) -> *mut u8 {
+    *(wrapper.add(0x488) as *const *mut u8)
+}
+
+/// Pure Rust implementation of CGameTask_InitTeamScoring_Maybe (0x528510).
+///
+/// Convention: fastcall(ECX=wrapper), plain RET.
+///
+/// Initializes 7 parallel u32 arrays (13 elements each) in CGameTask, then
+/// sets the starting-team flag, initializes team task pointer flags based on
+/// game mode (training vs normal), and zeros CTask sub-object fields.
+///
+/// # CGameTask array layout (all 13 × u32):
+/// - +0x0F4..+0x128: array_0  — zeroed
+/// - +0x128..+0x15C: array_1  — zeroed
+/// - +0x15C..+0x190: array_2  — scoring_param_a * 50
+/// - +0x190..+0x1C4: array_3  — zeroed
+/// - +0x1C4..+0x1F8: array_4  — scoring_param_b * 50
+/// - +0x1F8..+0x22C: array_5  — scoring_param_b * 50
+/// - +0x2BC..+0x2F0: array_6  — set to 1
+///
+/// # Other fields:
+/// - +0x128[starting_team]: set to 1 (starting team marker in array_1)
+/// - +0x22C[0..team_count]: team activity flags (-1 normal, -2 training)
+/// - +0x054[0..team_count]: CTask pointers — sub-fields zeroed if non-null
+pub unsafe fn init_team_scoring(wrapper: *mut u8) {
+    let game_info = game_info_from_wrapper(wrapper);
+
+    // GameInfo+0xD788: scoring_param_a (u16)
+    // GameInfo+0xD78A: scoring_param_b (u16)
+    let scoring_param_a = *(game_info.add(0xD788) as *const u16) as u32;
+    let scoring_param_b = *(game_info.add(0xD78A) as *const u16) as u32;
+    let value_a = scoring_param_a * 50; // uVar1 * 0x32
+    let value_b = scoring_param_b * 50; // iVar4
+
+    // Initialize 7 parallel arrays (13 elements each).
+    // puVar3 starts at wrapper+0x128, indexed relative to that.
+    let base = wrapper.add(0x128) as *mut u32;
+    for i in 0..MAX_TEAMS {
+        let p = base.add(i);
+        *p.sub(0xd) = 0; // +0x0F4[i]: array_0 — zeroed
+        *p = 0; // +0x128[i]: array_1 — zeroed
+        *p.add(0xd) = value_a; // +0x15C[i]: array_2 — scoring_param_a * 50
+        *p.add(0x27) = value_b; // +0x1C4[i]: array_4 — scoring_param_b * 50
+        *p.add(0x34) = value_b; // +0x1F8[i]: array_5 — scoring_param_b * 50
+        *p.add(0x1a) = 0; // +0x190[i]: array_3 — zeroed
+        *p.add(99) = 1; // +0x2BC[i]: array_6 — set to 1
+    }
+
+    // Mark the starting team in array_1: wrapper+0x128[starting_team] = 1
+    // GameInfo+0xD9DC: starting team index (i8)
+    let starting_team = *(game_info.add(0xD9DC) as *const i8) as i32;
+    *(base.add(starting_team as usize)) = 1;
+
+    // GameInfo+0xD9DD: mode flag (i8, negative = training/replay mode)
+    let mode_flag = *(game_info.add(0xD9DD) as *const i8);
+
+    // GameInfo+0x0000: first byte = total team count (num_teams, u8)
+    let num_teams = *game_info as u8 as i32;
+
+    // Team activity flags at wrapper+0x22C (one u32 per team)
+    let flags_base = wrapper.add(0x22C) as *mut u32;
+
+    if mode_flag < 0 {
+        // Training/replay mode: set all flags to -2 (0xFFFFFFFE)
+        if num_teams > 0 {
+            for i in 0..num_teams as usize {
+                *flags_base.add(i) = 0xFFFF_FFFE;
+            }
+        }
+
+        // For each active team slot in GameInfo, clear the flag to 0
+        // GameInfo+0x44C: team count for alliance data (u8)
+        let game_info2 = game_info_from_wrapper(wrapper);
+        let alliance_team_count = *game_info2.add(0x44C) as u8 as i32;
+        if alliance_team_count > 0 {
+            let mut offset: usize = 0;
+            for _ in 0..alliance_team_count {
+                // GameInfo+0x450 + team_index*3000: alliance group (i8)
+                let alliance_group = *(game_info2.add(0x450 + offset) as *const i8) as i32;
+                if alliance_group >= 0 {
+                    *flags_base.add(alliance_group as usize) = 0;
+                }
+                // Re-read game_info in case pointer chain changed (matches original)
+                let gi = game_info_from_wrapper(wrapper);
+                let _ = gi; // original re-reads but we already have the value
+                offset += TEAM_ENTRY_STRIDE;
+            }
+        }
+    } else {
+        // Normal mode: set all flags to -1 (0xFFFFFFFF)
+        if num_teams > 0 {
+            for i in 0..num_teams as usize {
+                *flags_base.add(i) = 0xFFFF_FFFF;
+            }
+        }
+
+        // Set starting team's flag to 1
+        // GameInfo+0xD9DD: starting team index for flags (i8, reuse mode_flag which is the same field)
+        let starting_flag_team = *(game_info_from_wrapper(wrapper).add(0xD9DD) as *const i8) as i32;
+        *flags_base.add(starting_flag_team as usize) = 1;
+    }
+
+    // Zero CTask sub-object fields for each team's task pointer
+    // wrapper+0x54[i] = CTask pointer, clear offsets +0x08..+0x18 (5 DWORDs)
+    let num_teams2 = *game_info_from_wrapper(wrapper) as u8 as i32;
+    if num_teams2 > 0 {
+        let task_ptrs = wrapper.add(0x54) as *mut *mut u8;
+        for i in 0..num_teams2 as usize {
+            let task = *task_ptrs.add(i);
+            if !task.is_null() {
+                *(task.add(0x18) as *mut u32) = 0;
+                *(task.add(0x14) as *mut u32) = 0;
+                *(task.add(0x10) as *mut u32) = 0;
+                *(task.add(0x0C) as *mut u32) = 0;
+                *(task.add(0x08) as *mut u32) = 0;
+            }
+        }
+    }
+}
+
+/// Pure Rust implementation of CGameTask_InitAllianceData_Maybe (0x5262D0).
+///
+/// Convention: usercall(EAX=wrapper), plain RET.
+///
+/// Initializes alliance bitmask table, per-team scoring flags in DDGame,
+/// and an auxiliary alliance array.
+///
+/// # Layout:
+/// - wrapper+0x350..+0x384: 13 × u32 alliance bitmasks (one per alliance group)
+/// - DDGame+0x7E70..+0x7E88: 6 × u32 per-team scoring flags
+/// - wrapper+0x3AC..: auxiliary array of non-starting-team alliance IDs (+0x10)
+///
+/// # GameInfo fields used:
+/// - +0x000: num_teams (u8, first byte)
+/// - +0x44C: alliance_team_count (u8)
+/// - +0x450 + i*3000: alliance_group (i8) for team i
+/// - +0x451 + i*3000: alliance_id (u8) for team i
+/// - +0xD778: game_version (i32)
+/// - +0xD9DC: starting_team_index (i8)
+///
+/// - wrapper+0x490: first byte used as scoring override value
+pub unsafe fn init_alliance_data(wrapper: *mut u8) {
+    // Zero 13 alliance bitmasks at wrapper+0x350..+0x384
+    for i in 0..MAX_TEAMS {
+        *(wrapper.add(0x350) as *mut u32).add(i) = 0;
+    }
+
+    // Build alliance bitmasks: for each team, set bit (alliance_id & 0x1F)
+    // in bitmask[alliance_group]
+    let game_info = game_info_from_wrapper(wrapper);
+    let num_teams = *game_info as u8 as i32;
+
+    // Global DAT_007a087c+4 = 0 (static variable, offset 0x7A0880)
+    // We skip this — it's a global we don't own. The original sets it but
+    // it appears unused in the init path.
+
+    let alliance_team_count = *game_info.add(0x44C) as u8 as i32;
+    if num_teams != 0 && alliance_team_count > 0 {
+        let mut offset: usize = 0;
+        for _ in 0..alliance_team_count {
+            let gi = game_info_from_wrapper(wrapper);
+            let alliance_group = *(gi.add(0x450 + offset) as *const i8) as i32;
+            let alliance_id = *(gi.add(0x451 + offset) as *const u8);
+
+            if alliance_group >= 0 {
+                let bitmask = (wrapper.add(0x350) as *mut u32).add(alliance_group as usize);
+                *bitmask |= 1u32 << (alliance_id & 0x1F);
+            }
+
+            offset += TEAM_ENTRY_STRIDE;
+        }
+    }
+
+    // Zero 6 per-team scoring flags at DDGame+0x7E70..+0x7E88
+    let ddgame = ddgame_from_wrapper(wrapper);
+    for i in 0..6u32 {
+        *(ddgame.add(0x7E70) as *mut u32).add(i as usize) = 0;
+    }
+
+    // Build scoring flags and auxiliary alliance array
+    let game_info = game_info_from_wrapper(wrapper);
+    let alliance_team_count = *game_info.add(0x44C) as u8 as i32;
+
+    // Local tracking: which alliance IDs we've already added to auxiliary array
+    let mut seen: [u8; 6] = [0; 6]; // local_8[0..6], indexed by alliance_id
+    let mut aux_count: usize = 0; // index into wrapper+0x3AC auxiliary array
+
+    if alliance_team_count > 0 {
+        let mut team_offset: usize = 0;
+
+        for team_idx in 0..alliance_team_count {
+            let gi = game_info_from_wrapper(wrapper);
+            let alliance_group = *(gi.add(0x450 + team_offset) as *const i8) as i32;
+            let alliance_id = *(gi.add(0x451 + team_offset) as *const u8) as u32;
+
+            let ddgame = ddgame_from_wrapper(wrapper);
+            let scoring_flag = (ddgame as *mut u32).add((0x7E70 / 4) + team_idx as usize);
+
+            if alliance_group < 0 {
+                // No alliance: flag = value from wrapper+0x490 (i8 sign-extended)
+                let override_val = *(wrapper.add(0x490) as *const i8) as i32;
+                *scoring_flag = override_val as u32;
+            } else {
+                // Check if this team is allied with the starting team
+                let gi = game_info_from_wrapper(wrapper);
+                let num_teams_byte = *gi as u8;
+                let override_byte = *(wrapper.add(0x490) as *const u8);
+
+                if num_teams_byte == 0 || override_byte != 0 {
+                    // No teams or override set: flag = 1
+                    *scoring_flag = 1;
+                } else {
+                    let game_version = *(gi.add(0xD778) as *const i32);
+                    let starting_team = *(gi.add(0xD9DC) as *const i8) as i32;
+
+                    let team_bitmask: u32 = if game_version < 0x83 {
+                        // Old version: use full alliance bitmask
+                        *((wrapper.add(0x350) as *const u32).add(alliance_group as usize))
+                    } else {
+                        // New version: just the single team's bit
+                        1u32 << (alliance_id & 0x1F)
+                    };
+
+                    let starting_bitmask =
+                        *((wrapper.add(0x350) as *const u32).add(starting_team as usize));
+
+                    if (starting_bitmask & team_bitmask) != 0 {
+                        // Same alliance as starting team: flag = 1
+                        *scoring_flag = 1;
+                    }
+                    // else: flag stays 0 (already zeroed above)
+                }
+
+                // Build auxiliary array for non-starting-team alliances
+                let gi2 = game_info_from_wrapper(wrapper);
+                let starting_team2 = *(gi2.add(0xD9DC) as *const i8) as i32;
+
+                if alliance_group != starting_team2 && seen[alliance_id as usize] == 0 {
+                    let starting_bitmask2 =
+                        *((wrapper.add(0x350) as *const u32).add(starting_team2 as usize));
+                    if (starting_bitmask2 & (1u32 << (alliance_id & 0x1F))) != 0 {
+                        // Store alliance_id + 0x10 into auxiliary array
+                        let aux_ptr = (wrapper.add(0x3AC) as *mut u32).add(aux_count);
+                        *aux_ptr = alliance_id + 0x10;
+                        aux_count += 1;
+                        seen[alliance_id as usize] = 1;
+                    }
+                }
+            }
+
+            team_offset += TEAM_ENTRY_STRIDE;
+        }
+    }
+}
+
+/// Pure Rust implementation of DDGame__IsSuperWeapon (0x565960).
+///
+/// Convention: usercall(EAX=weapon_index) + 1 stack param (param_1: u8), plain RET.
+/// Returns 1 for super weapons, param_1 for 0x3B, 0 otherwise.
+pub unsafe fn is_super_weapon(weapon_index: u32, param_1: u8) -> u8 {
+    match weapon_index {
+        10 | 0x13 | 0x1D | 0x1E | 0x1F | 0x24 | 0x29 | 0x2A | 0x2D | 0x2E | 0x31 | 0x32 | 0x33
+        | 0x36 | 0x37 | 0x38 | 0x3C | 0x3D => 1,
+        0x3B => param_1,
+        _ => 0,
+    }
+}
+
+/// Pure Rust implementation of DDGame__CheckWeaponAvail (0x53FFC0).
+///
+/// Convention: fastcall(ECX=ddgame) + unaff_ESI=weapon_index, plain RET. Returns i32.
+///
+/// Checks whether a weapon (1..0x46) is available given current game state.
+/// `ddgame` is the DDGame pointer directly (not wrapper).
+pub unsafe fn check_weapon_avail(ddgame: *mut u8, weapon_index: u32) -> i32 {
+    let game_info = *(ddgame.add(0x24) as *const *mut u8);
+    let game_version = *(game_info.add(0xD778) as *const i32);
+    let num_teams = *game_info as u8;
+
+    // Step 1: Special per-weapon disabling rules
+    match weapon_index {
+        10 | 0x37 | 0x38 => {
+            if *(game_info.add(0xD946) as *const u8) != 0
+                && *(game_info.add(0xD9A2) as *const u8) == 0
+            {
+                return 0;
+            }
+        }
+        0x36 => {
+            if *(game_info.add(0xD94C) as *const u8) != 0 {
+                return 0;
+            }
+        }
+        0x42 => {
+            let db08 = *(game_info.add(0xDB08) as *const u32);
+            if db08 == 0 {
+                if *(ddgame.add(0x1C) as *const u32) == 0 {
+                    return 0;
+                }
+            } else if (num_teams as u32) < 2 {
+                return 0;
+            }
+        }
+        0x45 => {
+            if game_version > 0xD1 {
+                let val = *(game_info.add(0xD932) as *const u16);
+                if val > 0x7FFF {
+                    return 0;
+                }
+            }
+        }
+        _ => {}
+    }
+
+    // Step 2: Branch on weapon table entry + DDGame+0x777C
+    // DDGame+0x510 is a POINTER to the weapon table (double deref)
+    let weapon_table = *(ddgame.add(0x510) as *const *const u8);
+    let weapon_entry = *(weapon_table.add(0x10 + (weapon_index as usize) * 0x1D0) as *const i32);
+
+    if *(ddgame.add(0x777C) as *const i32) == 0 || weapon_entry != 0 {
+        // Main path: check super weapon, 7E25, etc.
+        let super_result = is_super_weapon(weapon_index, *(ddgame.add(0x7E3F) as *const u8));
+        // After is_super_weapon, re-read ddgame (ECX may change in original — doesn't matter in Rust)
+        if super_result != 0 && *(game_info.add(0xD93C) as *const u8) == 0 {
+            // (game_version < 0x2A) - 1: if < 0x2A → 1-1=0, else → 0-1=-1
+            return (game_version < 0x2A) as i32 - 1;
+        }
+
+        if *(ddgame.add(0x7E25) as *const u8) == 0 {
+            return 1;
+        }
+
+        // Check if weapon_index == (0x19 - (game_info+0xD956 != 0))
+        let d956_nonzero = (*(game_info.add(0xD956) as *const u8) != 0) as u32;
+        if weapon_index != 0x19 - d956_nonzero {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    // Else branch: 777C != 0 AND weapon_entry == 0
+    if game_version > 0x29 && *(game_info.add(0xD959) as *const u8) != 0 {
+        return -2;
+    }
+
+    0
+}
+
+/// Bridge to DDGame__InitFeatureFlags (0x524700): stdcall(wrapper), RET 0x4.
+unsafe fn wa_init_feature_flags(wrapper: *mut u8) {
+    let f: unsafe extern "stdcall" fn(*mut u8) = core::mem::transmute(crate::rebase::rb(
+        crate::address::va::DDGAME_INIT_FEATURE_FLAGS,
+    ) as usize);
+    f(wrapper);
+}
+
+/// Pure Rust implementation of CGameTask__InitTurnState (0x528690).
+///
+/// Convention: usercall(EAX=wrapper), plain RET.
+///
+/// Initializes turn-related state fields in both the DDGameWrapper and DDGame
+/// structs. Zeroes camera state, timing fields, per-team flags, and calls
+/// DDGame__InitFeatureFlags. Also dispatches a vtable call on the landscape
+/// object.
+pub unsafe fn init_turn_state(wrapper: *mut u8) {
+    let ddgame = ddgame_from_wrapper(wrapper);
+    let game_info = *(ddgame.add(0x24) as *const *mut u8);
+
+    // wrapper+0x458 = -1, wrapper+0x450 = 0, wrapper+0x454 = 0
+    *(wrapper.add(0x458) as *mut u32) = 0xFFFF_FFFF;
+    *(wrapper.add(0x450) as *mut u32) = 0;
+    *(wrapper.add(0x454) as *mut u32) = 0;
+
+    // DDGame+0x72E0/E4 = -1, DDGame+0x72E8 = 0
+    *(ddgame.add(0x72E0) as *mut u32) = 0xFFFF_FFFF;
+    *(ddgame.add(0x72E4) as *mut u32) = 0xFFFF_FFFF;
+    *(ddgame.add(0x72E8) as *mut u32) = 0;
+
+    // Zero array at DDGame+0x73B0, stride 0x14, while offset < 0x118
+    {
+        let mut off = 0u32;
+        while off < 0x118 {
+            *(ddgame.add(0x73B0 + off as usize) as *mut u32) = 0;
+            off += 0x14;
+        }
+    }
+
+    // More DDGame field zeroing
+    *(ddgame.add(0x739C) as *mut u32) = 0;
+    *(ddgame.add(0x72F4) as *mut u32) = 0;
+    *(ddgame.add(0x72F8) as *mut u32) = 0;
+    *(ddgame.add(0x72FC) as *mut u32) = 0;
+    *(ddgame.add(0x7300) as *mut u32) = 0;
+    *(ddgame.add(0x7304) as *mut u32) = 0;
+
+    // DDGame+0x72EC = game_info+0xD774 (RNG seed from scheme)
+    let rng_seed = *(game_info.add(0xD774) as *const u32);
+    *(ddgame.add(0x72EC) as *mut u32) = rng_seed;
+    *(ddgame.add(0x72F0) as *mut u32) = rng_seed; // duplicate
+
+    *(ddgame.add(0x7378) as *mut u32) = 0;
+    *(ddgame.add(0x7374) as *mut u32) = 0;
+    *(ddgame.add(0x737C) as *mut u32) = 0;
+    *(ddgame.add(0x77DC) as *mut u32) = 0;
+    *(ddgame.add(0x77E0) as *mut u32) = 0;
+    *(ddgame.add(0x7784) as *mut u32) = 0;
+
+    // DDGame+0x7788 = game_info+0xF362 (byte → u32)
+    *(ddgame.add(0x7788) as *mut u32) = *(game_info.add(0xF362) as *const u8) as u32;
+    *(ddgame.add(0x778C) as *mut u32) = 0x10000; // Fixed-point 1.0
+    *(ddgame.add(0x7790) as *mut u32) = 0;
+
+    // Camera center: (level_width << 16) / 2, (level_height << 16) / 2
+    let level_width = *(ddgame.add(0x77C0) as *const i32);
+    let level_height = *(ddgame.add(0x77C4) as *const i32);
+    let cx = (level_width << 16) / 2;
+    let cy = (level_height << 16) / 2;
+    *(ddgame.add(0x7380) as *mut i32) = cx;
+    *(ddgame.add(0x7388) as *mut i32) = cx; // duplicate
+    *(ddgame.add(0x7384) as *mut i32) = cy;
+    *(ddgame.add(0x738C) as *mut i32) = cy; // duplicate
+
+    *(ddgame.add(0x7D84) as *mut u32) = 0;
+    *(ddgame.add(0x7E4C) as *mut u32) = 0;
+    *(ddgame.add(0x77D4) as *mut u32) = 0;
+    *(ddgame.add(0x77D8) as *mut u32) = 0;
+
+    // Per-team loop
+    let num_teams = *game_info as u8 as i32;
+    if num_teams > 0 {
+        let mut off = 0x7D88u32;
+        for i in 0..num_teams {
+            *(ddgame.add(off as usize) as *mut u32) = 0;
+            *(ddgame.add(0x7DBC + i as usize) as *mut u8) = 1;
+            *(ddgame.add(0x7DC9 + i as usize) as *mut u8) = 1;
+            *(ddgame.add(0x7DD6 + i as usize) as *mut u8) = 0;
+            *(ddgame.add(0x7DE3 + i as usize) as *mut u8) = 0;
+            *(ddgame.add(0x7DF0 + i as usize) as *mut u8) = 0;
+            off += 4;
+        }
+    }
+
+    *(ddgame.add(0x7E03) as *mut u8) = 0;
+    *(ddgame.add(0x7E04) as *mut u8) = 0;
+
+    // Call DDGame__InitFeatureFlags (600-line feature flag init, bridged)
+    wa_init_feature_flags(wrapper);
+
+    // Post-feature-flag field writes
+    *(ddgame.add(0x7E41) as *mut u8) = 0;
+    *(ddgame.add(0x7E50) as *mut u32) = 0;
+    *(ddgame.add(0x7E54) as *mut u32) = 0;
+    *(ddgame.add(0x7E58) as *mut u32) = 0;
+    *(ddgame.add(0x7E5C) as *mut u32) = 0;
+    *(ddgame.add(0x7E60) as *mut u32) = 0;
+    *(ddgame.add(0x7E64) as *mut u32) = 0;
+    *(ddgame.add(0x7E68) as *mut u32) = 0;
+    *(ddgame.add(0x7E6C) as *mut u32) = 0;
+    *(ddgame.add(0x7E88) as *mut u32) = 0;
+    *(ddgame.add(0x7E8C) as *mut u32) = 0;
+    *(ddgame.add(0x7E90) as *mut u32) = 0;
+    *(ddgame.add(0x7E94) as *mut u32) = 0;
+    *(ddgame.add(0x7E98) as *mut u32) = 0;
+    *(ddgame.add(0x7EA0) as *mut u32) = 0;
+    *(ddgame.add(0x7EA4) as *mut u32) = 0;
+
+    *(ddgame.add(0x8148) as *mut u32) = 1;
+
+    let ddgame2 = ddgame_from_wrapper(wrapper);
+    *(ddgame2.add(0x8158) as *mut u32) = 0;
+    *(ddgame2.add(0x815C) as *mut u32) = 0;
+    let ddgame3 = ddgame_from_wrapper(wrapper);
+    *(ddgame3.add(0x8160) as *mut u32) = 0;
+    *(ddgame3.add(0x8164) as *mut u32) = 0;
+
+    // Vtable dispatch: DDGame+0x20 → landscape object, vtable slot 1,
+    // param = game_info+0xD94C (byte)
+    let ddgame4 = ddgame_from_wrapper(wrapper);
+    let landscape = *(ddgame4.add(0x20) as *const *mut u8);
+    if !landscape.is_null() {
+        let vtable = *(landscape as *const *const usize);
+        let slot1: unsafe extern "thiscall" fn(*mut u8, u32) = core::mem::transmute(*vtable.add(1));
+        let game_info2 = *(ddgame4.add(0x24) as *const *const u8);
+        let param = *game_info2.add(0xD94C) as u32;
+        slot1(landscape, param);
+    }
+}
+
+/// Pure Rust implementation of CGameTask__InitLandscapeFlags (0x528480).
+///
+/// Convention: usercall(EAX=wrapper), plain RET.
+///
+/// Checks game_info+0xD94B and dispatches landscape vtable slot 6 with
+/// appropriate parameters, then updates DDGame+0x777C.
+pub unsafe fn init_landscape_flags(wrapper: *mut u8) {
+    let ddgame = ddgame_from_wrapper(wrapper);
+    let game_info = *(ddgame.add(0x24) as *const *mut u8);
+
+    let scheme_flag = *(game_info.add(0xD94B) as *const u8);
+
+    // Read the 4 DDGame fields used as params
+    let field_7318 = *(ddgame.add(0x7318) as *const u32);
+    let field_730c = *(ddgame.add(0x730C) as *const u32);
+    let field_734c = *(ddgame.add(0x734C) as *const u32);
+    let field_7340 = *(ddgame.add(0x7340) as *const u32);
+
+    // DDGame+0x20 = landscape object
+    let landscape = *(ddgame.add(0x20) as *const *mut u8);
+    let vtable = *(landscape as *const *const usize);
+    // Vtable slot 6 = offset +0x18
+    let slot6: unsafe extern "thiscall" fn(*mut u8, u32, u32, u32, u32, u32, u32, u32, u32) =
+        core::mem::transmute(*vtable.add(6));
+
+    if scheme_flag != 0 {
+        // Call with (1, 1, 1, 1, field_7318, field_730c, field_734c, field_7340)
+        slot6(
+            landscape, 1, 1, 1, 1, field_7318, field_730c, field_734c, field_7340,
+        );
+        *(ddgame.add(0x777C) as *mut u32) = 1;
+    } else if *(ddgame.add(0x777C) as *const u32) != 0 {
+        // Call with (0, 0, 1, 0, field_7318, field_730c, field_734c, field_7340)
+        slot6(
+            landscape, 0, 0, 1, 0, field_7318, field_730c, field_734c, field_7340,
+        );
+    }
+}

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

@@ -2,6 +2,7 @@ pub mod ddgame;
 pub mod ddgame_wrapper;
 pub mod game_info;
 pub mod game_session;
+pub mod game_state_init;
 pub mod game_timer;
 pub mod net_wrapper;
 

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

@@ -18,6 +18,10 @@ use openwa_core::engine::ddgame::{
     bit_grid_init, ddgame_init_fields, ddgame_init_render_indices, display_layer_color_init,
     gfx_dir_find_entry, gfx_dir_load_dir, gfx_resource_create, DDGame,
 };
+use openwa_core::engine::game_state_init::{
+    check_weapon_avail, init_alliance_data, init_landscape_flags, init_team_scoring,
+    init_turn_state, is_super_weapon, ring_buffer_init, sprite_gfx_table_init,
+};
 use openwa_core::engine::DDGameWrapper;
 
 // ─── DDGame__InitFields (0x526120) ──────────────────────────────────────────
@@ -200,7 +204,196 @@ pub fn install() -> Result<(), String> {
             va::GFX_DIR_LOAD_DIR,
             load_dir_trampoline as *const (),
         )?;
+
+        hook::install(
+            "SpriteGfxTable__Init",
+            va::SPRITE_GFX_TABLE_INIT,
+            sprite_gfx_table_init_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "RingBuffer__Init",
+            va::RING_BUFFER_INIT,
+            ring_buffer_init_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "CGameTask__InitTeamScoring",
+            va::INIT_TEAM_SCORING,
+            init_team_scoring_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "CGameTask__InitAllianceData",
+            va::INIT_ALLIANCE_DATA,
+            init_alliance_data_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "CGameTask__InitTurnState",
+            va::INIT_TURN_STATE,
+            init_turn_state_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "DDGame__CheckWeaponAvail",
+            va::CHECK_WEAPON_AVAIL,
+            check_weapon_avail_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "CGameTask__InitLandscapeFlags",
+            va::INIT_LANDSCAPE_FLAGS,
+            init_landscape_flags_trampoline as *const (),
+        )?;
+
+        hook::install(
+            "DDGame__IsSuperWeapon",
+            va::IS_SUPER_WEAPON,
+            is_super_weapon_trampoline as *const (),
+        )?;
     }
 
     Ok(())
 }
+
+// ─── SpriteGfxTable__Init (0x541620) ────────────────────────────────────────
+// Convention: fastcall(ECX=base, EDX=count), plain RET.
+
+unsafe extern "fastcall" fn sprite_gfx_table_init_trampoline(base: u32, count: u32) {
+    sprite_gfx_table_init(base as *mut u8, count);
+}
+
+// ─── RingBuffer__Init (0x541060) ────────────────────────────────────────────
+// Convention: usercall(EAX=capacity, ESI=struct_ptr), plain RET.
+
+extern "cdecl" fn impl_ring_buffer_init(struct_ptr: u32, capacity: u32) {
+    unsafe { ring_buffer_init(struct_ptr as *mut u8, capacity) }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn ring_buffer_init_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push eax",        // capacity (EAX)
+        "push esi",        // struct_ptr (ESI)
+        "call {impl_fn}",
+        "add esp, 8",
+        "pop edx",
+        "ret",
+        impl_fn = sym impl_ring_buffer_init,
+    );
+}
+
+// ─── CGameTask__InitTeamScoring (0x528510) ──────────────────────────────────
+// Convention: fastcall(ECX=wrapper), plain RET.
+
+unsafe extern "fastcall" fn init_team_scoring_trampoline(wrapper: u32, _edx: u32) {
+    init_team_scoring(wrapper as *mut u8);
+}
+
+// ─── CGameTask__InitAllianceData (0x5262D0) ─────────────────────────────────
+// Convention: usercall(EAX=wrapper), plain RET.
+
+extern "cdecl" fn impl_init_alliance_data(wrapper: u32) {
+    unsafe { init_alliance_data(wrapper as *mut u8) }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn init_alliance_data_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push eax",        // wrapper (EAX)
+        "call {impl_fn}",
+        "add esp, 4",
+        "pop edx",
+        "ret",
+        impl_fn = sym impl_init_alliance_data,
+    );
+}
+
+// ─── CGameTask__InitTurnState (0x528690) ────────────────────────────────────
+// Convention: usercall(EAX=wrapper), plain RET.
+
+extern "cdecl" fn impl_init_turn_state(wrapper: u32) {
+    unsafe { init_turn_state(wrapper as *mut u8) }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn init_turn_state_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push eax",        // wrapper (EAX)
+        "call {impl_fn}",
+        "add esp, 4",
+        "pop edx",
+        "ret",
+        impl_fn = sym impl_init_turn_state,
+    );
+}
+
+// ─── DDGame__CheckWeaponAvail (0x53FFC0) ────────────────────────────────────
+// Convention: fastcall(ECX=ddgame) + unaff_ESI=weapon_index, plain RET.
+// Returns i32 in EAX.
+
+extern "cdecl" fn impl_check_weapon_avail(ddgame: u32, weapon_index: u32) -> i32 {
+    unsafe { check_weapon_avail(ddgame as *mut u8, weapon_index) }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn check_weapon_avail_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push esi",        // weapon_index (ESI)
+        "push ecx",        // ddgame (ECX)
+        "call {impl_fn}",
+        "add esp, 8",
+        "pop edx",
+        "ret",
+        impl_fn = sym impl_check_weapon_avail,
+    );
+}
+
+// ─── CGameTask__InitLandscapeFlags (0x528480) ───────────────────────────────
+// Convention: usercall(EAX=wrapper), plain RET.
+
+extern "cdecl" fn impl_init_landscape_flags(wrapper: u32) {
+    unsafe { init_landscape_flags(wrapper as *mut u8) }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn init_landscape_flags_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push eax",        // wrapper (EAX)
+        "call {impl_fn}",
+        "add esp, 4",
+        "pop edx",
+        "ret",
+        impl_fn = sym impl_init_landscape_flags,
+    );
+}
+
+// ─── DDGame__IsSuperWeapon (0x565960) ───────────────────────────────────────
+// Convention: usercall(EAX=weapon_index) + 1 stack param (param_1: u8), plain RET.
+// Returns u8 in AL.
+
+extern "cdecl" fn impl_is_super_weapon(weapon_index: u32, param_1: u32) -> u32 {
+    unsafe { is_super_weapon(weapon_index, param_1 as u8) as u32 }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn is_super_weapon_trampoline() {
+    core::arch::naked_asm!(
+        "push ecx",
+        "push edx",
+        "push [esp+12]",  // stack param_1 (shifted by push ecx + push edx)
+        "push eax",        // weapon_index (EAX)
+        "call {impl_fn}",
+        "add esp, 8",
+        "pop edx",
+        "pop ecx",
+        "ret 0x4",         // callee cleans 1 stack param
+        impl_fn = sym impl_is_super_weapon,
+    );
+}

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

@@ -0,0 +1,205 @@
+//! Passthrough hooks for DDGame__InitGameState sub-functions.
+//!
+//! These hooks intercept stdcall constructors called during InitGameState,
+//! log their parameters, call the original, and return. This validates
+//! calling conventions and prepares for future Rust replacements.
+
+use crate::hook;
+use crate::log_line;
+use openwa_core::address::va;
+
+// ─── Trampoline storage ─────────────────────────────────────────────────────
+
+static mut HUD_PANEL_ORIG: *const () = core::ptr::null();
+static mut INIT_WEAPON_TABLE_ORIG: *const () = core::ptr::null();
+static mut INIT_TEAMS_ORIG: *const () = core::ptr::null();
+static mut TEAM_MANAGER_ORIG: *const () = core::ptr::null();
+static mut TURN_GAME_ORIG: *const () = core::ptr::null();
+static mut GAME_STATE_ORIG: *const () = core::ptr::null();
+static mut DISPLAYGFX_FULL_ORIG: *const () = core::ptr::null();
+static mut TEXTBOX_ORIG: *const () = core::ptr::null();
+static mut WEAPON_PANEL_ORIG: *const () = core::ptr::null();
+static mut BUFFER_OBJ_ORIG: *const () = core::ptr::null();
+static mut STREAM_INIT_ORIG: *const () = core::ptr::null();
+static mut DISPLAY_OBJ_ORIG: *const () = core::ptr::null();
+
+// ─── Passthrough hooks ──────────────────────────────────────────────────────
+
+// HudPanel__Constructor (0x524070): stdcall(this), RET 0x4
+unsafe extern "stdcall" fn hook_hud_panel(this: u32) -> u32 {
+    let _ = log_line(&format!(
+        "[InitGameState] HudPanel::Constructor this=0x{this:08X}"
+    ));
+    let orig: unsafe extern "stdcall" fn(u32) -> u32 = core::mem::transmute(HUD_PANEL_ORIG);
+    orig(this)
+}
+
+// InitWeaponTable (0x53CAB0): stdcall(wrapper), RET 0x4
+unsafe extern "stdcall" fn hook_init_weapon_table(wrapper: u32) -> u32 {
+    let _ = log_line(&format!(
+        "[InitGameState] InitWeaponTable wrapper=0x{wrapper:08X}"
+    ));
+    let orig: unsafe extern "stdcall" fn(u32) -> u32 = core::mem::transmute(INIT_WEAPON_TABLE_ORIG);
+    orig(wrapper)
+}
+
+// DDGame__InitTeamsFromSetup (0x5220B0): stdcall(team_arena, setup_data), RET 0x8
+unsafe extern "stdcall" fn hook_init_teams(team_arena: u32, setup_data: u32) -> u32 {
+    let _ = log_line(&format!(
+        "[InitGameState] InitTeamsFromSetup arena=0x{team_arena:08X} setup=0x{setup_data:08X}"
+    ));
+    let orig: unsafe extern "stdcall" fn(u32, u32) -> u32 = core::mem::transmute(INIT_TEAMS_ORIG);
+    orig(team_arena, setup_data)
+}
+
+// TeamManager__Constructor (0x563D40): stdcall(this, wrapper), RET 0x8
+unsafe extern "stdcall" fn hook_team_manager(this: u32, wrapper: u32) -> u32 {
+    let _ = log_line(&format!(
+        "[InitGameState] TeamManager::Constructor this=0x{this:08X} wrapper=0x{wrapper:08X}"
+    ));
+    let orig: unsafe extern "stdcall" fn(u32, u32) -> u32 = core::mem::transmute(TEAM_MANAGER_ORIG);
+    orig(this, wrapper)
+}
+
+// CTaskTurnGame__Constructor (0x55B280): stdcall(this, setup_data), RET 0x8
+// No logging — format! clobbers ECX which the post-call code may depend on
+unsafe extern "stdcall" fn hook_turn_game(this: u32, setup_data: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32) -> u32 = core::mem::transmute(TURN_GAME_ORIG);
+    orig(this, setup_data)
+}
+
+// CTaskGameState__Constructor (0x532330): stdcall(this, param), RET 0x8
+// No logging — may clobber registers the caller depends on
+unsafe extern "stdcall" fn hook_game_state(this: u32, param: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32) -> u32 = core::mem::transmute(GAME_STATE_ORIG);
+    orig(this, param)
+}
+
+// ─── Group F: Display objects ────────────────────────────────────────────────
+
+// DisplayGfx__ConstructFull (0x563FC0): stdcall(5 params), RET 0x14
+unsafe extern "stdcall" fn hook_displaygfx_full(
+    p1: u32,
+    p2: u32,
+    p3: u32,
+    p4: u32,
+    p5: u32,
+) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32, u32, u32, u32) -> u32 =
+        core::mem::transmute(DISPLAYGFX_FULL_ORIG);
+    orig(p1, p2, p3, p4, p5)
+}
+
+// DDDisplay__ConstructTextbox (0x4FAF00): stdcall(3 params), RET 0xC
+unsafe extern "stdcall" fn hook_textbox(p1: u32, p2: u32, p3: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32, u32) -> u32 = core::mem::transmute(TEXTBOX_ORIG);
+    orig(p1, p2, p3)
+}
+
+// DDGame__InitWeaponPanel (0x567770): stdcall(1 param = wrapper), RET 0x4
+unsafe extern "stdcall" fn hook_weapon_panel(wrapper: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32) -> u32 = core::mem::transmute(WEAPON_PANEL_ORIG);
+    orig(wrapper)
+}
+
+// ─── Group G: Buffer/stream objects ─────────────────────────────────────────
+
+// BufferObject__Constructor (0x545FD0): stdcall(3 params), RET 0xC
+unsafe extern "stdcall" fn hook_buffer_obj(p1: u32, p2: u32, p3: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32, u32) -> u32 =
+        core::mem::transmute(BUFFER_OBJ_ORIG);
+    orig(p1, p2, p3)
+}
+
+// GameStateStream__Init (0x4FB490): stdcall(1 param), RET 0x4
+unsafe extern "stdcall" fn hook_stream_init(p1: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32) -> u32 = core::mem::transmute(STREAM_INIT_ORIG);
+    orig(p1)
+}
+
+// DisplayObject__Constructor (0x540440): stdcall(2 params), RET 0x8
+unsafe extern "stdcall" fn hook_display_obj(p1: u32, p2: u32) -> u32 {
+    let orig: unsafe extern "stdcall" fn(u32, u32) -> u32 = core::mem::transmute(DISPLAY_OBJ_ORIG);
+    orig(p1, p2)
+}
+
+// ─── Hook installation ──────────────────────────────────────────────────────
+
+pub fn install() -> Result<(), String> {
+    unsafe {
+        HUD_PANEL_ORIG = hook::install(
+            "HudPanel__Constructor",
+            va::HUD_PANEL_CONSTRUCTOR,
+            hook_hud_panel as *const (),
+        )? as *const ();
+
+        INIT_WEAPON_TABLE_ORIG = hook::install(
+            "InitWeaponTable",
+            va::INIT_WEAPON_TABLE,
+            hook_init_weapon_table as *const (),
+        )? as *const ();
+
+        INIT_TEAMS_ORIG = hook::install(
+            "DDGame__InitTeamsFromSetup",
+            va::INIT_TEAMS_FROM_SETUP,
+            hook_init_teams as *const (),
+        )? as *const ();
+
+        TEAM_MANAGER_ORIG = hook::install(
+            "TeamManager__Constructor",
+            va::TEAM_MANAGER_CONSTRUCTOR,
+            hook_team_manager as *const (),
+        )? as *const ();
+
+        TURN_GAME_ORIG = hook::install(
+            "CTaskTurnGame__Constructor",
+            va::TURN_GAME_CONSTRUCTOR,
+            hook_turn_game as *const (),
+        )? as *const ();
+        GAME_STATE_ORIG = hook::install(
+            "CTaskGameState__Constructor",
+            va::GAME_STATE_CONSTRUCTOR,
+            hook_game_state as *const (),
+        )? as *const ();
+
+        // Group F: Display objects
+        DISPLAYGFX_FULL_ORIG = hook::install(
+            "DisplayGfx__ConstructFull",
+            va::DISPLAYGFX_CONSTRUCT_FULL,
+            hook_displaygfx_full as *const (),
+        )? as *const ();
+
+        TEXTBOX_ORIG = hook::install(
+            "DDDisplay__ConstructTextbox",
+            va::CONSTRUCT_TEXTBOX,
+            hook_textbox as *const (),
+        )? as *const ();
+
+        WEAPON_PANEL_ORIG = hook::install(
+            "DDGame__InitWeaponPanel",
+            va::FUN_567770,
+            hook_weapon_panel as *const (),
+        )? as *const ();
+
+        // Group G: Buffer/stream objects
+        BUFFER_OBJ_ORIG = hook::install(
+            "BufferObject__Constructor",
+            va::BUFFER_OBJECT_CONSTRUCTOR,
+            hook_buffer_obj as *const (),
+        )? as *const ();
+
+        STREAM_INIT_ORIG = hook::install(
+            "GameStateStream__Init",
+            va::GAME_STATE_STREAM_INIT,
+            hook_stream_init as *const (),
+        )? as *const ();
+
+        DISPLAY_OBJ_ORIG = hook::install(
+            "DisplayObject__Constructor",
+            va::DISPLAY_OBJECT_CONSTRUCTOR,
+            hook_display_obj as *const (),
+        )? as *const ();
+    }
+
+    Ok(())
+}

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

@@ -3,6 +3,7 @@ mod ddgame_init;
 mod display;
 mod frontend;
 mod game_session;
+mod game_state_hooks;
 mod hardware_init;
 mod headless;
 pub(crate) mod input;
@@ -28,5 +29,6 @@ pub fn install_all() -> Result<(), String> {
     speech::install()?;
     input::install()?;
     ddgame_init::install()?;
+    game_state_hooks::install()?;
     Ok(())
 }