refactor: replace raw pointer arithmetic with typed structs

- DDGame: rename _param_008 to sound_enabled, expose crosshair_scale at 0x8150
- Add BungeeTrailTask overlay (fields at 0xBC-0xE4 for trail rendering)
- Add WeaponAimTask overlay (fields at 0x258, 0x264, 0x324 for crosshair)
- Update render.rs and sound.rs to use typed field access

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

crates/openwa-types/src/ddgame.rs

@@ -20,8 +20,8 @@ pub struct DDGame {
     pub _base_000: *mut u8,
     /// 0x004: Context pointer (param_3)
     pub _context: *mut u8,
-    /// 0x008: param_4
-    pub _param_008: *mut u8,
+    /// 0x008: Sound enabled flag (nonzero = enabled). Checked by PlaySoundGlobal.
+    pub sound_enabled: i32,
     /// 0x00C: Allocated object (0x608 bytes, conditional)
     pub _object_00c: *mut u8,
     /// 0x010: param_6
@@ -97,12 +97,17 @@ pub struct DDGame {
     /// 0x8140: Number of entries currently in the sound queue (0–16).
     pub sound_queue_count: i32,
 
-    /// 0x8144-0x98B7: Remaining fields
+    /// 0x8144-0x814F: Unknown
+    pub _unknown_8144: [u8; 0x8150 - 0x8144],
+    /// 0x8150: Scale factor used by DrawCrosshairLine (multiplied by 0x140000).
+    pub crosshair_scale: i32,
+
+    /// 0x8154-0x98B7: Remaining fields
     ///
     /// Known landmarks:
     /// - 0x8CBC-0x8CF0: 4x 0x10-byte entries (zeroed at +0, +4)
     /// - 0x9850-0x9884: 4x 0x10-byte entries (zeroed at +0, +4)
-    pub _unknown_8144: [u8; 0x98B8 - 0x8144],
+    pub _unknown_8154: [u8; 0x98B8 - 0x8154],
 }
 
 const _: () = assert!(core::mem::size_of::<DDGame>() == 0x98B8);

crates/openwa-types/src/task.rs

@@ -118,3 +118,71 @@ pub struct SoundEmitterVTable {
     /// [5]-[11]: Inherited CTask base methods
     pub _base_methods: [*const (); 7],
 }
+
+// ============================================================
+// Derived task overlays — for accessing task-specific fields
+// beyond or within CGameTask that differ per task type.
+// ============================================================
+
+/// Bungee trail rendering task fields.
+///
+/// Used by DrawBungeeTrail (0x500720). Fields at 0xBC-0xE4 overlap with
+/// CGameTask's `_unknown_98` region — different task types may use these
+/// offsets for different purposes.
+///
+/// Cast a task pointer to this type when you know it's a bungee trail task.
+#[repr(C)]
+pub struct BungeeTrailTask {
+    /// 0x00-0x2F: CTask base
+    pub base: CTask,
+    /// 0x30-0x83: Unknown
+    pub _unknown_30: [u8; 0x54],
+    /// 0x84: X position in fixed-point
+    pub pos_x: Fixed,
+    /// 0x88: Y position in fixed-point
+    pub pos_y: Fixed,
+    /// 0x8C-0xBB: Unknown
+    pub _unknown_8c: [u8; 0x30],
+    /// 0xBC: Trail visible flag (set by InitWormTrail when Bungee is used)
+    pub trail_visible: i32,
+    /// 0xC0: Trail start X position
+    pub trail_start_x: i32,
+    /// 0xC4: Trail start Y position
+    pub trail_start_y: i32,
+    /// 0xC8-0xCF: Unknown
+    pub _unknown_c8: [u8; 8],
+    /// 0xD0: Number of trail segments
+    pub segment_count: i32,
+    /// 0xD4-0xE3: Unknown
+    pub _unknown_d4: [u8; 0x10],
+    /// 0xE4: Pointer to segment data array (8 bytes per segment: 4 padding + 4 angle)
+    pub segment_data: *const u8,
+    /// 0xE8: Sound emitter sub-object
+    pub sound_emitter: SoundEmitter,
+}
+
+const _: () = assert!(core::mem::size_of::<BungeeTrailTask>() == 0xFC);
+
+/// Weapon aiming task fields.
+///
+/// Used by DrawCrosshairLine (0x5197D0). Fields at 0x258+ are in the derived
+/// class region beyond CGameTask (0xFC). The exact class name is unknown.
+///
+/// Cast a task pointer to this type when you know it's a worm/weapon aiming task.
+#[repr(C)]
+pub struct WeaponAimTask {
+    /// 0x00-0xFB: CGameTask base
+    pub game_task: CGameTask,
+    /// 0xFC-0x257: Unknown derived fields
+    pub _unknown_fc: [u8; 0x258 - 0xFC],
+    /// 0x258: Aiming active flag (nonzero = crosshair visible)
+    pub aim_active: i32,
+    /// 0x25C-0x263: Unknown
+    pub _unknown_25c: [u8; 8],
+    /// 0x264: Current aim angle (used for trig lookup)
+    pub aim_angle: u32,
+    /// 0x268-0x323: Unknown
+    pub _unknown_268: [u8; 0x324 - 0x268],
+    /// 0x324: Aim range offset (added to DDGame crosshair scale)
+    pub aim_range_offset: i32,
+}

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

@@ -7,7 +7,7 @@ use openwa_lib::rebase::rb;
 use openwa_types::address::va;
 use openwa_types::ddgame::{offsets as dg, DDGame};
 use openwa_types::render::*;
-use openwa_types::task::CGameTask;
+use openwa_types::task::{BungeeTrailTask, WeaponAimTask};
 
 use crate::hook::{self, usercall_trampoline};
 
@@ -374,29 +374,27 @@ unsafe extern "stdcall" fn draw_bungee_trail_impl(
     style: u32,
     fill: u32,
 ) {
-    let task = task_ptr as *mut u8;
-    let game_task = task_ptr as *const CGameTask;
+    let task = &*(task_ptr as *const BungeeTrailTask);
 
-    // Early exit if trail not visible (set by InitWormTrail when Bungee is used)
-    if *(task.add(0xBC) as *const i32) == 0 {
+    if task.trail_visible == 0 {
         return;
     }
 
-    let ddgame = &*((*game_task).base.ddgame as *const DDGame);
+    let ddgame = &*(task.base.ddgame as *const DDGame);
     let rq = &mut *ddgame.render_queue;
 
-    let seg_data = *(task.add(0xE4) as *const *const u8);
+    let seg_data = task.segment_data;
     if seg_data.is_null() {
         return;
     }
 
-    let segment_count = *(task.add(0xD0) as *const i32);
+    let segment_count = task.segment_count;
     if segment_count <= 0 {
         return;
     }
 
-    let mut x = *(task.add(0xC0) as *const i32);
-    let mut y = *(task.add(0xC4) as *const i32);
+    let mut x = task.trail_start_x;
+    let mut y = task.trail_start_y;
 
     let first_angle = *(seg_data.add(4) as *const i32);
 
@@ -443,7 +441,7 @@ unsafe extern "stdcall" fn draw_bungee_trail_impl(
 
     // Final vertex = task position (target)
     if vert_count < MAX_VERTICES {
-        verts[vert_count] = [(*game_task).pos_x.0, (*game_task).pos_y.0, 0];
+        verts[vert_count] = [task.pos_x.0, task.pos_y.0, 0];
         vert_count += 1;
     }
 
@@ -499,22 +497,20 @@ usercall_trampoline!(fn trampoline_draw_crosshair_line; impl_fn = draw_crosshair
     reg = edi);
 
 unsafe extern "cdecl" fn draw_crosshair_line_impl(task_ptr: u32) {
-    let task = task_ptr as *const u8;
-    let game_task = task_ptr as *const CGameTask;
+    let task = &*(task_ptr as *const WeaponAimTask);
+    let gt = &task.game_task;
 
-    // Early exit if aiming not active (derived class field)
-    if *(task.add(0x258) as *const i32) == 0 {
+    if task.aim_active == 0 {
         return;
     }
 
-    let ddgame_ptr = (*game_task).base.ddgame as *const u8;
-    let ddgame = &*(ddgame_ptr as *const DDGame);
+    let ddgame = &*(gt.base.ddgame as *const DDGame);
     let rq = &mut *ddgame.render_queue;
 
-    let start_x = (*game_task).pos_x.0;
-    let start_y = (*game_task).pos_y.0;
+    let start_x = gt.pos_x.0;
+    let start_y = gt.pos_y.0;
 
-    let angle = *(task.add(0x264) as *const u32);
+    let angle = task.aim_angle;
 
     // Trig interpolation
     let sin_table = rb(va::G_SIN_TABLE) as *const i32;
@@ -522,10 +518,9 @@ unsafe extern "cdecl" fn draw_crosshair_line_impl(task_ptr: u32) {
     let sin_interp = trig_lookup(sin_table, angle);
     let cos_interp = trig_lookup(cos_table, angle);
 
-    // Scale = fixed_mul(DDGame[CROSSHAIR_SCALE], 0x140000) + task[0x324]
-    let ddgame_scale = *(ddgame_ptr.add(dg::CROSSHAIR_SCALE) as *const i32);
-    let scale = fixed_mul(ddgame_scale, 0x14_0000)
-        + *(task.add(0x324) as *const i32);
+    // Scale = fixed_mul(DDGame.crosshair_scale, 0x140000) + task.aim_range_offset
+    let scale = fixed_mul(ddgame.crosshair_scale, 0x14_0000)
+        + task.aim_range_offset;
 
     // Endpoint = start + direction * scale
     let mut endpoint_x = fixed_mul(sin_interp, scale).wrapping_add(start_x);
@@ -559,6 +554,7 @@ unsafe extern "cdecl" fn draw_crosshair_line_impl(task_ptr: u32) {
     }
 
     // Enqueue polygon line (2 vertices)
+    let ddgame_ptr = ddgame as *const DDGame as *const u8;
     let poly_param_1 = *(ddgame_ptr.add(dg::CROSSHAIR_LINE_PARAM_1) as *const u32);
     let poly_param_2 = *(ddgame_ptr.add(dg::CROSSHAIR_LINE_PARAM_2) as *const u32);
     let verts: [[i32; 3]; 2] = [

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

@@ -10,7 +10,7 @@
 use std::sync::atomic::Ordering;
 
 use openwa_types::address::va;
-use openwa_types::ddgame::{DDGame, offsets, SoundQueueEntry};
+use openwa_types::ddgame::{DDGame, SoundQueueEntry};
 use openwa_types::sound::SoundId;
 use openwa_types::task::CGameTask;
 
@@ -37,9 +37,7 @@ unsafe fn queue_sound(
     pitch: u32,
 ) -> Option<*mut SoundQueueEntry> {
     let g = &mut *ddgame;
-    // sound_enabled is at DDGame+0x008, mapped as _param_008 (pointer-sized).
-    let sound_enabled = *((ddgame as *const u8).add(offsets::SOUND_ENABLED) as *const i32);
-    if g.sound_queue_count >= 16 || sound_enabled == 0 {
+    if g.sound_queue_count >= 16 || g.sound_enabled == 0 {
         return None;
     }
     let entry = &mut g.sound_queue[g.sound_queue_count as usize];