feat: add vcall! macro and typed vtable structs for Palette and InputCtrl

Add vcall! macro for one-liner vtable method dispatch, replacing the
3-line transmute boilerplate. Define PaletteVtable (slots 2-4) and
InputCtrlVtable (slot 0 = destructor) with typed function pointers.
Add impl method wrappers so callers write (*pal).reset() instead of
manual vtable indexing.

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

CLAUDE.md

@@ -28,19 +28,9 @@ cargo test --target i686-pc-windows-msvc -p openwa-harness
 cargo test -p openwa-core -- scheme_parse::parse_beginner_v2
 ```
 
-## Deploy to Game
+## How to run the game with the DLL
 
-Game directory: `I:\games\SteamLibrary\steamapps\common\Worms Armageddon`
-
-Copy the unified DLL from `target/i686-pc-windows-msvc/release/` to the game directory:
-- `openwa_wormkit.dll` → rename to `wkOpenWA.dll`
-
-Quick deploy:
-```bash
-cp target/i686-pc-windows-msvc/release/openwa_wormkit.dll "I:/games/SteamLibrary/steamapps/common/Worms Armageddon/wkOpenWA.dll"
-```
-
-WormKit auto-loads any `wk*.dll` from the game directory. Logs appear in the game directory as `OpenWA.log` and `OpenWA_validation.log` (when validation is enabled).
+It used to be necessary to copy the built DLLs to the game directory and launch WA.exe. **HOWEVER**, we now have the launcher crate (`openwa-launcher`) that automatically starts the game with the correct DLL injected.
 
 ## Replay Testing
 
@@ -133,6 +123,9 @@ A Ghidra MCP bridge is configured in `.mcp.json`. When using Ghidra tools:
 - Unknown struct fields as `_unknown_XX` padding arrays
 - Fixed-point: `Fixed(i32)` newtype, 16.16 format (0x10000 = 1.0)
 - Naked asm uses `naked_asm!` (Rust 1.79+ syntax), not `asm!`
+- **Typed vtable structs**: Define `#[repr(C)]` vtable structs with typed function pointers for known slots and `usize` for unknown slots (see `PaletteVtable`, `SoundEmitterVTable`). Set the class struct's vtable field to `*const FooVtable` instead of `*mut u8`.
+- **`vcall!` macro**: Use `vcall!(obj, method, args...)` for one-liner vtable dispatch. Expands to `((*(*obj).vtable).method)(obj, args...)`.
+- **Virtual method wrappers**: Add `impl` methods on the class struct that wrap `vcall!`. Callers write `(*obj).method(args)` — idiomatic, type-safe, and hides the vtable indirection.
 
 ## FFI Style
 

crates/openwa-core/src/input_ctrl.rs

