feat: port PaletteContext__MapColor to Rust with global hook

Pure Rust reimplementation of the palette color mapping function
(0x5412B0). All 10 callers now use the Rust version via MinHook detour.

Uses raw pointer ops to match WA's cache overflow behavior (cache_count
can reach 256, writing past the cache array into the dirty field) and
to avoid noalias miscompilation.

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

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

@@ -1,5 +1,6 @@
 pub mod gfx_dir;
 pub mod landscape;
+pub mod palette;
 pub mod queue;
 pub mod spr;
 pub mod sprite;

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

@@ -0,0 +1,89 @@
+//! Palette context — maps RGB colors to display palette indices.
+//!
+//! WA's `PaletteContext` maintains a 256-entry palette with a free-slot
+//! allocator and a recently-mapped cache for fast repeated lookups.
+
+/// PaletteContext struct layout.
+///
+/// Used by `PaletteContext__MapColor` (0x5412B0) and related functions.
+/// May be embedded in a larger composite object (e.g. GfxDir + palette data).
+#[repr(C)]
+pub struct PaletteContext {
+    /// +0x00: Unknown (possibly vtable or parent object field).
+    pub _unknown_00: u32,
+    /// +0x04: RGB values stored per palette index (24-bit RGB in low 3 bytes).
+    pub rgb_table: [u32; 256],
+    /// +0x404: In-use flag per palette index (1 = allocated).
+    pub in_use: [u8; 256],
+    /// +0x504: Number of free slots remaining in the free stack.
+    pub free_count: i16,
+    /// +0x506: Free slot index stack (LIFO). Entries are palette indices.
+    pub free_stack: [u8; 256],
+    /// +0x606: Number of entries in the recently-mapped cache.
+    pub cache_count: i16,
+    /// +0x608: Recently-mapped palette indices (cache for fast lookup).
+    pub cache: [u8; 256],
+    /// +0x708: Dirty flag (set to 1 when a new slot is allocated).
+    pub dirty: u16,
+}
+
+const _: () = assert!(core::mem::offset_of!(PaletteContext, rgb_table) == 0x04);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, in_use) == 0x404);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, free_count) == 0x504);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, free_stack) == 0x506);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, cache_count) == 0x606);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, cache) == 0x608);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, dirty) == 0x708);
+
+/// Map an RGB color to the nearest display palette index.
+///
+/// Rust port of `PaletteContext__MapColor` (0x5412B0). Operates on a raw
+/// pointer to WA's PaletteContext struct.
+///
+/// Algorithm:
+/// 1. Search the recently-mapped cache for an exact 24-bit RGB match
+/// 2. On miss: pop a free slot, store the RGB, add to cache, return new index
+/// 3. If no free slots: return 0xFFFFFFFF
+///
+/// # Safety
+///
+/// `ctx` must point to a valid WA PaletteContext struct.
+pub unsafe fn palette_map_color(ctx: *mut PaletteContext, rgb: u32) -> u32 {
+    // Raw pointer ops throughout — no &mut to avoid noalias miscompilation,
+    // and to match WA's overflow behavior when cache_count reaches 256
+    // (writes past cache[] into dirty field, which is then set to 1 anyway).
+    let p = ctx as *mut u8;
+
+    let cache_count = *(p.add(0x606) as *const i16);
+
+    // Search cache for matching RGB (24-bit compare)
+    for i in 0..cache_count as usize {
+        let idx = *p.add(0x608 + i) as usize;
+        if idx != 0 && (*(p.add(0x04 + idx * 4) as *const u32) ^ rgb) & 0xFF_FFFF == 0 {
+            return idx as u32;
+        }
+    }
+
+    // Cache miss — allocate a free slot
+    let free_count = *(p.add(0x504) as *const i16);
+    if free_count <= 0 {
+        return 0xFFFF_FFFF;
+    }
+
+    let new_free_count = free_count - 1;
+    *(p.add(0x504) as *mut i16) = new_free_count;
+    let slot = *p.add(0x506 + new_free_count as usize);
+    let slot_idx = slot as usize;
+
+    // Add to cache (may overflow into dirty field at +0x708 when cache is full —
+    // matches WA behavior, and dirty is set to 1 immediately after anyway)
+    *p.add(0x608 + cache_count as usize) = slot;
+    *(p.add(0x606) as *mut i16) = cache_count + 1;
+
+    // Store RGB and mark in-use
+    *(p.add(0x04 + slot_idx * 4) as *mut u32) = rgb;
+    *p.add(0x404 + slot_idx) = 1;
+    *(p.add(0x708) as *mut u16) = 1;
+
+    slot_idx as u32
+}

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

