feat: add typed vtables to all CTask subclasses

Extend the generic CTask<V>/CGameTask<V> vtable pattern to every task class:

New vtable definitions (via #[vtable] macro, with handle_message + process_frame):
- CTaskTurnGameVTable (0x669F70, 12 slots)
- CTaskFilterVTable (0x669DAC, 12 slots)
- CTaskCloudVTable (0x669D38, 12 slots)
- CTaskFireVTable (0x669DD8, 12 slots)
- CTaskMissileVTable (0x664438, 12 slots)
- CTaskArrowVTable (0x664198, 12 slots)
- CTaskMineVTable (0x6643E8, 12 slots)
- CTaskOilDrumVTable (0x664338, 12 slots)
- CTaskCrateVTable (0x664298, 12 slots)

Each struct now uses typed base: CTask<*const XxxVTable> or
CGameTask<*const XxxVTable>, with bind macro for method dispatch.

CGameTask made generic (V parameter with *const c_void default).
CTaskWorm updated to use CGameTask<*const CTaskWormVTable>.

FieldRegistry derive macro: improved generic substitution to handle
nested types like CTask<V> (recursive type AST walking).

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

crates/openwa-core/src/task/arrow.rs

@@ -1,3 +1,4 @@
+use super::base::CTask;
 use super::game_task::CGameTask;
 use crate::FieldRegistry;
 
@@ -8,6 +9,21 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskArrow vtable — 12 slots. Extends CGameTask vtable with arrow behavior.
+///
+/// Vtable at Ghidra 0x664198.
+#[openwa_core::vtable(size = 12, va = 0x0066_4198, class = "CTaskArrow")]
+pub struct CTaskArrowVTable {
+    /// HandleMessage — processes arrow messages.
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskArrow, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame arrow update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskArrow, flags: u32),
+}
+
 /// Arrow/bullet projectile entity (Shotgun, Longbow).
 ///
 /// Extends CGameTask (0xFC bytes). Allocated size: 0x168 bytes.
@@ -20,10 +36,13 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskArrow {
     /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94).
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskArrowVTable>,
 
     /// 0xFC–0x167: Arrow-specific fields. Layout unknown.
     pub _unknown_fc: [u8; 0x168 - 0xFC],
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskArrow>() == 0x168);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskArrowVTable!(CTaskArrow, base.base.vtable);

crates/openwa-core/src/task/cloud.rs

@@ -10,6 +10,21 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskCloud vtable — 12 slots. Extends CTask base (8 slots) with cloud behavior.
+///
+/// Vtable at Ghidra 0x669D38.
+#[openwa_core::vtable(size = 12, va = 0x0066_9D38, class = "CTaskCloud")]
+pub struct CTaskCloudVTable {
+    /// HandleMessage — processes cloud messages (wind updates, render).
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskCloud, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame cloud update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskCloud, flags: u32),
+}
+
 /// Airstrike / weather cloud task.
 ///
 /// Extends CTask directly (not CGameTask). Clouds drift horizontally with wind,
@@ -30,7 +45,7 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskCloud {
     /// 0x00–0x2F: CTask base
-    pub base: CTask,
+    pub base: CTask<*const CTaskCloudVTable>,
     /// 0x30: Parallax scroll layer depth (Fixed; 0x190000 = 25.0 at spawn,
     /// decrements by 1 each cloud spawned in a batch)
     pub layer_depth: Fixed,
@@ -55,3 +70,6 @@ pub struct CTaskCloud {
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskCloud>() == 0x74);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskCloudVTable!(CTaskCloud, base.vtable);

crates/openwa-core/src/task/filter.rs

@@ -9,6 +9,22 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskFilter vtable — 12 slots. Extends CTask base (8 slots) with filter behavior.
+///
+/// Vtable at Ghidra 0x669DAC. Slot 2 (HandleMessage) checks the subscription
+/// table before forwarding messages to children.
+#[openwa_core::vtable(size = 12, va = 0x0066_9DAC, class = "CTaskFilter")]
+pub struct CTaskFilterVTable {
+    /// HandleMessage — checks subscription table, forwards matching messages.
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskFilter, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame filter update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskFilter, flags: u32),
+}
+
 /// Message-subscription filter task — routes messages selectively to child tasks.
 ///
 /// CTaskFilter is a CTask subclass that overrides HandleMessage to only forward
