paavohtl Claude Opus 4.6 (1M context) commited on
Commit
b169d13
·
1 Parent(s): 10c18ac

feat: parse version 2+ replay payload — scheme, observers, game version

Browse files

parse_v2plus_payload validates the second payload structure using
ReplayStream: sub-format flags, observer team loop, game version ID,
SCHM magic + scheme data (v1/v2/v3 with correct sizes from assembly),
random seed, map bytes, replay name, host index, and 13 observer
player entries.

Key findings from assembly analysis:
- Scheme data sizes: v1=216, v2=292, v3=variable (indicator-5)
- Scheme size indicator read when obs_count >= 0x14 (assembly CMP ESI,0x14)
- Scheme header byte read when obs_count >= 3
- Version 7-9 extra field (transitional format, assembly ADD ECX,-7; CMP ECX,2)

Team parsing (XOR game ID + 6×0xD7B per-team data) still TODO — needs
more decompilation work for per-team field structure.

Headless PASS, unit tests pass.

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

crates/openwa-wormkit/src/replacements/replay.rs CHANGED
@@ -6,7 +6,7 @@
6
  use crate::hook;
7
  use crate::log_line;
8
  use openwa_core::address::va;
9
- use openwa_core::engine::replay::{self, ReplayError};
10
  use openwa_core::rebase::rb;
11
 
12
  use core::ffi::c_void;
@@ -14,9 +14,8 @@ use core::ptr;
14
 
15
  // ─── WA CRT function wrappers ────────────────────────────────────────────────
16
  //
17
- // WA.exe statically links MSVC 2005 CRT. We must call WA's own CRT functions
18
- // via rebased addresses — NOT the Rust DLL's UCRT — because FILE* and heap
19
- // state are CRT-instance-specific.
20
 
21
  #[allow(non_camel_case_types)]
22
  type FILE = c_void;
@@ -26,41 +25,34 @@ unsafe fn wa_fopen(filename: *const u8, mode: *const u8) -> *mut FILE {
26
  core::mem::transmute(rb(0x005D_3271));
27
  f(filename, mode)
28
  }
29
-
30
  unsafe fn wa_fclose(stream: *mut FILE) {
31
  let f: unsafe extern "cdecl" fn(*mut FILE) = core::mem::transmute(rb(0x005D_399B));
32
  f(stream);
33
  }
34
-
35
  unsafe fn wa_fread(buf: *mut c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
36
  let f: unsafe extern "cdecl" fn(*mut c_void, u32, u32, *mut FILE) -> u32 =
37
  core::mem::transmute(rb(0x005D_4531));
38
  f(buf, size, count, file)
39
  }
40
-
41
  unsafe fn wa_fwrite(buf: *const c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
42
  let f: unsafe extern "cdecl" fn(*const c_void, u32, u32, *mut FILE) -> u32 =
43
  core::mem::transmute(rb(0x005D_3B76));
44
  f(buf, size, count, file)
45
  }
46
-
47
  unsafe fn wa_malloc(size: u32) -> *mut u8 {
48
  let f: unsafe extern "cdecl" fn(u32) -> *mut u8 =
49
  core::mem::transmute(rb(0x005D_0F65));
50
  f(size)
51
  }
52
-
53
  unsafe fn wa_free(ptr: *mut u8) {
54
  let f: unsafe extern "cdecl" fn(*mut u8) = core::mem::transmute(rb(0x005D_0D2B));
55
  f(ptr);
56
  }
57
-
58
  unsafe fn wa_fileno(stream: *mut FILE) -> i32 {
59
  let f: unsafe extern "cdecl" fn(*mut FILE) -> i32 =
60
  core::mem::transmute(rb(0x005D_5155));
61
  f(stream)
62
  }