@@ -11,7 +11,7 @@
 #[repr(C)]
 pub struct InputCtrl {
     /// 0x000: Vtable pointer (0x66B3FC)
-    pub vtable: *mut u8,
+    pub vtable: *const InputCtrlVtable,
     pub _unknown_004: [u8; 0xD74 - 4],
     /// 0xD74: Set to 0x3F9 during inline construction.
     pub _field_d74: u32,
@@ -19,3 +19,17 @@ pub struct InputCtrl {
 }
 
 const _: () = assert!(core::mem::size_of::<InputCtrl>() == 0x1800);
+
+/// Vtable for InputCtrl (0x66B3FC).
+///
+/// Only slot 0 (destructor) is known — called on init failure cleanup.
+#[repr(C)]
+pub struct InputCtrlVtable {
+    /// [0]: Destructor(this, flags) — scalar deleting destructor
+    pub destructor: unsafe extern "thiscall" fn(*mut InputCtrl, u32),
+}
+
+impl InputCtrl {
+    /// Vtable[0]: Destroy and optionally free (flags & 1 = free).
+    pub unsafe fn destroy(&mut self, flags: u32) { vcall!(self, destructor, flags) }
+}

crates/openwa-core/src/lib.rs

@@ -1,5 +1,8 @@
 #![allow(non_snake_case)]
 
+#[macro_use]
+pub mod macros;
+
 pub mod active_sound;
 pub mod class_type;
 pub mod message;

crates/openwa-core/src/macros.rs

@@ -0,0 +1,23 @@
+/// Call a virtual method through a typed vtable pointer.
+///
+/// Assumes `$obj` is a raw pointer to a struct whose first field `vtable`
+/// is `*const SomeVtable`, and `$method` is a function pointer field on
+/// that vtable struct.
+///
+/// # Examples
+///
+/// ```ignore
+/// // Single arg (thiscall — `self` is implicit in ECX):
+/// vcall!(pal, reset);
+///
+/// // With extra arguments:
+/// vcall!(pal, set_mode, 7);
+/// ```
+///
+/// Expands to: `((*(*$obj).vtable).$method)($obj, $($args),*)`
+#[macro_export]
+macro_rules! vcall {
+    ($obj:expr, $method:ident $(, $args:expr)*) => {
+        ((*(*$obj).vtable).$method)($obj $(, $args)*)
+    };
+}

crates/openwa-core/src/palette.rs

@@ -8,7 +8,7 @@
 #[repr(C)]
 pub struct Palette {
     /// 0x000: Vtable pointer (0x66A2E4)
-    pub vtable: *mut u8,
+    pub vtable: *const PaletteVtable,
     /// 0x004: Initialized to 0xFFFFFFFF during inline construction.
     pub _field_004: u32,
     /// 0x008-0x027: Unknown
@@ -16,3 +16,30 @@ pub struct Palette {
 }
 
 const _: () = assert!(core::mem::size_of::<Palette>() == 0x28);
+
+/// Vtable for Palette (0x66A2E4).
+///
+/// Slots 2-4 are called by GameEngine__InitHardware after DDGameWrapper construction.
+/// Slots 0-1 are unknown.
+#[repr(C)]
+pub struct PaletteVtable {
+    /// [0]: Unknown
+    pub _slot_0: usize,
+    /// [1]: Unknown
+    pub _slot_1: usize,
+    /// [2]: set_mode(this, mode) — called with mode=7 during hardware init
+    pub set_mode: unsafe extern "thiscall" fn(*mut Palette, u32),
+    /// [3]: init(this) — called during hardware init
+    pub init: unsafe extern "thiscall" fn(*mut Palette),
+    /// [4]: reset(this) — called first during hardware init
+    pub reset: unsafe extern "thiscall" fn(*mut Palette),
+}
+
+impl Palette {
+    /// Vtable[4]: Reset palette state.
+    pub unsafe fn reset(&mut self) { vcall!(self, reset) }
+    /// Vtable[3]: Initialize palette.
+    pub unsafe fn init(&mut self) { vcall!(self, init) }
+    /// Vtable[2]: Set palette mode.
+    pub unsafe fn set_mode(&mut self, mode: u32) { vcall!(self, set_mode, mode) }
+}

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

@@ -49,8 +49,8 @@ use openwa_core::ddgame_wrapper::DDGameWrapper;
 use openwa_core::ddkeyboard::DDKeyboard;
 use openwa_core::dddisplay::DDDisplay;
 use openwa_core::dssound::DSSound;
-use openwa_core::palette::Palette;
-use openwa_core::input_ctrl::InputCtrl;
+use openwa_core::palette::{Palette, PaletteVtable};
+use openwa_core::input_ctrl::{InputCtrl, InputCtrlVtable};
 use openwa_core::game_timer::GameTimer;
 use openwa_core::game_stats::GameStats;
 use openwa_core::display_gfx::DisplayGfx;
@@ -266,7 +266,7 @@ unsafe extern "cdecl" fn impl_init_hardware(
     } else {
         let ctrl = WABox::<InputCtrl>::alloc(0x1800, 0x17E0).leak();
         (*ctrl)._field_d74 = 0x3F9;
-        (*ctrl).vtable = rb(va::INPUT_CTRL_VTABLE) as *mut u8;
+        (*ctrl).vtable = rb(va::INPUT_CTRL_VTABLE) as *const InputCtrlVtable;
         (*session).input_ctrl = ctrl as *mut u8;
 
         // Original passes GameInfo+4 (skips first DWORD of unknown padding).
@@ -274,10 +274,7 @@ unsafe extern "cdecl" fn impl_init_hardware(
         INPUT_CTRL_ESI = ctrl as u32;
         let ok = call_input_ctrl_init(game_info_plus_4, param3, param4, crosshair_threshold);
         if ok == 0 {
-            let vtbl = *(ctrl as *const *const usize);
-            let dtor: unsafe extern "thiscall" fn(*mut u8, u32) =
-                core::mem::transmute(*vtbl);
-            dtor(ctrl as *mut u8, 1);
+            (*ctrl).destroy(1);
             (*session).input_ctrl = core::ptr::null_mut();
             return 0;
         }
@@ -375,7 +372,7 @@ unsafe extern "cdecl" fn impl_init_hardware(
 
         // ── Palette (inline construction) ─────────────────────────────────────
         let pal = WABox::<Palette>::alloc(0x28, 0).leak();
-        (*pal).vtable = rb(va::PALETTE_VTABLE_MAYBE) as *mut u8;
+        (*pal).vtable = rb(va::PALETTE_VTABLE_MAYBE) as *const PaletteVtable;
         (*pal)._field_004 = 0xFFFF_FFFF;
         (*session).palette = pal;
 
@@ -464,16 +461,9 @@ unsafe extern "cdecl" fn impl_init_hardware(
     if !headless {
         let pal = (*session).palette;
         if !pal.is_null() {
-            let vtbl = *(pal as *const *const usize);
-            let vt4: unsafe extern "thiscall" fn(*mut Palette) =
-                core::mem::transmute(*vtbl.add(4));
-            let vt3: unsafe extern "thiscall" fn(*mut Palette) =
-                core::mem::transmute(*vtbl.add(3));
-            let vt2: unsafe extern "thiscall" fn(*mut Palette, u32) =
-                core::mem::transmute(*vtbl.add(2));
-            vt4(pal);
-            vt3(pal);
-            vt2(pal, 7);
+            (*pal).reset();
+            (*pal).init();
+            (*pal).set_mode(7);
         }
 
         let kb = (*session).keyboard;