@@ -42,14 +42,17 @@ unsafe extern "cdecl" fn construct_sprite_impl(sprite: u32, context: u32) {
 usercall_trampoline!(fn trampoline_process_sprite; impl_fn = process_sprite_impl;
     regs = [eax, ecx]; stack_params = 1; ret_bytes = "0x4");
 
-static mut PALETTE_MAP_COLOR_ADDR: u32 = 0;
-
-/// Call WA's PaletteContext__MapColor to find the nearest display palette index.
-#[cfg(target_arch = "x86")]
-unsafe fn palette_map_color(palette_ctx: u32, rgb: u32) -> u8 {
-    let f: unsafe extern "thiscall" fn(u32, u32) -> u32 =
-        core::mem::transmute(PALETTE_MAP_COLOR_ADDR as usize);
-    f(palette_ctx, rgb) as u8
+// ---------------------------------------------------------------------------
+// PaletteContext__MapColor (0x5412B0)
+// thiscall(ECX=palette_ctx, stack=rgb_u32), RET 0x4
+// ---------------------------------------------------------------------------
+
+usercall_trampoline!(fn trampoline_palette_map_color; impl_fn = palette_map_color_impl;
+    reg = ecx; stack_params = 1; ret_bytes = "0x4");
+
+unsafe extern "cdecl" fn palette_map_color_impl(palette_ctx: u32, rgb: u32) -> u32 {
+    let ctx = palette_ctx as *mut openwa_core::render::palette::PaletteContext;
+    openwa_core::render::palette::palette_map_color(ctx, rgb)
 }
 
 unsafe extern "cdecl" fn process_sprite_impl(sprite: u32, palette_ctx: u32, raw_data: u32) -> u32 {
@@ -100,11 +103,12 @@ unsafe extern "cdecl" fn process_sprite_impl(sprite: u32, palette_ctx: u32, raw_
 
     // Map each RGB entry to display palette index
     let rgb_start = data_ptr.add(hdr.palette_offset);
+    let ctx = palette_ctx as *mut openwa_core::render::palette::PaletteContext;
     for i in 0..hdr.palette_count as usize {
         // Read 4 bytes (3 RGB + 1 from next entry, matching WA behavior)
         let rgb_val = *(rgb_start.add(i * 3) as *const u32);
-        let mapped = palette_map_color(palette_ctx, rgb_val);
-        *palette_base.add(1 + i) = mapped;
+        let mapped = openwa_core::render::palette::palette_map_color(ctx, rgb_val);
+        *palette_base.add(1 + i) = mapped as u8;
     }
 
     // --- Secondary frame table (if header_flags & 0x4000) ---
@@ -188,8 +192,6 @@ unsafe extern "cdecl" fn process_sprite_impl(sprite: u32, palette_ctx: u32, raw_
 
 pub fn install() -> Result<(), String> {
     unsafe {
-        PALETTE_MAP_COLOR_ADDR = rb(va::PALETTE_CONTEXT_MAP_COLOR);
-
         let _ = hook::install(
             "ConstructSprite",
             va::CONSTRUCT_SPRITE,
@@ -201,6 +203,12 @@ pub fn install() -> Result<(), String> {
             va::PROCESS_SPRITE,
             trampoline_process_sprite as *const (),
         )?;
+
+        let _ = hook::install(
+            "PaletteContext__MapColor",
+            va::PALETTE_CONTEXT_MAP_COLOR,
+            trampoline_palette_map_color as *const (),
+        )?;
     }
     Ok(())
 }