63
-
64
  unsafe fn wa_filelengthi64(fd: i32) -> i64 {
65
  let f: unsafe extern "cdecl" fn(i32) -> i64 = core::mem::transmute(rb(0x005D_4FE1));
66
  f(fd)
@@ -85,22 +77,15 @@ struct ReplayGuard {
85
 
86
  impl ReplayGuard {
87
  fn new() -> Self {
88
- Self {
89
- file: ptr::null_mut(),
90
- payload: ptr::null_mut(),
91
- }
92
  }
93
  }
94
 
95
  impl Drop for ReplayGuard {
96
  fn drop(&mut self) {
97
  unsafe {
98
- if !self.payload.is_null() {
99
- wa_free(self.payload);
100
- }
101
- if !self.file.is_null() {
102
- wa_fclose(self.file);
103
- }
104
  }
105
  }
106
  }
@@ -113,7 +98,6 @@ unsafe extern "stdcall" fn hook_replay_loader(state: u32, mode: i32) -> u32 {
113
  core::mem::transmute(REPLAY_LOADER_ORIG);
114
  return orig(state, mode);
115
  }
116
-
117
  match replay_loader_play(state) {
118
  Ok(()) => 0u32,
119
  Err(e) => e as i32 as u32,
@@ -123,11 +107,7 @@ unsafe extern "stdcall" fn hook_replay_loader(state: u32, mode: i32) -> u32 {
123
  // ─── Main replay loader (mode 1) ────────────────────────────────────────────
124
 
125
  unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
126
- let _ = log_line(&format!(
127
- "[Replay] ReplayLoader Rust: state=0x{state:08X}"
128
- ));
129
-
130
- // Guard: ArtClass counter (signed comparison, JL in asm)
131
  let artclass_counter = *(rb(va::G_ARTCLASS_COUNTER) as *const i32);
132
  if artclass_counter >= 0x34 {
133
  return Err(ReplayError::ArtClassLimit);
@@ -141,7 +121,6 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
141
  SetCurrentDirectoryA(rb(0x0088_E078) as *const u8);
142
  let file = wa_fopen(s.add(0xDB60), b"rb\0".as_ptr());
143
  SetCurrentDirectoryA(rb(0x0088_E17D) as *const u8);
144
-
145
  if file.is_null() {
146
  return Err(ReplayError::FileNotFound);
147
  }
@@ -152,7 +131,7 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
152
  let fd = wa_fileno(file);
153
  let file_size = wa_filelengthi64(fd) as u64;
154
 
155
- // Read 4-byte header: lower 16 = magic, upper 16 = version
156
  let mut header: u32 = 0;
157
  if wa_fread(&mut header as *mut u32 as *mut c_void, 4, 1, file) == 0 {
158
  return Err(ReplayError::InvalidFormat);
@@ -160,7 +139,6 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
160
  if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 {
161
  return Err(ReplayError::InvalidFormat);
162
  }
163
-
164
  let version = header >> 16;
165
  if version == 0 || version > 20 {
166
  return Err(ReplayError::VersionTooNew);
@@ -170,7 +148,7 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
170
  *(s.add(0xDB54) as *mut u32) = version;
171
  *(s.add(0xDB58) as *mut u32) = 0xFFFF_FFFF;
172
 
173
- // Read payload size + validate
174
  let mut payload_size: u32 = 0;
175
  if wa_fread(&mut payload_size as *mut u32 as *mut c_void, 4, 1, file) == 0 {
176
  return Err(ReplayError::InvalidFormat);
@@ -178,8 +156,6 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
178
  if (payload_size as u64 + 8) > file_size {
179
  return Err(ReplayError::InvalidFormat);
180
  }
181
-
182
- // Read first payload
183
  let payload = wa_malloc(payload_size);
184
  if payload.is_null() {
185
  return Err(ReplayError::MallocFailure);
@@ -189,10 +165,9 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
189
  return Err(ReplayError::FileNotFound);
190
  }
191
 
192
- // Handle first payload based on first dword (sub-version / content type)
193
  let first_dword = *(payload as *const i32);
194
  *(s.add(0xDB1C) as *mut i32) = first_dword;
195
-
196
  if first_dword >= 1 {
197
  let thm = wa_fopen(b"data\\playback.thm\0".as_ptr(), b"wb\0".as_ptr());
198
  if !thm.is_null() {
@@ -205,15 +180,12 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
205
  *(s.add(0xDB24) as *mut i32) = *(payload.add(8) as *const i32);
206
  } else if first_dword == -2 {
207
  let copy_len = payload_size.saturating_sub(8) as usize;
208
- if copy_len > 0x20 {
209
- return Err(ReplayError::InvalidFormat);
210
- }
211
  ptr::copy_nonoverlapping(payload.add(8), s.add(0xDB24), copy_len);
212
  *s.add(0xDB1C + payload_size as usize) = 0;
213
  }
214
  }
215
 
216
- // Free first payload (file stays open for version-specific second payload)
217
  wa_free(payload);
218
  guard.payload = ptr::null_mut();
219
 
@@ -222,7 +194,7 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
222
  core::ptr::write_bytes(rb(va::G_TEAM_SECONDARY_DATA) as *mut u8, 0, 0xD9DC);
223
 
224
  let _ = log_line(&format!(
225
- "[Replay] Header OK: ver={version} payload={payload_size} sub={first_dword}"
226
  ));
227
 
228
  // Dispatch to version-specific parsing
@@ -235,52 +207,30 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
235
 
236
  // ─── Version 1 (legacy) ─────────────────────────────────────────────────────
237
 
238
- /// Version 1 replay parsing. Rare format (pre-3.5).
239
- /// Currently delegates to original trampoline.
240
  unsafe fn parse_version1(
241
- state: u32,
242
- _file: *mut FILE,
243
- guard: &mut ReplayGuard,
244
  ) -> Result<(), ReplayError> {
245
  let _ = log_line("[Replay] Version 1: delegating to original");
246
-
247
- // Close our file handle before original re-opens
248
  wa_fclose(guard.file);
249
  guard.file = ptr::null_mut();
250
-
251
- let orig: unsafe extern "stdcall" fn(u32, i32) -> u32 =
252
- core::mem::transmute(REPLAY_LOADER_ORIG);
253
- let result = orig(state, 1);
254
-
255
- if result == 0 { Ok(()) } else { Err(ReplayError::FileNotFound) }
256
  }
257
 
258
  // ─── Version 2+ (modern) ────────────────────────────────────────────────────
259
 
260
- /// Version 2+ replay parsing. Reads a second payload from the file containing
261
- /// team/scheme/observer data, then parses it.
262
- /// Currently delegates to original trampoline for the complex field parsing.
263
  unsafe fn parse_version2plus(
264
- state: u32,
265
- version: u32,
266
- file: *mut FILE,
267
- file_size: u64,
268
- first_payload_size: u32,
269
- guard: &mut ReplayGuard,
270
  ) -> Result<(), ReplayError> {
271
- // Read second payload size (4 bytes from file, after first payload)
272
  let mut second_size: u32 = 0;
273
  if wa_fread(&mut second_size as *mut u32 as *mut c_void, 4, 1, file) == 0 {
274
  return Err(ReplayError::InvalidFormat);
275
  }
276
-
277
- // Validate: header(4) + size1(4) + payload1 + size2(4) + payload2 <= file_size
278
  let total = 4u64 + 4 + first_payload_size as u64 + 4 + second_size as u64;
279
  if total > file_size {
280
  return Err(ReplayError::InvalidFormat);
281
  }
282
-
283
- // Read second payload
284
  let payload2 = wa_malloc(second_size);
285
  if payload2.is_null() {
286
  return Err(ReplayError::MallocFailure);
@@ -289,38 +239,197 @@ unsafe fn parse_version2plus(
289
  if wa_fread(payload2 as *mut c_void, second_size, 1, file) == 0 {
290
  return Err(ReplayError::InvalidFormat);
291
  }
292
-
293
- let _ = log_line(&format!(
294
- "[Replay] Version {version}: second payload = {second_size} bytes"
295
- ));
296
-
297
- // Close file — no more reads needed
298
  wa_fclose(file);
299
  guard.file = ptr::null_mut();
300
 
301
- // TODO: Parse second payload using ReplayStream.
302
- // The second payload contains: sub-format flags, observer teams,
303
- // game version ID, scheme data (SCHM), per-team data (6 × 0xD7B stride),
304
- // weapon data blocks, alliance/seed data.
305
- //
306
- // For now, delegate to original which re-parses from scratch.
307
 
308
- // Free second payload before delegation
309
  wa_free(payload2);
310
  guard.payload = ptr::null_mut();
311
 
312
- let _ = log_line("[Replay] Delegating to original for field parsing");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
313
  let orig: unsafe extern "stdcall" fn(u32, i32) -> u32 =
314
  core::mem::transmute(REPLAY_LOADER_ORIG);
315
  let result = orig(state, 1);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
316
 
317
- if result == 0 {
318
- let _ = log_line("[Replay] Original completed OK");
319
- Ok(())
 
320
  } else {
321
- let _ = log_line(&format!("[Replay] Original error: {}", result as i32));
322
- Err(ReplayError::FileNotFound)
 
 
 
 
 
 
 
 
 
 
 
 
 
323
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
324
  }
325
 
326
  // ─── ParseReplayPosition full replacement ────────────────────────────────────
@@ -329,9 +438,7 @@ unsafe extern "stdcall" fn hook_parse_replay_position(input: *const u8) -> i32 {
329
  let mut len = 0usize;
330
  while *input.add(len) != 0 {
331
  len += 1;
332
- if len > 256 {
333
- break;
334
- }
335
  }
336
  let slice = core::slice::from_raw_parts(input, len + 1);
337
  replay::parse_replay_position(slice)
@@ -346,7 +453,6 @@ pub fn install() -> Result<(), String> {
346
  va::REPLAY_LOADER,
347
  hook_replay_loader as *const (),
348
  )? as *const ();
349
-
350
  PARSE_POSITION_ORIG = hook::install(
351
  "ParseReplayPosition",
352
  va::PARSE_REPLAY_POSITION,
 
6
  use crate::hook;
7
  use crate::log_line;
8
  use openwa_core::address::va;
9
+ use openwa_core::engine::replay::{self, ReplayError, ReplayStream};
10
  use openwa_core::rebase::rb;
11
 
12
  use core::ffi::c_void;
 
14
 
15
  // ─── WA CRT function wrappers ────────────────────────────────────────────────
16
  //
17
+ // Must call WA's own CRT (MSVC 2005, statically linked) via rebased addresses,
18
+ // NOT the Rust DLL's UCRT — FILE* and heap are CRT-instance-specific.
 
19
 
20
  #[allow(non_camel_case_types)]
21
  type FILE = c_void;
 
25
  core::mem::transmute(rb(0x005D_3271));
26
  f(filename, mode)
27
  }
 
28
  unsafe fn wa_fclose(stream: *mut FILE) {
29
  let f: unsafe extern "cdecl" fn(*mut FILE) = core::mem::transmute(rb(0x005D_399B));
30
  f(stream);
31
  }
 
32
  unsafe fn wa_fread(buf: *mut c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
33
  let f: unsafe extern "cdecl" fn(*mut c_void, u32, u32, *mut FILE) -> u32 =
34
  core::mem::transmute(rb(0x005D_4531));
35
  f(buf, size, count, file)
36
  }
 
37
  unsafe fn wa_fwrite(buf: *const c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
38
  let f: unsafe extern "cdecl" fn(*const c_void, u32, u32, *mut FILE) -> u32 =
39
  core::mem::transmute(rb(0x005D_3B76));
40
  f(buf, size, count, file)
41
  }
 
42
  unsafe fn wa_malloc(size: u32) -> *mut u8 {
43
  let f: unsafe extern "cdecl" fn(u32) -> *mut u8 =
44
  core::mem::transmute(rb(0x005D_0F65));
45
  f(size)
46
  }
 
47
  unsafe fn wa_free(ptr: *mut u8) {
48
  let f: unsafe extern "cdecl" fn(*mut u8) = core::mem::transmute(rb(0x005D_0D2B));
49
  f(ptr);
50
  }
 
51
  unsafe fn wa_fileno(stream: *mut FILE) -> i32 {
52
  let f: unsafe extern "cdecl" fn(*mut FILE) -> i32 =
53
  core::mem::transmute(rb(0x005D_5155));
54
  f(stream)
55
  }
 
56
  unsafe fn wa_filelengthi64(fd: i32) -> i64 {
57
  let f: unsafe extern "cdecl" fn(i32) -> i64 = core::mem::transmute(rb(0x005D_4FE1));
58
  f(fd)
 
77
 
78
  impl ReplayGuard {
79
  fn new() -> Self {
80
+ Self { file: ptr::null_mut(), payload: ptr::null_mut() }
 
 
 
81
  }
82
  }
83
 
84
  impl Drop for ReplayGuard {
85
  fn drop(&mut self) {
86
  unsafe {
87
+ if !self.payload.is_null() { wa_free(self.payload); }
88
+ if !self.file.is_null() { wa_fclose(self.file); }
 
 
 
 
89
  }
90
  }
91
  }
 
98
  core::mem::transmute(REPLAY_LOADER_ORIG);
99
  return orig(state, mode);
100
  }
 
101
  match replay_loader_play(state) {
102
  Ok(()) => 0u32,
103
  Err(e) => e as i32 as u32,
 
107
  // ─── Main replay loader (mode 1) ────────────────────────────────────────────
108
 
109
  unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
110
+ // ArtClass counter guard (signed comparison, JL in asm)
 
 
 
 
111
  let artclass_counter = *(rb(va::G_ARTCLASS_COUNTER) as *const i32);
112
  if artclass_counter >= 0x34 {
113
  return Err(ReplayError::ArtClassLimit);
 
121
  SetCurrentDirectoryA(rb(0x0088_E078) as *const u8);
122
  let file = wa_fopen(s.add(0xDB60), b"rb\0".as_ptr());
123
  SetCurrentDirectoryA(rb(0x0088_E17D) as *const u8);
 
124
  if file.is_null() {
125
  return Err(ReplayError::FileNotFound);
126
  }
 
131
  let fd = wa_fileno(file);
132
  let file_size = wa_filelengthi64(fd) as u64;
133
 
134
+ // Header: magic + version
135
  let mut header: u32 = 0;
136
  if wa_fread(&mut header as *mut u32 as *mut c_void, 4, 1, file) == 0 {
137
  return Err(ReplayError::InvalidFormat);
 
139
  if (header & 0xFFFF) != replay::REPLAY_MAGIC as u32 {
140
  return Err(ReplayError::InvalidFormat);
141
  }
 
142
  let version = header >> 16;
143
  if version == 0 || version > 20 {
144
  return Err(ReplayError::VersionTooNew);
 
148
  *(s.add(0xDB54) as *mut u32) = version;
149
  *(s.add(0xDB58) as *mut u32) = 0xFFFF_FFFF;
150
 
151
+ // First payload
152
  let mut payload_size: u32 = 0;
153
  if wa_fread(&mut payload_size as *mut u32 as *mut c_void, 4, 1, file) == 0 {
154
  return Err(ReplayError::InvalidFormat);
 
156
  if (payload_size as u64 + 8) > file_size {
157
  return Err(ReplayError::InvalidFormat);
158
  }
 
 
159
  let payload = wa_malloc(payload_size);
160
  if payload.is_null() {
161
  return Err(ReplayError::MallocFailure);
 
165
  return Err(ReplayError::FileNotFound);
166
  }
167
 
168
+ // Handle first payload (sub-version / content type)
169
  let first_dword = *(payload as *const i32);
170
  *(s.add(0xDB1C) as *mut i32) = first_dword;
 
171
  if first_dword >= 1 {
172
  let thm = wa_fopen(b"data\\playback.thm\0".as_ptr(), b"wb\0".as_ptr());
173
  if !thm.is_null() {
 
180
  *(s.add(0xDB24) as *mut i32) = *(payload.add(8) as *const i32);
181
  } else if first_dword == -2 {
182
  let copy_len = payload_size.saturating_sub(8) as usize;
183
+ if copy_len > 0x20 { return Err(ReplayError::InvalidFormat); }
 
 
184
  ptr::copy_nonoverlapping(payload.add(8), s.add(0xDB24), copy_len);
185
  *s.add(0xDB1C + payload_size as usize) = 0;
186
  }
187
  }
188
 
 
189
  wa_free(payload);
190
  guard.payload = ptr::null_mut();
191
 
 
194
  core::ptr::write_bytes(rb(va::G_TEAM_SECONDARY_DATA) as *mut u8, 0, 0xD9DC);
195
 
196
  let _ = log_line(&format!(
197
+ "[Replay] Header: ver={version} payload={payload_size} sub={first_dword}"
198
  ));
199
 
200
  // Dispatch to version-specific parsing
 
207
 
208
  // ─── Version 1 (legacy) ─────────────────────────────────────────────────────
209
 
 
 
210
  unsafe fn parse_version1(
211
+ state: u32, _file: *mut FILE, guard: &mut ReplayGuard,
 
 
212
  ) -> Result<(), ReplayError> {
213
  let _ = log_line("[Replay] Version 1: delegating to original");
 
 
214
  wa_fclose(guard.file);
215
  guard.file = ptr::null_mut();
216
+ delegate_to_original(state)
 
 
 
 
 
217
  }
218
 
219
  // ─── Version 2+ (modern) ────────────────────────────────────────────────────
220
 
 
 
 
221
  unsafe fn parse_version2plus(
222
+ state: u32, version: u32, file: *mut FILE,
223
+ file_size: u64, first_payload_size: u32, guard: &mut ReplayGuard,
 
 
 
 
224
  ) -> Result<(), ReplayError> {
225
+ // Read second payload
226
  let mut second_size: u32 = 0;
227
  if wa_fread(&mut second_size as *mut u32 as *mut c_void, 4, 1, file) == 0 {
228
  return Err(ReplayError::InvalidFormat);
229
  }
 
 
230
  let total = 4u64 + 4 + first_payload_size as u64 + 4 + second_size as u64;
231
  if total > file_size {
232
  return Err(ReplayError::InvalidFormat);
233
  }
 
 
234
  let payload2 = wa_malloc(second_size);
235
  if payload2.is_null() {
236
  return Err(ReplayError::MallocFailure);
 
239
  if wa_fread(payload2 as *mut c_void, second_size, 1, file) == 0 {
240
  return Err(ReplayError::InvalidFormat);
241
  }
 
 
 
 
 
 
242
  wa_fclose(file);
243
  guard.file = ptr::null_mut();
244
 
245
+ // Parse second payload (validation only — does not write globals yet)
246
+ let data = core::slice::from_raw_parts(payload2, second_size as usize);
247
+ let result = parse_v2plus_payload(data, version);
 
 
 
248
 
 
249
  wa_free(payload2);
250
  guard.payload = ptr::null_mut();
251
 
252
+ match &result {
253
+ Ok(info) => {
254
+ let _ = log_line(&format!(
255
+ "[Replay] Parsed OK: game_ver={} scheme_v={} teams={} observers={}",
256
+ info.game_version_id, info.scheme_version, info.team_count, info.observer_count
257
+ ));
258
+ }
259
+ Err(e) => {
260
+ let _ = log_line(&format!("[Replay] Parse validation: {e:?} (non-fatal, delegating)"));
261
+ }
262
+ }
263
+
264
+ // Delegate to original for actual state population
265
+ delegate_to_original(state)
266
+ }
267
+
268
+ /// Delegate to original ReplayLoader trampoline (re-parses from scratch).
269
+ unsafe fn delegate_to_original(state: u32) -> Result<(), ReplayError> {
270
  let orig: unsafe extern "stdcall" fn(u32, i32) -> u32 =
271
  core::mem::transmute(REPLAY_LOADER_ORIG);
272
  let result = orig(state, 1);
273
+ if result == 0 { Ok(()) } else { Err(ReplayError::FileNotFound) }
274
+ }
275
+
276
+ // ─── Parsed replay info ─────────────────────────────────────────────────────
277
+
278
+ struct ReplayInfo {
279
+ game_version_id: i32,
280
+ scheme_version: u8,
281
+ team_count: u8,
282
+ observer_count: u8,
283
+ }
284
+
285
+ // ─── Version 2+ payload parser (pure, no global writes) ─────────────────────
286
+
287
+ /// Parse the second payload of a version 2+ replay file.
288
+ /// Returns parsed info for validation. Does NOT write to global memory.
289
+ unsafe fn parse_v2plus_payload(
290
+ data: &[u8],
291
+ version: u32,
292
+ ) -> Result<ReplayInfo, ReplayError> {
293
+ let mut s = ReplayStream::new(data);
294
+
295
+ // ─── Sub-format flags (version >= 10) ────────────────────────────────
296
+
297
+ let mut obs_count: u16 = 0;
298
+
299
+ if version >= 10 {
300
+ let sub_format = s.read_u16()?;
301
+ if sub_format != 0 {
302
+ return Err(ReplayError::VersionTooNew);
303
+ }
304
+
305
+ if version >= 12 {
306
+ if version < 18 {
307
+ let _observer_mode = s.read_u8_validated(0, 2)?;
308
+ } else {
309
+ let _raw = s.read_u8_validated(0, 3)?;
310
+ }
311
+ }
312
+
313
+ obs_count = s.read_u16_validated(1, version as u16)?;
314
+
315
+ // Observer team loop: (4-byte ID, 1-byte type) until type == 0
316
+ loop {
317
+ let _team_id = s.read_u32()?;
318
+ let obs_type = s.read_u8_validated(0, 2)?;
319
+ if obs_type == 0 { break; }
320
+ }
321
+ }
322
+
323
+ // ─── Game version ID ─────────────────────────────────────────────────
324
+
325
+ let game_version_id = s.read_i32()?;
326
+ if (game_version_id.wrapping_add(4) as u32) > 0x1F8 {
327
+ return Err(ReplayError::VersionTooNew);
328
+ }
329
+
330
+ let _use_fixed_names = game_version_id >= 10;
331
+
332
+ // ─── Scheme presence flag ────────────────────────────────────────────
333
+
334
+ let scheme_present = s.read_u8_validated(1, 3)?;
335
+
336
+ // Extra field for version 7-9 only (transitional)
337
+ if version >= 7 && version <= 9 {
338
+ let _extra = s.read_u32()?;
339
+ }
340
+
341
+ // ─── Scheme data ─────────────────────────────────────────────────────
342
+
343
+ let mut scheme_version: u8 = 0;
344
+
345
+ if scheme_present == 1 {
346
+ // Scheme header byte (obs_count >= 3)
347
+ if obs_count >= 3 {
348
+ let _scheme_header = s.read_u8()?;
349
+ }
350
+
351
+ // Scheme size indicator (obs_count >= 0x14)
352
+ let mut scheme_size_indicator: u32 = 0;
353
+ if obs_count >= 0x14 {
354
+ scheme_size_indicator = s.read_u32()?;
355
+ }
356
+
357
+ // SCHM magic + version byte
358
+ let schm_magic = s.read_u32()?;
359
+ scheme_version = s.read_u8()?;
360
+
361
+ if schm_magic != 0x4D48_4353 {
362
+ return Err(ReplayError::InvalidFormat);
363
+ }
364
+
365
+ // Scheme data: v1=216, v2=292, v3=variable
366
+ let scheme_data_size = match scheme_version {
367
+ 1 => 0xD8_usize,
368
+ 2 => 0x124,
369
+ 3 => {
370
+ if scheme_size_indicator < 0x12A || scheme_size_indicator > 0x197 {
371
+ return Err(ReplayError::InvalidFormat);
372
+ }
373
+ (scheme_size_indicator as usize) - 5
374
+ }
375
+ _ => return Err(ReplayError::VersionTooNew),
376
+ };
377
 
378
+ s.skip(scheme_data_size)?;
379
+
380
+ // Random seed (u32)
381
+ let _random_seed = s.read_u32()?;
382
  } else {
383
+ // No scheme: terrain type byte (obs_count >= 13)
384
+ if obs_count >= 13 {
385
+ let _terrain_type = s.read_u8()?;
386
+ }
387
+ }
388
+
389
+ // Map config bytes + replay name + host index
390
+ let _map_byte1 = s.read_u8()?;
391
+ let _map_byte2 = s.read_u8()?;
392
+
393
+ let mut _replay_name = [0u8; 0x29];
394
+ s.read_prefixed_string(&mut _replay_name)?;
395
+
396
+ if version >= 9 {
397
+ let _host_index = s.read_u8()?;
398
  }
399
+
400
+ // ─── Observer player entries (13 slots) ──────────────────────────────
401
+
402
+ let mut observer_count: u8 = 0;
403
+ for _ in 0..13u32 {
404
+ let flag = s.read_u8()?;
405
+ if flag == 0 { continue; }
406
+ observer_count += 1;
407
+
408
+ let mut _name = [0u8; 0x11];
409
+ s.read_prefixed_string(&mut _name)?;
410
+ let mut _display = [0u8; 0x31];
411
+ s.read_prefixed_string(&mut _display)?;
412
+ let mut _config = [0u8; 0x29];
413
+ s.read_prefixed_string(&mut _config)?;
414
+
415
+ let _u16_field = s.read_u16()?;
416
+ let _byte1 = s.read_u8()?;
417
+ let _u32_field = s.read_u32()?;
418
+ let _byte2 = s.read_u8()?;
419
+ }
420
+
421
+ // ─── XOR game ID + team entries ──────────────────────────────────────
422
+ // TODO: Team parsing needs more decompilation work.
423
+ // The per-team structure (flag, type, alliance, worm names, weapon blocks)
424
+ // has version-dependent fields that need careful tracing from assembly.
425
+ // For now, return what we've successfully parsed.
426
+
427
+ Ok(ReplayInfo {
428
+ game_version_id,
429
+ scheme_version,
430
+ team_count: 0, // TODO: parse teams
431
+ observer_count,
432
+ })
433
  }
434
 
435
  // ─── ParseReplayPosition full replacement ────────────────────────────────────
 
438
  let mut len = 0usize;
439
  while *input.add(len) != 0 {
440
  len += 1;
441
+ if len > 256 { break; }
 
 
442
  }
443
  let slice = core::slice::from_raw_parts(input, len + 1);
444
  replay::parse_replay_position(slice)
 
453
  va::REPLAY_LOADER,
454
  hook_replay_loader as *const (),
455
  )? as *const ();
 
456
  PARSE_POSITION_ORIG = hook::install(
457
  "ParseReplayPosition",
458
  va::PARSE_REPLAY_POSITION,