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

refactor: split ReplayLoader into parse_version1 and parse_version2plus

Browse files

Restructured replay_loader_play to dispatch to version-specific
functions after header parsing. parse_version1 and parse_version2plus
both delegate to original for now, but parse_version2plus reads the
second payload (6800 bytes for bots.WAgame) before delegating.

Clean separation for incremental replacement of field parsing.

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

crates/openwa-wormkit/src/replacements/replay.rs CHANGED
@@ -21,54 +21,46 @@ use core::ptr;
21
  #[allow(non_camel_case_types)]
22
  type FILE = c_void;
23
 
24
- /// WA's fopen (0x5D3271)
25
  unsafe fn wa_fopen(filename: *const u8, mode: *const u8) -> *mut FILE {
26
  let f: unsafe extern "cdecl" fn(*const u8, *const u8) -> *mut FILE =
27
  core::mem::transmute(rb(0x005D_3271));
28
  f(filename, mode)
29
  }
30
 
31
- /// WA's fclose (0x5D399B)
32
  unsafe fn wa_fclose(stream: *mut FILE) {
33
  let f: unsafe extern "cdecl" fn(*mut FILE) = core::mem::transmute(rb(0x005D_399B));
34
  f(stream);
35
  }
36
 
37
- /// WA's fread wrapper (0x5D4531): fread(buf, size, count, file) β†’ items read
38
  unsafe fn wa_fread(buf: *mut c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
39
  let f: unsafe extern "cdecl" fn(*mut c_void, u32, u32, *mut FILE) -> u32 =
40
  core::mem::transmute(rb(0x005D_4531));
41
  f(buf, size, count, file)
42
  }
43
 
44
- /// WA's _fwrite (0x5D3B76)
45
  unsafe fn wa_fwrite(buf: *const c_void, size: u32, count: u32, file: *mut FILE) -> u32 {
46
  let f: unsafe extern "cdecl" fn(*const c_void, u32, u32, *mut FILE) -> u32 =
47
  core::mem::transmute(rb(0x005D_3B76));
48
  f(buf, size, count, file)
49
  }
50
 
51
- /// WA's malloc (0x5D0F65 β†’ calls through to MSVC CRT malloc)
52
  unsafe fn wa_malloc(size: u32) -> *mut u8 {
53
  let f: unsafe extern "cdecl" fn(u32) -> *mut u8 =
54
  core::mem::transmute(rb(0x005D_0F65));
55
  f(size)
56
  }
57
 
58
- /// WA's free (0x5D0D2B)
59
  unsafe fn wa_free(ptr: *mut u8) {
60
  let f: unsafe extern "cdecl" fn(*mut u8) = core::mem::transmute(rb(0x005D_0D2B));
61
  f(ptr);
62
  }
63
 
64
- /// WA's _fileno (0x5D5155)
65
  unsafe fn wa_fileno(stream: *mut FILE) -> i32 {
66
  let f: unsafe extern "cdecl" fn(*mut FILE) -> i32 =
67
  core::mem::transmute(rb(0x005D_5155));
68
  f(stream)
69
  }
70
 
