feat: replace Scheme__ReadFile, ValidateExtendedOptions, FileExists with Rust

Three WA.exe scheme functions now fully replaced by Rust implementations:

- Scheme__ReadFile (0x4D3890): Rust file I/O via SchemeFile parser,
writes payload to dest struct matching original memory layout for
V1/V2/V3 schemes. Gameplay modifier globals not yet ported.
- Scheme__ValidateExtendedOptions (0x4D5110): naked asm trampoline
(EAX implicit param) calling ExtendedOptions::validate_bytes()
with 60+ field checks matching Ghidra decompilation.
- Scheme__FileExists (0x4D4CD0): stdcall replacement using
std::path::Path::exists().

Also fixes SchemeVersion enum: replaces Extended(u8) with explicit V3
variant, from_byte() now returns Option for unknown versions, adds
SCHEME_PAYLOAD_V3 constant.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

crates/openwa-types/src/address.rs

@@ -248,6 +248,8 @@ pub mod va {
     pub const SCHEME_V3_DEFAULTS: u32 = 0x0064_9AB8;
     /// Per-weapon max ammo table (39 bytes), used by CheckWeaponLimits
     pub const SCHEME_WEAPON_AMMO_LIMITS: u32 = 0x006A_D130;
+    /// Guard global for gameplay modifier application in ReadFile (nonzero = apply modifiers)
+    pub const SCHEME_MODIFIER_GUARD: u32 = 0x0088_E460;
 
     // === Lobby / network ===
 

crates/openwa-types/src/scheme.rs

@@ -28,6 +28,9 @@ pub const SCHEME_PAYLOAD_V1: usize = 0xD8;
 /// Payload size for version 2 schemes.
 pub const SCHEME_PAYLOAD_V2: usize = 0x124;
 
+/// Payload size for version 3 schemes.
+pub const SCHEME_PAYLOAD_V3: usize = 0x192;
+
 /// Scheme file version.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SchemeVersion {
@@ -35,8 +38,9 @@ pub enum SchemeVersion {
     V1,
     /// Version 2: 0x124 byte payload (total file: 297 bytes)
     V2,
-    /// Extended: payload = version_byte + 0x124 bytes
-    Extended(u8),
+    /// Version 3: 0x192 byte payload (total file: 407 bytes)
+    /// V2 + 110 bytes extended options.
+    V3,
 }
 
 impl SchemeVersion {
@@ -45,16 +49,17 @@ impl SchemeVersion {
         match self {
             SchemeVersion::V1 => 1,
             SchemeVersion::V2 => 2,
-            SchemeVersion::Extended(v) => v,
+            SchemeVersion::V3 => 3,
         }
     }
 
-    /// Parse version from the raw byte.
-    pub fn from_byte(b: u8) -> Self {
+    /// Parse version from the raw byte. Returns `None` for unknown versions.
+    pub fn from_byte(b: u8) -> Option<Self> {
         match b {
-            1 => SchemeVersion::V1,
-            2 => SchemeVersion::V2,
-            v => SchemeVersion::Extended(v),
+            1 => Some(SchemeVersion::V1),
+            2 => Some(SchemeVersion::V2),
+            3 => Some(SchemeVersion::V3),
+            _ => None,
         }
     }
 
@@ -63,7 +68,7 @@ impl SchemeVersion {
         match self {
             SchemeVersion::V1 => SCHEME_PAYLOAD_V1,
             SchemeVersion::V2 => SCHEME_PAYLOAD_V2,
-            SchemeVersion::Extended(v) => v as usize + SCHEME_PAYLOAD_V2,
+            SchemeVersion::V3 => SCHEME_PAYLOAD_V3,
         }
     }
 }
@@ -75,6 +80,8 @@ pub enum SchemeError {
     TooShort { len: usize },
     /// Magic bytes don't match "SCHM".
     BadMagic([u8; 4]),
+    /// Unknown version byte (not 1, 2, or 3).
+    UnknownVersion(u8),
     /// Payload size doesn't match what the version byte expects.
     PayloadMismatch { expected: usize, got: usize },
 }
@@ -88,6 +95,9 @@ impl core::fmt::Display for SchemeError {
             SchemeError::BadMagic(m) => {
                 write!(f, "bad magic: {:02X} {:02X} {:02X} {:02X} (expected SCHM)", m[0], m[1], m[2], m[3])
             }
+            SchemeError::UnknownVersion(v) => {
+                write!(f, "unknown version byte: 0x{v:02X}")
+            }
             SchemeError::PayloadMismatch { expected, got } => {
                 write!(f, "payload size mismatch: expected {expected}, got {got}")
             }
@@ -119,7 +129,8 @@ impl SchemeFile {
             return Err(SchemeError::BadMagic(magic));
         }
 
-        let version = SchemeVersion::from_byte(data[4]);
+        let version = SchemeVersion::from_byte(data[4])
+            .ok_or(SchemeError::UnknownVersion(data[4]))?;
         let expected_payload = version.payload_size();
         let actual_payload = data.len() - SCHEME_HEADER_SIZE;
 
@@ -793,6 +804,85 @@ impl ExtendedOptions {
         b[0x6D] = self.double_time_stack_limit;
         b
     }
+
+    /// Validate raw extended options bytes (110 bytes) against WA's field constraints.
+    ///
+    /// Returns `true` if all fields are within valid ranges, exactly matching
+    /// the logic of `Scheme__ValidateExtendedOptions` (0x4D5110).
+    ///
+    /// Note: operates on raw bytes, not parsed struct fields, because WA validates
+    /// at the byte level (e.g., bool fields must be exactly 0x00 or 0x01).
+    pub fn validate_bytes(b: &[u8]) -> bool {
+        fn is_bool(v: u8) -> bool {
+            v == 0 || v == 1
+        }
+        fn is_tristate(v: u8) -> bool {
+            v == 0 || v == 1 || v == 0x80
+        }
+
+        read_u32_le(b, 0x00) == 0                                        // data_version
+        && (read_i32_le(b, 0x08) as u32).wrapping_sub(1) < 0xC8_0000     // gravity [1, 0xC80000]
+        && (read_i32_le(b, 0x0C) as u32) < 0x2_8CCD                     // terrain_friction
+        && is_bool(b[0x12])                                              // unrestrict_rope
+        && is_bool(b[0x13])                                              // auto_place_worms_by_ally
+        && is_bool(b[0x17])                                              // sd_disables_worm_select
+        && b[0x19] < 4                                                   // phased_worms_allied
+        && b[0x1A] < 4                                                   // phased_worms_enemy
+        && is_bool(b[0x1B])                                              // circular_aim
+        && is_bool(b[0x1C])                                              // anti_lock_aim
+        && is_bool(b[0x1D])                                              // anti_lock_power
+        && is_bool(b[0x1E])                                              // worm_select_no_end_hot_seat
+        && is_bool(b[0x1F])                                              // worm_select_never_cancelled
+        && is_bool(b[0x20])                                              // batty_rope
+        && b[0x21] < 3                                                   // rope_roll_drops
+        && (b[0x22] == 0 || b[0x22] == 0xFF)                             // x_impact_loss_of_control
+        && is_bool(b[0x23])                                              // keep_control_bump_head
+        && b[0x24] < 3                                                   // keep_control_skimming
+        && is_bool(b[0x25])                                              // explosion_fall_damage
+        && is_tristate(b[0x26])                                          // explosions_push_all
+        && is_tristate(b[0x27])                                          // undetermined_crates
+        && is_tristate(b[0x28])                                          // undetermined_fuses
+        && is_bool(b[0x29])                                              // pause_timer_while_firing
+        && is_bool(b[0x2A])                                              // loss_of_control_no_end_turn
+        && is_bool(b[0x2B])                                              // weapon_use_no_end_turn
+        && is_bool(b[0x2C])                                              // weapon_use_no_block
+        && is_tristate(b[0x2D])                                          // drill_imparts_velocity
+        && is_bool(b[0x2E])                                              // girder_radius_assist
+        && b[0x31] != 0                                                  // petrol_touch_decay nonzero
+        && read_u16_le(b, 0x32) != 0                                    // max_flamelet_count nonzero
+        && (read_i32_le(b, 0x34) as u32) < 0x8000_0000                  // max_projectile_speed > 0
+        && (read_i32_le(b, 0x38) as u32) < 0x8000_0000                  // max_rope_speed > 0
+        && (read_i32_le(b, 0x3C) as u32) < 0x8000_0000                  // max_jet_pack_speed > 0
+        && (read_i32_le(b, 0x40) as u32).wrapping_sub(0x1000) < 0x7F_F001 // game_engine_speed
+        && is_tristate(b[0x44])                                          // indian_rope_glitch
+        && is_tristate(b[0x45])                                          // herd_doubling_glitch
+        && is_bool(b[0x46])                                              // jet_pack_bungee_glitch
+        && is_bool(b[0x47])                                              // angle_cheat_glitch
+        && is_bool(b[0x48])                                              // glide_glitch
+        && (b[0x49] as i8 as i32 + 1) as u32 <= 2                       // skipwalking {-1,0,1}
+        && b[0x4A] < 3                                                   // block_roofing
+        && is_bool(b[0x4B])                                              // floating_weapon_glitch
+        && (read_i32_le(b, 0x4C) as u32) < 0x1_0001                     // rw_bounciness
+        && (read_i32_le(b, 0x50) as u32) < 0x4001                       // rw_air_viscosity
+        && is_bool(b[0x54])                                              // rw_air_viscosity_worms
+        && read_u32_le(b, 0x55) < 0x1_0001                              // rw_wind_influence
+        && is_bool(b[0x59])                                              // rw_wind_influence_worms
+        && b[0x5A] < 4                                                   // rw_gravity_type
+        && (read_i32_le(b, 0x5B) as u32).wrapping_add(0x4000_0000) < 0x8000_0001 // rw_gravity_strength
+        && is_bool(b[0x60])                                              // rw_crate_shower
+        && is_bool(b[0x61])                                              // rw_anti_sink
+        && is_bool(b[0x62])                                              // rw_remember_weapons
+        && is_bool(b[0x63])                                              // rw_extended_fuses
+        && is_bool(b[0x64])                                              // rw_anti_lock_aim
+        && is_tristate(b[0x65])                                          // terrain_overlap_glitch
+        && is_bool(b[0x66])                                              // fractional_round_timer
+        && is_bool(b[0x67])                                              // auto_retreat
+        && (b[0x68] as i8 as i32 + 1) as u32 <= 3                       // health_crates_cure_poison
+        && b[0x69] < 6                                                   // rw_kaos_mod
+        && b[0x6A].wrapping_sub(1) < 7                                   // sheep_heavens_gate [1,7]
+        && is_bool(b[0x6B])                                              // conserve_instant_utilities
+        && is_bool(b[0x6C])                                              // expedite_instant_utilities
+    }
 }
 
 /// V3 extended options defaults from WA.exe ROM at 0x649AB8 (110 bytes).
@@ -895,16 +985,19 @@ mod tests {
 
     #[test]
     fn version_roundtrip() {
-        for v in [SchemeVersion::V1, SchemeVersion::V2, SchemeVersion::Extended(5)] {
-            assert_eq!(SchemeVersion::from_byte(v.to_byte()), v);
+        for v in [SchemeVersion::V1, SchemeVersion::V2, SchemeVersion::V3] {
+            assert_eq!(SchemeVersion::from_byte(v.to_byte()), Some(v));
         }
+        // Unknown versions return None
+        assert_eq!(SchemeVersion::from_byte(0), None);
+        assert_eq!(SchemeVersion::from_byte(4), None);
     }
 
     #[test]
     fn payload_sizes() {
         assert_eq!(SchemeVersion::V1.payload_size(), 0xD8);
         assert_eq!(SchemeVersion::V2.payload_size(), 0x124);
-        assert_eq!(SchemeVersion::Extended(3).payload_size(), 3 + 0x124);
+        assert_eq!(SchemeVersion::V3.payload_size(), 0x192);
     }
 
     #[test]

crates/openwa-types/tests/scheme_parse.rs

@@ -1,7 +1,8 @@
 use std::path::Path;
 
 use openwa_types::scheme::{
-    SchemeFile, SchemeVersion, SCHEME_PAYLOAD_V1, SCHEME_PAYLOAD_V2, WEAPONS_V1_COUNT,
+    ExtendedOptions, SchemeFile, SchemeVersion, EXTENDED_OPTIONS_DEFAULTS,
+    EXTENDED_OPTIONS_SIZE, SCHEME_PAYLOAD_V1, SCHEME_PAYLOAD_V2, WEAPONS_V1_COUNT,
 };
 
 const FIXTURES: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures");
@@ -207,3 +208,142 @@ fn parse_all_game_schemes() {
     }
     eprintln!("Successfully parsed and round-tripped {count} scheme files");
 }
+
+// === ExtendedOptions validation tests ===
+
+/// Build a valid 110-byte extended options buffer from scratch.
+/// ROM defaults contain intentionally invalid V3 values (0x80 in bool fields),
+/// so we construct a minimal valid buffer instead.
+fn make_valid_extended_options() -> [u8; EXTENDED_OPTIONS_SIZE] {
+    let mut b = [0u8; EXTENDED_OPTIONS_SIZE];
+    // data_version = 0 (already zero)
+    // gravity must be >= 1
+    b[0x08..0x0C].copy_from_slice(&1i32.to_le_bytes());
+    // terrain_friction < 0x28CCD (leave at 0 — valid)
+    // petrol_touch_decay must be nonzero
+    b[0x31] = 1;
+    // max_flamelet_count must be nonzero
+    b[0x32..0x34].copy_from_slice(&1u16.to_le_bytes());
+    // speeds must be positive (> 0)
+    b[0x34..0x38].copy_from_slice(&1i32.to_le_bytes()); // max_projectile_speed
+    b[0x38..0x3C].copy_from_slice(&1i32.to_le_bytes()); // max_rope_speed
+    b[0x3C..0x40].copy_from_slice(&1i32.to_le_bytes()); // max_jet_pack_speed
+    // game_engine_speed in [0x1000, 0x800000]
+    b[0x40..0x44].copy_from_slice(&0x10000i32.to_le_bytes());
+    // sheep_heavens_gate in [1, 7]
+    b[0x6A] = 1;
+    b
+}
+
+#[test]
+fn validate_valid_extended_options() {
+    let b = make_valid_extended_options();
+    assert!(ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_data_version() {
+    let mut b = make_valid_extended_options();
+    b[0x00] = 1; // data_version must be 0
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_gravity() {
+    let mut b = make_valid_extended_options();
+    // gravity = 0 (below minimum of 1)
+    b[0x08..0x0C].copy_from_slice(&0i32.to_le_bytes());
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    // gravity = negative
+    b[0x08..0x0C].copy_from_slice(&(-1i32).to_le_bytes());
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_bool() {
+    let mut b = make_valid_extended_options();
+    // unrestrict_rope at offset 0x12: value 2 is not a valid bool
+    b[0x12] = 2;
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_tristate() {
+    let mut b = make_valid_extended_options();
+    // explosions_push_all at offset 0x26: must be 0, 1, or 0x80
+    b[0x26] = 2;
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    // 0x80 should be valid
+    b[0x26] = 0x80;
+    assert!(ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_skipwalking() {
+    let mut b = make_valid_extended_options();
+    // skipwalking at 0x49: must be -1, 0, or 1
+    b[0x49] = 2u8; // 2 as i8 is invalid
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    // -1 (0xFF) should be valid
+    b[0x49] = 0xFF;
+    assert!(ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_zero_petrol_touch_decay() {
+    let mut b = make_valid_extended_options();
+    b[0x31] = 0; // must be nonzero
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_bad_sheep_heavens_gate() {
+    let mut b = make_valid_extended_options();
+    b[0x6A] = 0; // must be in [1, 7]
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    b[0x6A] = 8; // too high
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    b[0x6A] = 7; // max valid
+    assert!(ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rejects_negative_speeds() {
+    let mut b = make_valid_extended_options();
+    // max_projectile_speed at 0x34: must be positive
+    b[0x34..0x38].copy_from_slice(&(-1i32).to_le_bytes());
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_game_engine_speed_range() {
+    let mut b = make_valid_extended_options();
+
+    // Too low (below 0x1000)
+    b[0x40..0x44].copy_from_slice(&0xFFFi32.to_le_bytes());
+    assert!(!ExtendedOptions::validate_bytes(&b));
+
+    // Minimum valid (0x1000)
+    b[0x40..0x44].copy_from_slice(&0x1000i32.to_le_bytes());
+    assert!(ExtendedOptions::validate_bytes(&b));
+
+    // Maximum valid (0x800000)
+    b[0x40..0x44].copy_from_slice(&0x80_0000i32.to_le_bytes());
+    assert!(ExtendedOptions::validate_bytes(&b));
+
+    // Too high (0x800001)
+    b[0x40..0x44].copy_from_slice(&0x80_0001i32.to_le_bytes());
+    assert!(!ExtendedOptions::validate_bytes(&b));
+}
+
+#[test]
+fn validate_rom_defaults_fail_sheep_gate() {
+    // ROM defaults have sheep_heavens_gate=0, which is intentionally invalid.
+    // WA uses defaults as a fallback when V3 validation fails, but never validates them.
+    assert!(!ExtendedOptions::validate_bytes(&EXTENDED_OPTIONS_DEFAULTS));
+}

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

@@ -1,10 +1,12 @@
-//! Scheme file (.wsc) hook.
+//! Scheme file (.wsc) hooks.
 //!
-//! Hooks Scheme__ReadFile (0x4D3890) to log when schemes are loaded.
-//! Currently a passthrough — calls the original and logs the result.
-//! Future: replace the file I/O with our Rust SchemeFile parser.
+//! Replaces several WA.exe Scheme__ functions with Rust implementations:
+//! - Scheme__ReadFile (0x4D3890): full Rust file I/O using SchemeFile parser
+//! - Scheme__ValidateExtendedOptions (0x4D5110): pure Rust validation
+//! - Scheme__FileExists (0x4D4CD0): Rust path check
 
-use std::ffi::c_void;
+use std::ffi::{c_void, CStr};
+use std::path::Path;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use minhook::MinHook;
@@ -12,70 +14,273 @@ use minhook::MinHook;
 use crate::log_line;
 use crate::rebase::rb;
 use openwa_types::address::va;
+use openwa_types::scheme::{
+    ExtendedOptions, SchemeFile, SchemeVersion, EXTENDED_OPTIONS_DEFAULTS, EXTENDED_OPTIONS_SIZE,
+    SCHEME_PAYLOAD_V1, SCHEME_PAYLOAD_V2, SCHEME_PAYLOAD_V3,
+};
 
-/// Trampoline to original Scheme__ReadFile.
+// ============================================================
+// Scheme__ReadFile replacement (0x4D3890)
+// ============================================================
+
+/// Trampoline to original Scheme__ReadFile (for fallback on flag/out_ptr path).
 static ORIG_SCHEME_READ_FILE: AtomicU32 = AtomicU32::new(0);
 
-/// Hook for Scheme__ReadFile (0x4D3890).
+/// Dest struct offsets (WA runtime layout).
+const DEST_FLAG: usize = 0x04;
+const DEST_INDEX: usize = 0x08;
+const DEST_PAYLOAD: usize = 0x14;
+/// Offset within payload where super weapons start (V1 payload ends here).
+const PAYLOAD_SUPER_WEAPONS: usize = SCHEME_PAYLOAD_V1; // 0xD8
+/// Size of super weapons region to zero for V1 schemes.
+const SUPER_WEAPONS_SIZE: usize = SCHEME_PAYLOAD_V2 - SCHEME_PAYLOAD_V1; // 0x4C = 76
+/// Offset within payload where extended options start.
+const PAYLOAD_EXTENDED: usize = SCHEME_PAYLOAD_V2; // 0x124
+
+/// Write a parsed SchemeFile into the WA dest struct at the correct offsets.
+///
+/// Replicates the memory writes from Scheme__ReadFile:
+/// - V1: payload(0xD8) + zero super weapons(0x4C) + ROM defaults(0x6E)
+/// - V2: payload(0x124) + ROM defaults(0x6E)
+/// - V3: payload(0x192), with validation fallback to ROM defaults
+unsafe fn write_scheme_to_dest(scheme: &SchemeFile, dest: u32) {
+    let payload_ptr = (dest as usize + DEST_PAYLOAD) as *mut u8;
+
+    match scheme.version {
+        SchemeVersion::V1 => {
+            // Copy V1 payload (216 bytes)
+            core::ptr::copy_nonoverlapping(
+                scheme.payload.as_ptr(),
+                payload_ptr,
+                SCHEME_PAYLOAD_V1,
+            );
+            // Zero the super weapons region (76 bytes)
+            core::ptr::write_bytes(
+                payload_ptr.add(PAYLOAD_SUPER_WEAPONS),
+                0,
+                SUPER_WEAPONS_SIZE,
+            );
+            // Copy V3 defaults for extended options (110 bytes)
+            core::ptr::copy_nonoverlapping(
+                EXTENDED_OPTIONS_DEFAULTS.as_ptr(),
+                payload_ptr.add(PAYLOAD_EXTENDED),
+                EXTENDED_OPTIONS_SIZE,
+            );
+        }
+        SchemeVersion::V2 => {
+            // Copy V2 payload (292 bytes)
+            core::ptr::copy_nonoverlapping(
+                scheme.payload.as_ptr(),
+                payload_ptr,
+                SCHEME_PAYLOAD_V2,
+            );
+            // Copy V3 defaults for extended options (110 bytes)
+            core::ptr::copy_nonoverlapping(
+                EXTENDED_OPTIONS_DEFAULTS.as_ptr(),
+                payload_ptr.add(PAYLOAD_EXTENDED),
+                EXTENDED_OPTIONS_SIZE,
+            );
+        }
+        SchemeVersion::V3 => {
+            // Copy full V3 payload (402 bytes)
+            core::ptr::copy_nonoverlapping(
+                scheme.payload.as_ptr(),
+                payload_ptr,
+                SCHEME_PAYLOAD_V3,
+            );
+            // Validate extended options; if invalid, replace with defaults
+            let ext_bytes = &scheme.payload[PAYLOAD_EXTENDED..];
+            if !ExtendedOptions::validate_bytes(ext_bytes) {
+                core::ptr::copy_nonoverlapping(
+                    EXTENDED_OPTIONS_DEFAULTS.as_ptr(),
+                    payload_ptr.add(PAYLOAD_EXTENDED),
+                    EXTENDED_OPTIONS_SIZE,
+                );
+            }
+        }
+    }
+
+    // Set scheme index to 0xFFFFFFFF (unassigned)
+    *((dest as usize + DEST_INDEX) as *mut u32) = 0xFFFF_FFFF;
+}
+
+/// Rust replacement for Scheme__ReadFile (0x4D3890).
 /// stdcall(dest_struct, file_path, flag, out_ptr) -> u32, RET 0x10
 ///
-/// - dest_struct: pointer to destination scheme struct (payload written to +0x14)
-/// - file_path: scheme file path string
-/// - flag: boolean flag (passed to error display)
-/// - out_ptr: optional output byte pointer
-/// - returns: 0 on success, 0xFFFFFFFF on failure
+/// out_ptr is an output bool: 0 = no gameplay modifiers applied, 1 = modifiers applied.
+/// flag controls whether CheckWeaponLimits is called after loading.
+///
+/// TODO: Gameplay modifier globals (~20 fields at 0x88DBxx) are not yet ported.
+/// These are applied in online lobbies; for now we always report "no modifiers applied".
 unsafe extern "stdcall" fn hook_scheme_read_file(
     dest_struct: u32,
     file_path: u32,
-    flag: u32,
+    _flag: u32,
     out_ptr: u32,
 ) -> u32 {
-    // Read the scheme name from the file_path pointer
+    // Initialize out_ptr to 0 (no modifiers applied), matching original behavior
+    if out_ptr != 0 {
+        *(out_ptr as *mut u8) = 0;
+    }
+
+    // Read the path string
     let name = if file_path != 0 {
-        let cstr = std::ffi::CStr::from_ptr(file_path as *const i8);
-        cstr.to_string_lossy().into_owned()
+        match CStr::from_ptr(file_path as *const i8).to_str() {
+            Ok(s) => s,
+            Err(_) => {
+                let _ = log_line("[Scheme] ReadFile: invalid UTF-8 path, delegating to original");
+                return call_original_read_file(dest_struct, file_path, _flag, out_ptr);
+            }
+        }
     } else {
-        "<null>".to_string()
+        let _ = log_line("[Scheme] ReadFile: null path");
+        return 0xFFFF_FFFF;
     };
 
-    // Call original
+    // Use Rust parser for file I/O
+    let path = Path::new(name);
+    match SchemeFile::from_file(path) {
+        Ok(scheme) => {
+            write_scheme_to_dest(&scheme, dest_struct);
+
+            // Set flag byte to 0 and scheme index to 0xFFFFFFFF
+            *((dest_struct as usize + DEST_FLAG) as *mut u8) = 0;
+
+            let _ = log_line(&format!(
+                "[Scheme] ReadFile OK (Rust): {name} -> {:?}, dest=0x{dest_struct:08X}",
+                scheme.version
+            ));
+            0
+        }
+        Err(e) => {
+            let _ = log_line(&format!("[Scheme] ReadFile FAILED (Rust): {name}: {e}"));
+            0xFFFF_FFFF
+        }
+    }
+}
+
+/// Call the original Scheme__ReadFile via trampoline.
+#[inline]
+unsafe fn call_original_read_file(dest: u32, path: u32, flag: u32, out_ptr: u32) -> u32 {
     let orig: unsafe extern "stdcall" fn(u32, u32, u32, u32) -> u32 =
         core::mem::transmute(ORIG_SCHEME_READ_FILE.load(Ordering::Relaxed));
-    let result = orig(dest_struct, file_path, flag, out_ptr);
-
-    // Log the result
-    if result == 0 {
-        // Read the version byte from dest_struct+0x14 (first 5 bytes are the header)
-        // Actually the header is consumed during read; the payload starts at +0x14
-        let _ = log_line(&format!(
-            "[Scheme] Loaded: {name} -> dest=0x{dest_struct:08X}"
-        ));
+    orig(dest, path, flag, out_ptr)
+}
+
+// ============================================================
+// Scheme__ValidateExtendedOptions replacement (0x4D5110)
+// ============================================================
+
+/// Naked trampoline for Scheme__ValidateExtendedOptions.
+///
+/// WA calls this with EAX = pointer to 110-byte extended options data.
+/// Plain RET (no stack cleanup). Returns EAX: 0 = valid, 1 = invalid.
+#[unsafe(naked)]
+unsafe extern "C" fn trampoline_validate_ext_opts() {
+    core::arch::naked_asm!(
+        "push eax",         // push options pointer as arg
+        "call {impl_fn}",  // cdecl call
+        "add esp, 4",      // clean up our push
+        "ret",              // plain ret (no stack params to clean)
+        impl_fn = sym validate_extended_options_impl,
+    );
+}
+
+/// Rust implementation called by the naked trampoline.
+unsafe extern "cdecl" fn validate_extended_options_impl(options_ptr: u32) -> u32 {
+    let bytes = core::slice::from_raw_parts(options_ptr as *const u8, EXTENDED_OPTIONS_SIZE);
+    if ExtendedOptions::validate_bytes(bytes) {
+        0 // valid
     } else {
-        let _ = log_line(&format!(
-            "[Scheme] FAILED to load: {name} (result=0x{result:08X})"
-        ));
+        1 // invalid
     }
+}
+
+// ============================================================
+// Scheme__FileExists replacement (0x4D4CD0)
+// ============================================================
 
-    result
+/// Rust replacement for Scheme__FileExists (0x4D4CD0).
+/// stdcall(name) -> u32 (0 = not found, 1 = found), RET 0x4
+///
+/// Original: formats "User\Schemes\%s.wsc", opens with CFile.
+/// Rust: uses std::path::Path::exists().
+unsafe extern "stdcall" fn hook_scheme_file_exists(name: u32) -> u32 {
+    if name == 0 {
+        return 0;
+    }
+    let c_name = CStr::from_ptr(name as *const i8);
+    let name_str = c_name.to_string_lossy();
+    let path = format!("User\\Schemes\\{name_str}.wsc");
+    if Path::new(&path).exists() {
+        1
+    } else {
+        0
+    }
 }
 
+// ============================================================
+// Hook installation
+// ============================================================
+
 pub fn install() -> Result<(), String> {
     unsafe {
-        let target = rb(va::SCHEME_READ_FILE) as *mut c_void;
-        let detour = hook_scheme_read_file as *const () as *mut c_void;
+        // Hook Scheme__ReadFile (0x4D3890) — full Rust replacement
+        {
+            let target = rb(va::SCHEME_READ_FILE) as *mut c_void;
+            let detour = hook_scheme_read_file as *const () as *mut c_void;
+
+            let trampoline = MinHook::create_hook(target, detour)
+                .map_err(|e| format!("MinHook create_hook failed for Scheme__ReadFile: {e}"))?;
+
+            MinHook::enable_hook(target)
+                .map_err(|e| format!("MinHook enable_hook failed for Scheme__ReadFile: {e}"))?;
+
+            ORIG_SCHEME_READ_FILE.store(trampoline as u32, Ordering::Relaxed);
+
+            let _ = log_line(&format!(
+                "  [REPLACE] Scheme__ReadFile: target 0x{:08X}, trampoline 0x{:08X}",
+                target as u32, trampoline as u32
+            ));
+        }
+
+        // Hook Scheme__ValidateExtendedOptions (0x4D5110) — full Rust replacement
+        {
+            let target = rb(va::SCHEME_VALIDATE_EXTENDED_OPTIONS) as *mut c_void;
+            let detour = trampoline_validate_ext_opts as *const () as *mut c_void;
+
+            MinHook::create_hook(target, detour).map_err(|e| {
+                format!("MinHook create_hook failed for ValidateExtendedOptions: {e}")
+            })?;
+
+            MinHook::enable_hook(target).map_err(|e| {
+                format!("MinHook enable_hook failed for ValidateExtendedOptions: {e}")
+            })?;
+
+            let _ = log_line(&format!(
+                "  [REPLACE] Scheme__ValidateExtendedOptions: target 0x{:08X}",
+                target as u32
+            ));
+        }
 
-        let trampoline = MinHook::create_hook(target, detour)
-            .map_err(|e| format!("MinHook create_hook failed for Scheme__ReadFile: {e}"))?;
+        // Hook Scheme__FileExists (0x4D4CD0) — full Rust replacement
+        {
+            let target = rb(va::SCHEME_FILE_EXISTS) as *mut c_void;
+            let detour = hook_scheme_file_exists as *const () as *mut c_void;
 
-        MinHook::enable_hook(target)
-            .map_err(|e| format!("MinHook enable_hook failed for Scheme__ReadFile: {e}"))?;
+            MinHook::create_hook(target, detour).map_err(|e| {
+                format!("MinHook create_hook failed for Scheme__FileExists: {e}")
+            })?;
 
-        ORIG_SCHEME_READ_FILE.store(trampoline as u32, Ordering::Relaxed);
+            MinHook::enable_hook(target).map_err(|e| {
+                format!("MinHook enable_hook failed for Scheme__FileExists: {e}")
+            })?;
 
-        let _ = log_line(&format!(
-            "  [HOOK] Scheme__ReadFile: target 0x{:08X}, trampoline 0x{:08X}",
-            target as u32, trampoline as u32
-        ));
+            let _ = log_line(&format!(
+                "  [REPLACE] Scheme__FileExists: target 0x{:08X}",
+                target as u32
+            ));
+        }
     }
 
     Ok(())