@@ -49,7 +65,7 @@ pub struct CTaskFilter {
     /// - CTask+0x18 (`_unknown_18`): set to 0
     /// - CTask+0x1C (`_unknown_1c`): set to `init_val_1c` constructor param
     /// - CTask+0x20 (`_unknown_20`): set to 7 (task type / mode constant)
-    pub base: CTask,
+    pub base: CTask<*const CTaskFilterVTable>,
     /// 0x30–0x93: Boolean subscription table, indexed by message type ID (0–99).
     ///
     /// `subscription_table[id] != 0` means this filter will forward messages of
@@ -61,3 +77,6 @@ pub struct CTaskFilter {
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskFilter>() == 0xB4);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskFilterVTable!(CTaskFilter, base.vtable);

crates/openwa-core/src/task/fire.rs

@@ -9,6 +9,21 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskFire vtable — 12 slots. Extends CTask base (8 slots) with fire behavior.
+///
+/// Vtable at Ghidra 0x669DD8.
+#[openwa_core::vtable(size = 12, va = 0x0066_9DD8, class = "CTaskFire")]
+pub struct CTaskFireVTable {
+    /// HandleMessage — processes fire messages.
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskFire, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame fire update (countdown, spread, damage).
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskFire, flags: u32),
+}
+
 /// Fire/flame entity task.
 ///
 /// Extends CTask (not CGameTask) — no physics body.
@@ -24,7 +39,7 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskFire {
     /// 0x00-0x2F: CTask base
-    pub base: CTask,
+    pub base: CTask<*const CTaskFireVTable>,
     /// 0x30: spread counter (incremented while fire is spreading)
     pub spread_counter: i32,
     /// 0x34: frame countdown; starts at 0xFFFF, decrements each ProcessFrame
@@ -54,3 +69,6 @@ pub struct CTaskFire {
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskFire>() == 0xD8);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskFireVTable!(CTaskFire, base.vtable);

crates/openwa-core/src/task/game_task.rs

@@ -31,9 +31,9 @@ pub const CGAMETASK_SOUND_EMITTER_VT: u32 = SOUND_EMITTER_VTABLE;
 /// Additional vtable (12 methods at offsets 0x1C-0x48 in vtable)
 #[derive(FieldRegistry)]
 #[repr(C)]
-pub struct CGameTask {
+pub struct CGameTask<V: 'static = *const core::ffi::c_void> {
     /// 0x00-0x2F: Base CTask fields
-    pub base: CTask,
+    pub base: CTask<V>,
     /// 0x30-0x83: Subclass-specific data (84 bytes). Each CGameTask derivative
     /// uses this region differently:
     /// - CTaskWorm: weapon fire state (+0x30 type, +0x34/+0x38 subtypes, +0x3C flag)

crates/openwa-core/src/task/mine_oil_drum.rs

@@ -1,3 +1,4 @@
+use super::base::CTask;
 use super::game_task::CGameTask;
 use crate::FieldRegistry;
 
@@ -15,6 +16,36 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskMine vtable — 12 slots. Extends CGameTask vtable with mine behavior.
+///
+/// Vtable at Ghidra 0x6643E8.
+#[openwa_core::vtable(size = 12, va = 0x0066_43E8, class = "CTaskMine")]
+pub struct CTaskMineVTable {
+    /// HandleMessage — processes mine messages (arm, trigger, detonate).
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskMine, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame mine update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskMine, flags: u32),
+}
+
+/// CTaskOilDrum vtable — 12 slots. Extends CGameTask vtable with oil drum behavior.
+///
+/// Vtable at Ghidra 0x664338.
+#[openwa_core::vtable(size = 12, va = 0x0066_4338, class = "CTaskOilDrum")]
+pub struct CTaskOilDrumVTable {
+    /// HandleMessage — processes oil drum messages.
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskOilDrum, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame oil drum update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskOilDrum, flags: u32),
+}
+
 /// Land mine entity task.
 ///
 /// Extends CGameTask (0xFC bytes). Mines sit on the terrain and arm after