71
- /// WA's _filelengthi64 (0x5D4FE1)
72
  unsafe fn wa_filelengthi64(fd: i32) -> i64 {
73
  let f: unsafe extern "cdecl" fn(i32) -> i64 = core::mem::transmute(rb(0x005D_4FE1));
74
  f(fd)
@@ -86,7 +78,6 @@ static mut PARSE_POSITION_ORIG: *const () = core::ptr::null();
86
 
87
  // ─── RAII cleanup guard ─────────────────────────────────────────────────────
88
 
89
- /// Ensures file handle and malloc'd buffer are freed on all exit paths.
90
  struct ReplayGuard {
91
  file: *mut FILE,
92
  payload: *mut u8,
@@ -114,48 +105,39 @@ impl Drop for ReplayGuard {
114
  }
115
  }
116
 
117
- // ─── ReplayLoader replacement ────────────────────────────────────────────────
118
 
119
- /// ReplayLoader: stdcall(state: u32, mode: i32) -> u32. RET 0x8.
120
  unsafe extern "stdcall" fn hook_replay_loader(state: u32, mode: i32) -> u32 {
121
- // Modes other than 1 (play): delegate to original
122
  if mode != 1 {
123
  let orig: unsafe extern "stdcall" fn(u32, i32) -> u32 =
124
  core::mem::transmute(REPLAY_LOADER_ORIG);
125
  return orig(state, mode);
126
  }
127
 
128
- // Mode 1 (play): Rust implementation
129
  match replay_loader_play(state) {
130
  Ok(()) => 0u32,
131
  Err(e) => e as i32 as u32,
132
  }
133
  }
134
 
135
- /// Rust implementation of ReplayLoader mode 1 (play).
136
- ///
137
- /// Currently: artclass guard + delegation to original.
138
- /// Incrementally replacing sections (header, payload, version parsing).
139
  unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
140
  let _ = log_line(&format!(
141
- "[Replay] ReplayLoader Rust path: state=0x{state:08X}"
142
  ));
143
 
144
- // Guard: ArtClass counter. Assembly: CMP [0x88c790], 0x34; JL ok
145
- // JL = signed less-than. Counter can be -1 (0xFFFFFFFF) which passes.
146
  let artclass_counter = *(rb(va::G_ARTCLASS_COUNTER) as *const i32);
147
  if artclass_counter >= 0x34 {
148
  return Err(ReplayError::ArtClassLimit);
149
  }
150
 
151
  let s = state as *mut u8;
152
-
153
- // Set replay active flag and init counter (same as original)
154
  *s.add(0xDB48) = 1;
155
  *(s.add(0xEF60) as *mut u32) = 0;
156
 
157
- // ─── Header: open file, read magic, validate version ─────────────────
158
-
159
  SetCurrentDirectoryA(rb(0x0088_E078) as *const u8);
160
  let file = wa_fopen(s.add(0xDB60), b"rb\0".as_ptr());
161
  SetCurrentDirectoryA(rb(0x0088_E17D) as *const u8);
@@ -167,11 +149,10 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
167
  let mut guard = ReplayGuard::new();
168
  guard.file = file;
169
 
170
- // File size
171
  let fd = wa_fileno(file);
172
  let file_size = wa_filelengthi64(fd) as u64;
173
 
174
- // Read 4-byte header
175
  let mut header: u32 = 0;
176
  if wa_fread(&mut header as *mut u32 as *mut c_void, 4, 1, file) == 0 {
177
  return Err(ReplayError::InvalidFormat);
@@ -180,7 +161,6 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
180
  return Err(ReplayError::InvalidFormat);
181
  }
182
 
183
- // Version: upper 16 bits, valid 1..=20
184
  let version = header >> 16;
185
  if version == 0 || version > 20 {
186
  return Err(ReplayError::VersionTooNew);
@@ -190,7 +170,7 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
190
  *(s.add(0xDB54) as *mut u32) = version;
191
  *(s.add(0xDB58) as *mut u32) = 0xFFFF_FFFF;
192
 
193
- // Payload size
194
  let mut payload_size: u32 = 0;
195
  if wa_fread(&mut payload_size as *mut u32 as *mut c_void, 4, 1, file) == 0 {
196
  return Err(ReplayError::InvalidFormat);
@@ -199,24 +179,21 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
199
  return Err(ReplayError::InvalidFormat);
200
  }
201
 
202
- // Read payload
203
  let payload = wa_malloc(payload_size);
204
  if payload.is_null() {
205
  return Err(ReplayError::MallocFailure);
206
  }
207
  guard.payload = payload;
208
-
209
  if wa_fread(payload as *mut c_void, payload_size, 1, file) == 0 {
210
  return Err(ReplayError::FileNotFound);
211
  }
212
 
213
- // ─── First dword: sub-version / content type ─────────────────────────
214
-
215
  let first_dword = *(payload as *const i32);
216
  *(s.add(0xDB1C) as *mut i32) = first_dword;
217
 
218
  if first_dword >= 1 {
219
- // Write payload to playback.thm
220
  let thm = wa_fopen(b"data\\playback.thm\0".as_ptr(), b"wb\0".as_ptr());
221
  if !thm.is_null() {
222
  wa_fwrite(payload as *const c_void, 1, payload_size, thm);
@@ -236,34 +213,109 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
236
  }
237
  }
238
 
239
- // Free payload and close file
240
  wa_free(payload);
241
  guard.payload = ptr::null_mut();
242
- wa_fclose(file);
243
- guard.file = ptr::null_mut();
244
-
245
- // ─── Clear global buffers ────────────────────────────────────────────
246
 
 
247
  core::ptr::write_bytes(rb(va::G_TEAM_HEADER_DATA) as *mut u8, 0, 0x5728);
248
  core::ptr::write_bytes(rb(va::G_TEAM_SECONDARY_DATA) as *mut u8, 0, 0xD9DC);
249
 
250
  let _ = log_line(&format!(
251
- "[Replay] Header OK: ver={version} payload={payload_size} sub={}",
252
- first_dword
253
  ));
254
 
255
- // ─── Delegate version-specific parsing to original ───────────────────
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
256
  //
257
- // The original re-parses from scratch. This is safe for read-only mode 1.
258
- // We've already set up DB48/EF60/DB50/DB54/DB58/DB1C and cleared globals,
259
- // which the original will overwrite with identical values.
 
 
260
 
261
- let _ = log_line("[Replay] Delegating to original for version-specific parsing");
262
  let orig: unsafe extern "stdcall" fn(u32, i32) -> u32 =
263
  core::mem::transmute(REPLAY_LOADER_ORIG);
264
  let result = orig(state, 1);
265
 
266
  if result == 0 {
 
267
  Ok(())
268
  } else {
269
  let _ = log_line(&format!("[Replay] Original error: {}", result as i32));
@@ -273,7 +325,6 @@ unsafe fn replay_loader_play(state: u32) -> Result<(), ReplayError> {
273
 
274
  // ─── ParseReplayPosition full replacement ────────────────────────────────────
275
 
276
- /// ParseReplayPosition: stdcall(input: *const u8) -> i32. RET 0x4.
277
  unsafe extern "stdcall" fn hook_parse_replay_position(input: *const u8) -> i32 {
278
  let mut len = 0usize;
279
  while *input.add(len) != 0 {
 
21
  #[allow(non_camel_case_types)]
22
  type FILE = c_void;
23
 
 
24
  unsafe fn wa_fopen(filename: *const u8, mode: *const u8) -> *mut FILE {
25
  let f: unsafe extern "cdecl" fn(*const u8, *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)
 
78
 
79
  // ─── RAII cleanup guard ─────────────────────────────────────────────────────
80
 
 
81
  struct ReplayGuard {
82
  file: *mut FILE,
83
  payload: *mut u8,
 
105
  }
106
  }
107
 
108
+ // ─── ReplayLoader hook ──────────────────────────────────────────────────────
109
 
 
110
  unsafe extern "stdcall" fn hook_replay_loader(state: u32, mode: i32) -> u32 {
 
111
  if mode != 1 {
112
  let orig: unsafe extern "stdcall" fn(u32, 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,
120
  }
121
  }
122
 
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);
134
  }
135
 
136
  let s = state as *mut u8;
 
 
137
  *s.add(0xDB48) = 1;
138
  *(s.add(0xEF60) as *mut u32) = 0;
139
 
140
+ // Open replay file
 
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);
 
149
  let mut guard = ReplayGuard::new();
150
  guard.file = file;
151
 
 
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);
 
161
  return Err(ReplayError::InvalidFormat);
162
  }
163
 
 
164
  let version = header >> 16;
165
  if version == 0 || version > 20 {
166
  return Err(ReplayError::VersionTooNew);
 
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);
 
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);
186
  }
187
  guard.payload = payload;
 
188
  if wa_fread(payload as *mut c_void, payload_size, 1, file) == 0 {
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() {
199
  wa_fwrite(payload as *const c_void, 1, payload_size, thm);
 
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
 
220
+ // Clear global buffers
221
  core::ptr::write_bytes(rb(va::G_TEAM_HEADER_DATA) as *mut u8, 0, 0x5728);
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
229
+ if version == 1 {
230
+ parse_version1(state, file, &mut guard)
231
+ } else {
232
+ parse_version2plus(state, version, file, file_size, payload_size, &mut guard)
233
+ }
234
+ }
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);
287
+ }
288
+ guard.payload = payload2;
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));
 
325
 
326
  // ─── ParseReplayPosition full replacement ────────────────────────────────────
327
 
 
328
  unsafe extern "stdcall" fn hook_parse_replay_position(input: *const u8) -> i32 {
329
  let mut len = 0usize;
330
  while *input.add(len) != 0 {