@@ -29,7 +60,7 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskMine {
     /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94)
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskMineVTable>,
     /// 0xFC–0x10F: Unknown mine flags
     pub _unknown_fc: [u8; 0x14],
     /// 0x110: Object pool slot index (assigned from DDGame+0x3600 pool)
@@ -51,6 +82,9 @@ pub struct CTaskMine {
 
 const _: () = assert!(core::mem::size_of::<CTaskMine>() == 0x128);
 
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskMineVTable!(CTaskMine, base.base.vtable);
+
 /// Exploding oil drum entity task.
 ///
 /// Extends CGameTask (0xFC bytes). Oil drums roll on terrain and explode
@@ -65,7 +99,7 @@ const _: () = assert!(core::mem::size_of::<CTaskMine>() == 0x128);
 #[repr(C)]
 pub struct CTaskOilDrum {
     /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94)
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskOilDrumVTable>,
     /// 0xFC: Triggered flag — set to 1 on first impact, starts smoke/fire
     pub triggered: u32,
     /// 0x100: Object pool slot index
@@ -80,6 +114,9 @@ pub struct CTaskOilDrum {
 
 const _: () = assert!(core::mem::size_of::<CTaskOilDrum>() == 0x110);
 
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskOilDrumVTable!(CTaskOilDrum, base.base.vtable);
+
 impl CTaskOilDrum {
     /// Returns true if the drum is on fire (flag at CGameTask+0xB0, inside _unknown_98).
     ///

crates/openwa-core/src/task/missile.rs

@@ -1,3 +1,4 @@
+use super::base::CTask;
 use super::game_task::CGameTask;
 use crate::fixed::Fixed;
 use crate::game::weapon::WeaponSpawnData;
@@ -11,6 +12,21 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskMissile vtable — 12 slots. Extends CGameTask vtable with missile behavior.
+///
+/// Vtable at Ghidra 0x664438.
+#[openwa_core::vtable(size = 12, va = 0x0066_4438, class = "CTaskMissile")]
+pub struct CTaskMissileVTable {
+    /// HandleMessage — processes missile messages.
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskMissile, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame missile update (physics, homing, detonation).
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskMissile, flags: u32),
+}
+
 /// Projectile / missile entity task.
 ///
 /// Extends CGameTask (0xFC bytes). One instance per airborne projectile
@@ -32,7 +48,7 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskMissile {
     /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94).
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskMissileVTable>,
 
     // ---- 0xFC–0x12F: missile init fields ----
     /// 0xFC–0x10F: Unknown missile flags and state
@@ -128,6 +144,9 @@ pub struct CTaskMissile {
 
 const _: () = assert!(core::mem::size_of::<CTaskMissile>() == 0x40C);
 
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskMissileVTable!(CTaskMissile, base.base.vtable);
+
 impl CTaskMissile {
     /// Missile type from `render_data[0x17]` (= weapon_data[0x1A] for single shots).
     ///

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

@@ -13,16 +13,16 @@ pub mod team;
 pub mod turn_game;
 pub mod worm;
 
-pub use arrow::CTaskArrow;
+pub use arrow::{CTaskArrow, CTaskArrowVTable};
 pub use base::{CTask, CTaskBfsIter, SharedDataIter, SharedDataNode, SharedDataTable};
-pub use cloud::CTaskCloud;
-pub use filter::CTaskFilter;
-pub use fire::CTaskFire;
+pub use cloud::{CTaskCloud, CTaskCloudVTable};
+pub use filter::{CTaskFilter, CTaskFilterVTable};
+pub use fire::{CTaskFire, CTaskFireVTable};
 pub use game_task::{CGameTask, SoundEmitter, SoundEmitterVTable};
-pub use mine_oil_drum::{CTaskMine, CTaskOilDrum};
-pub use missile::{CTaskMissile, MissileType};
+pub use mine_oil_drum::{CTaskMine, CTaskMineVTable, CTaskOilDrum, CTaskOilDrumVTable};
+pub use missile::{CTaskMissile, CTaskMissileVTable, MissileType};
 pub use overlays::{BungeeTrailTask, WeaponAimTask};
-pub use supply_crate::CTaskCrate;
+pub use supply_crate::{CTaskCrate, CTaskCrateVTable};
 pub use team::{CTaskTeam, CTaskTeamVTable};
-pub use turn_game::{CTaskTurnGame, TurnGameCtx};
+pub use turn_game::{CTaskTurnGame, CTaskTurnGameVTable, TurnGameCtx};
 pub use worm::{CTaskWorm, CTaskWormVTable};

crates/openwa-core/src/task/supply_crate.rs

@@ -1,3 +1,4 @@
+use super::base::CTask;
 use super::game_task::CGameTask;
 use crate::FieldRegistry;
 
@@ -9,6 +10,21 @@ crate::define_addresses! {
     }
 }
 
+/// CTaskCrate vtable — 12 slots. Extends CGameTask vtable with crate behavior.
+///
+/// Vtable at Ghidra 0x664298.
+#[openwa_core::vtable(size = 12, va = 0x0066_4298, class = "CTaskCrate")]
+pub struct CTaskCrateVTable {
+    /// HandleMessage — processes crate messages (collection, parachute, etc.).
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskCrate, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame crate update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskCrate, flags: u32),
+}
+
 /// Weapon/health/utility crate entity task.
 ///
 /// Extends CGameTask (0xFC bytes). Crates fall from the sky with a parachute,
@@ -26,7 +42,7 @@ crate::define_addresses! {
 #[repr(C)]
 pub struct CTaskCrate {
     /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94)
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskCrateVTable>,
     /// 0xFC: Unknown (zeroed by constructor)
     pub _unknown_fc: u32,
     /// 0x100: Object pool slot index (assigned from DDGame+0x3600 pool)
@@ -57,3 +73,6 @@ pub struct CTaskCrate {
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskCrate>() == 0x4B0);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame().
+bind_CTaskCrateVTable!(CTaskCrate, base.base.vtable);

crates/openwa-core/src/task/turn_game.rs

@@ -89,6 +89,22 @@ pub struct TurnGameCtx {
 
 const _: () = assert!(core::mem::size_of::<TurnGameCtx>() == 0xAC);
 
+/// CTaskTurnGame vtable — 12 slots. Extends CTask base (8 slots) with turn-game behavior.
+///
+/// Vtable at Ghidra 0x669F70. Slot 2 (HandleMessage) is the main turn-flow
+/// dispatcher (30+ message types).
+#[openwa_core::vtable(size = 12, va = 0x0066_9F70, class = "CTaskTurnGame")]
+pub struct CTaskTurnGameVTable {
+    /// HandleMessage — processes messages for turn flow control
+    /// thiscall + 4 stack params, RET 0x10.
+    #[slot(2)]
+    pub handle_message: fn(this: *mut CTaskTurnGame, sender: *mut CTask, msg_type: u32, size: u32, data: *const u8),
+    /// ProcessFrame — per-frame turn update.
+    /// thiscall + 1 stack param (flags), RET 0x4.
+    #[slot(7)]
+    pub process_frame: fn(this: *mut CTaskTurnGame, flags: u32),
+}
+
 /// Root turn-controller task — one instance per game, parent of the entire entity tree.
 ///
 /// Every worm, team, projectile, and environment task is a child (direct or indirect)
@@ -112,7 +128,7 @@ const _: () = assert!(core::mem::size_of::<TurnGameCtx>() == 0xAC);
 #[repr(C)]
 pub struct CTaskTurnGame {
     /// 0x00-0x2F: CTask base (vtable, parent, children, shared_data, ddgame, …)
-    pub base: CTask,
+    pub base: CTask<*const CTaskTurnGameVTable>,
     /// 0x30–0xDB: Embedded `TurnGameCtx` sub-object (0xAC bytes).
     /// See [`TurnGameCtx`] for field details.
     pub game_ctx: TurnGameCtx,
@@ -189,3 +205,6 @@ pub struct CTaskTurnGame {
 }
 
 const _: () = assert!(core::mem::size_of::<CTaskTurnGame>() == 0x2E0);
+
+// Generate typed vtable method wrappers: handle_message(), process_frame(), etc.
+bind_CTaskTurnGameVTable!(CTaskTurnGame, base.vtable);

crates/openwa-core/src/task/worm.rs

@@ -95,7 +95,7 @@ pub struct CTaskWormVTable {
 #[repr(C)]
 pub struct CTaskWorm {
     /// 0x00–0xFB: CGameTask base (position, velocity, sound emitter, etc.)
-    pub base: CGameTask,
+    pub base: CGameTask<*const CTaskWormVTable>,
 
     /// 0xFC: Team index (0-based); 3rd constructor param
     pub team_index: u32,
@@ -189,6 +189,9 @@ pub struct CTaskWorm {
 
 const _: () = assert!(core::mem::size_of::<CTaskWorm>() == 0x3FC);
 
+// Generate typed vtable method wrappers: handle_message(), on_contact_entity(), etc.
+bind_CTaskWormVTable!(CTaskWorm, base.base.vtable);
+
 impl CTaskWorm {
     /// Returns the worm's current state code (lives at offset +0x44, inside
     /// `base.subclass_data`).
@@ -214,14 +217,7 @@ impl CTaskWorm {
         self.base.subclass_data[12..16].copy_from_slice(&value.to_ne_bytes());
     }
 
-    /// Returns a reference to the vtable.
-    ///
-    /// # Safety
-    /// The vtable pointer at offset 0 must be the genuine CTaskWorm vtable
-    /// (0x6644C8 in Ghidra, rebased at runtime).
-    pub unsafe fn vtable(&self) -> &'static CTaskWormVTable {
-        &*(self.base.base.vtable as *const CTaskWormVTable)
-    }
+    // vtable() method is now provided by bind_CTaskWormVTable! macro above.
 }
 
 // ── Snapshot impl ──────────────────────────────────────────

crates/openwa-derive/src/lib.rs

@@ -586,24 +586,10 @@ pub fn derive_field_registry(input: TokenStream) -> TokenStream {
         let doc = extract_doc_comment(&field.attrs);
         let field_ty = &field.ty;
 
-        // If the field type is a generic param (e.g., `V`), substitute with its
-        // default type for size_of. offset_of uses the bare struct name which
+        // Substitute generic type params (e.g., `V` or `CTask<V>`) with their
+        // defaults for size_of. offset_of uses the bare struct name which
         // Rust resolves with defaults applied.
-        let size_ty: Box<dyn quote::ToTokens> =
-            if let syn::Type::Path(tp) = field_ty {
-                if tp.path.segments.len() == 1 {
-                    let seg = &tp.path.segments[0];
-                    if let Some(default) = generic_defaults.get(&seg.ident.to_string()) {
-                        Box::new(default.clone())
-                    } else {
-                        Box::new(field_ty.clone())
-                    }
-                } else {
-                    Box::new(field_ty.clone())
-                }
-            } else {
-                Box::new(field_ty.clone())
-            };
+        let size_ty = substitute_generics(field_ty, &generic_defaults);
 
         // Determine ValueKind: check for #[field(kind = "...")] override, else infer
         let kind = parse_field_kind_attr(&field.attrs)
@@ -734,3 +720,59 @@ fn value_kind_token(variant: &str) -> proc_macro2::TokenStream {
     let ident = quote::format_ident!("{}", variant);
     quote! { openwa_core::registry::ValueKind::#ident }
 }
+
+/// Recursively substitute generic type parameters with their defaults.
+///
+/// For example, given `CTask<V>` with defaults `{V → *const c_void}`,
+/// produces `CTask<*const c_void>`. Handles nested generics and all
+/// common type forms (paths, pointers, arrays, etc.).
+fn substitute_generics(
+    ty: &syn::Type,
+    defaults: &std::collections::HashMap<String, syn::Type>,
+) -> syn::Type {
+    if defaults.is_empty() {
+        return ty.clone();
+    }
+
+    match ty {
+        syn::Type::Path(tp) => {
+            // Check if the entire path is a generic param name (e.g., `V`)
+            if tp.qself.is_none() && tp.path.segments.len() == 1 {
+                let seg = &tp.path.segments[0];
+                if seg.arguments.is_empty() {
+                    if let Some(default) = defaults.get(&seg.ident.to_string()) {
+                        return default.clone();
+                    }
+                }
+            }
+            // Recursively substitute within generic arguments (e.g., CTask<V>)
+            let mut tp = tp.clone();
+            for seg in &mut tp.path.segments {
+                if let syn::PathArguments::AngleBracketed(ref mut args) = seg.arguments {
+                    for arg in &mut args.args {
+                        if let syn::GenericArgument::Type(ref mut inner_ty) = arg {
+                            *inner_ty = substitute_generics(inner_ty, defaults);
+                        }
+                    }
+                }
+            }
+            syn::Type::Path(tp)
+        }
+        syn::Type::Ptr(ptr) => {
+            let mut ptr = ptr.clone();
+            ptr.elem = Box::new(substitute_generics(&ptr.elem, defaults));
+            syn::Type::Ptr(ptr)
+        }
+        syn::Type::Array(arr) => {
+            let mut arr = arr.clone();
+            arr.elem = Box::new(substitute_generics(&arr.elem, defaults));
+            syn::Type::Array(arr)
+        }
+        syn::Type::Reference(r) => {
+            let mut r = r.clone();
+            r.elem = Box::new(substitute_generics(&r.elem, defaults));
+            syn::Type::Reference(r)
+        }
+        _ => ty.clone(),
+    }
+}

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

@@ -408,7 +408,7 @@ unsafe fn fire_weapon_special(
 unsafe fn lookup_team_task(worm: *const CTaskWorm) -> *mut openwa_core::task::CTaskTeam {
     use openwa_core::task::SharedDataTable;
 
-    let task = &(*worm).base.base;
+    let task = &(*worm).base.base as *const _ as *const openwa_core::task::CTask;
     let table = SharedDataTable::from_task(task);
     // CTaskTeam is registered with key (0, 0x14) in SharedData
     table.lookup(0, 0x14) as *mut openwa_core::task::CTaskTeam
@@ -432,7 +432,7 @@ unsafe fn fire_send_team_message(worm: *mut CTaskWorm, msg_type: u32) {
     buf[0..4].copy_from_slice(&team_index.to_ne_bytes());
 
     (*team).handle_message(
-        &raw mut (*worm).base.base,
+        &raw mut (*worm).base.base as *mut openwa_core::task::CTask,
         msg_type,
         4,
         buf.as_ptr(),
@@ -453,7 +453,7 @@ unsafe fn fire_select_worm(worm: *mut CTaskWorm) {
     buf[4..8].copy_from_slice(&(*worm).team_index.to_ne_bytes());
 
     (*team).handle_message(
-        &raw mut (*worm).base.base,
+        &raw mut (*worm).base.base as *mut openwa_core::task::CTask,
         0x5D,
         0x408,
         buf.as_ptr(),
@@ -726,7 +726,7 @@ unsafe extern "cdecl" fn create_weapon_projectile_impl(
     }
 
     // Look up parent CTaskTurnGame via SharedData (key_esi=0, key_edi=0x19)
-    let table = SharedDataTable::from_task(task);
+    let table = SharedDataTable::from_task(task as *const _ as *const openwa_core::task::CTask);
     let parent = table.lookup(0, 0x19);
 
     // Allocate CTaskMissile (0x40C bytes)
@@ -900,7 +900,7 @@ unsafe extern "cdecl" fn create_arrow_impl(
     }
 
     // Look up parent CTaskTurnGame via SharedData (key 0, 0x19)
-    let table = SharedDataTable::from_task(task);
+    let table = SharedDataTable::from_task(task as *const _ as *const openwa_core::task::CTask);
     let parent = table.lookup(0, 0x19);
 
     // Allocate CTaskArrow (0x168 bytes)