feat: port DrawLineStrip/DrawPolygon, add RenderQueue to DDGame, replace Ptr32

- Add DrawLineStrip (type 8) and DrawPolygon (type 9) as full Rust
replacements, completing all 10 RenderQueue enqueue methods
- Add RenderQueue::alloc_raw() for variable-size buffer allocation
- Add render_queue (*mut RenderQueue) field to DDGame at offset 0x524,
discovered via xref analysis of DrawPolygon callers
- Replace Ptr32 with *mut u8 / *mut RenderQueue in DDGame and RenderQueue
structs (Ptr32 was just u32; real pointers are more expressive)
- Add RENDER_QUEUE offset to ddgame_offsets

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

crates/openwa-types/src/address.rs

@@ -478,6 +478,8 @@ pub mod va {
         pub const PC_LANDSCAPE: u32 = 0x4CC;
         /// Offset to weapon table pointer
         pub const WEAPON_TABLE: u32 = 0x510;
+        /// Offset to RenderQueue pointer
+        pub const RENDER_QUEUE: u32 = 0x524;
         /// Offset to weapon panel pointer
         pub const WEAPON_PANEL: u32 = 0x548;
     }

crates/openwa-types/src/ddgame.rs

@@ -1,4 +1,4 @@
-use crate::task::Ptr32;
+use crate::render::RenderQueue;
 
 /// DDGame — the main game engine object.
 ///
@@ -8,7 +8,7 @@ use crate::task::Ptr32;
 /// Allocated in DDGame__Constructor (0x56E220).
 /// The DDGame pointer is stored at DDGameWrapper+0x488 (DWORD index 0x122).
 ///
-/// PARTIAL: Fields up to 0x510 are densely mapped from the constructor.
+/// PARTIAL: Fields up to 0x54C are densely mapped from the constructor.
 /// Beyond that, only scattered fields are known — use the `offsets` module.
 ///
 /// Note on offsets: The constructor accesses DDGame fields via
@@ -17,56 +17,66 @@ use crate::task::Ptr32;
 #[repr(C)]
 pub struct DDGame {
     /// 0x000: Base value (param_5 from constructor)
-    pub _base_000: Ptr32,
+    pub _base_000: *mut u8,
     /// 0x004: Context pointer (param_3)
-    pub _context: Ptr32,
+    pub _context: *mut u8,
     /// 0x008: param_4
-    pub _param_008: Ptr32,
+    pub _param_008: *mut u8,
     /// 0x00C: Allocated object (0x608 bytes, conditional)
-    pub _object_00c: Ptr32,
+    pub _object_00c: *mut u8,
     /// 0x010: param_6
-    pub _param_010: Ptr32,
+    pub _param_010: *mut u8,
     /// 0x014: param_7
-    pub _param_014: Ptr32,
+    pub _param_014: *mut u8,
     /// 0x018: param_8
-    pub _param_018: Ptr32,
+    pub _param_018: *mut u8,
     /// 0x01C: Caller/parent pointer (param_1)
-    pub _caller: Ptr32,
+    pub _caller: *mut u8,
     /// 0x020: PCLandscape pointer (copied from DDGameWrapper[0x133])
-    pub landscape: Ptr32,
+    pub landscape: *mut u8,
     /// 0x024: Game state pointer (param_10)
-    pub game_state: Ptr32,
+    pub game_state: *mut u8,
     /// 0x028: param_9
-    pub _param_028: Ptr32,
+    pub _param_028: *mut u8,
     /// 0x02C: Secondary GfxDir object (0x70C bytes, conditional on GfxHandler 1)
-    pub secondary_gfxdir: Ptr32,
+    pub secondary_gfxdir: *mut u8,
     /// 0x030: Gradient image pointer
-    pub gradient_image: Ptr32,
+    pub gradient_image: *mut u8,
     /// 0x034: Gradient image 2 pointer
-    pub gradient_image_2: Ptr32,
+    pub gradient_image_2: *mut u8,
     /// 0x038-0x0B4: Arrow sprite object pointers (32 entries)
-    pub arrow_sprites: [Ptr32; 32],
+    pub arrow_sprites: [*mut u8; 32],
     /// 0x0B8-0x134: Arrow GfxDir pointers (32 entries, conditional)
-    pub arrow_gfxdirs: [Ptr32; 32],
+    pub arrow_gfxdirs: [*mut u8; 32],
     /// 0x138: DisplayGfx object pointer (vtable 0x664144)
-    pub display_gfx: Ptr32,
+    pub display_gfx: *mut u8,
     /// 0x13C-0x37F: Unknown
     pub _unknown_13c: [u8; 0x244],
     /// 0x380: TaskStateMachine pointer (vtable 0x664118, 0x2C bytes)
-    pub task_state_machine: Ptr32,
+    pub task_state_machine: *mut u8,
     /// 0x384-0x467: Unknown
     pub _unknown_384: [u8; 0xE4],
     /// 0x468: Landscape-derived value
-    pub _landscape_val: Ptr32,
+    pub _landscape_val: *mut u8,
     /// 0x46C-0x488: 8 SpriteRegion pointers (0x9C bytes each, vtable 0x66B268)
     /// Created by SpriteRegion__Constructor (0x57DB20).
     /// Each contains 32 TaskStateMachine sub-objects.
-    pub sprite_regions: [Ptr32; 8],
+    pub sprite_regions: [*mut u8; 8],
     /// 0x48C-0x508: Arrow collision region pointers (32 entries)
-    pub arrow_collision_regions: [Ptr32; 32],
+    pub arrow_collision_regions: [*mut u8; 32],
     /// 0x50C: Coordinate list object (capacity 600, 0x12C0 data buffer)
-    pub coord_list: Ptr32,
-    /// 0x510-0x98B7: Remaining fields (sparse — see offsets module)
+    pub coord_list: *mut u8,
+    /// 0x510: Weapon table pointer
+    pub weapon_table: *mut u8,
+    /// 0x514-0x523: Unknown
+    pub _unknown_514: [u8; 0x10],
+    /// 0x524: RenderQueue pointer (passed as `this` to all Draw* functions)
+    pub render_queue: *mut RenderQueue,
+    /// 0x528-0x547: Unknown
+    pub _unknown_528: [u8; 0x20],
+    /// 0x548: Weapon panel pointer
+    pub weapon_panel: *mut u8,
+    /// 0x54C-0x98B7: Remaining fields (sparse — see offsets module)
     ///
     /// Known landmarks in this region:
     /// - 0x64D8: cleared by init
@@ -81,7 +91,7 @@ pub struct DDGame {
     ///
     /// Also includes FUN_00526120 zeroed offsets at stride 0x194:
     /// 0x379C, 0x3930, 0x3AC4, 0x3C58, 0x3DEC, 0x3F80, 0x4114, 0x42A8, 0x443C, 0x45D0
-    pub _remaining: [u8; 0x93A8],
+    pub _remaining: [u8; 0x936C],
 }
 
 const _: () = assert!(core::mem::size_of::<DDGame>() == 0x98B8);

crates/openwa-types/src/render.rs

@@ -1,5 +1,3 @@
-use crate::task::Ptr32;
-
 /// Render command entry (0x18 bytes).
 ///
 /// Enqueued by DrawSpriteGlobal (type 4), DrawSpriteLocal (type 5),
@@ -34,8 +32,8 @@ pub struct RenderQueue {
     pub _buffer: [u8; 0x10000],
     /// 0x10004: Number of enqueued entries (max 0x800)
     pub entry_count: u32,
-    /// 0x10008: Pointer array — entry_ptrs[N] points to the N-th DrawSpriteCmd
-    pub entry_ptrs: [Ptr32; 0x800],
+    /// 0x10008: Pointer array — entry_ptrs[N] points to the N-th command
+    pub entry_ptrs: [*mut u8; 0x800],
 }
 
 impl RenderQueue {
@@ -54,10 +52,30 @@ impl RenderQueue {
         self.buffer_offset = new_offset;
 
         let entry = &mut *(self._buffer.as_mut_ptr().add(new_offset as usize) as *mut T);
-        self.entry_ptrs[self.entry_count as usize] = entry as *mut T as u32;
+        self.entry_ptrs[self.entry_count as usize] = entry as *mut T as *mut u8;
         self.entry_count += 1;
         Some(entry)
     }
+
+    /// Allocate `size` bytes from the downward-growing buffer.
+    ///
+    /// Like `alloc<T>()` but for variable-size entries (e.g. DrawLineStrip, DrawPolygon).
+    /// Returns `None` if the queue is full or buffer exhausted.
+    pub unsafe fn alloc_raw(&mut self, size: usize) -> Option<*mut u8> {
+        if self.entry_count >= 0x800 {
+            return None;
+        }
+        let new_offset = self.buffer_offset - size as i32;
+        if new_offset < 0 {
+            return None;
+        }
+        self.buffer_offset = new_offset;
+
+        let ptr = self._buffer.as_mut_ptr().add(new_offset as usize);
+        self.entry_ptrs[self.entry_count as usize] = ptr;
+        self.entry_count += 1;
+        Some(ptr)
+    }
 }
 
 /// Type 0xD — single pixel (0x18 bytes).
@@ -156,6 +174,33 @@ pub struct DrawTextboxLocalCmd {
 
 const _: () = assert!(core::mem::size_of::<DrawTextboxLocalCmd>() == 0x34);
 
+/// Type 8 — line strip header (0x10 bytes, followed by count × 0xC vertex data).
+///
+/// Total allocation: count × 0xC + 0x1C.
+#[repr(C)]
+pub struct DrawLineStripHeader {
+    pub command_type: u32, // 8
+    pub layer: u32,        // hardcoded 0xE_0000
+    pub count: u32,        // vertex count (from EDI)
+    pub param_1: u32,      // stack param
+}
+
+const _: () = assert!(core::mem::size_of::<DrawLineStripHeader>() == 0x10);
+
+/// Type 9 — polygon header (0x14 bytes, followed by count × 0xC vertex data).
+///
+/// Total allocation: count × 0xC + 0x20.
+#[repr(C)]
+pub struct DrawPolygonHeader {
+    pub command_type: u32, // 9
+    pub layer: u32,        // hardcoded 0xE_0000
+    pub count: u32,        // vertex count (from ESI)
+    pub param_1: u32,      // stack param 1
+    pub param_2: u32,      // stack param 2
+}
+
+const _: () = assert!(core::mem::size_of::<DrawPolygonHeader>() == 0x14);
+
 /// Render command type constants.
 pub mod command_type {
     pub const DRAW_RECT: u32 = 0;
@@ -164,6 +209,8 @@ pub mod command_type {
     pub const DRAW_SPRITE_GLOBAL: u32 = 4;
     pub const DRAW_SPRITE_LOCAL: u32 = 5;
     pub const DRAW_SPRITE_OFFSET: u32 = 6;
+    pub const DRAW_LINE_STRIP: u32 = 8;
+    pub const DRAW_POLYGON: u32 = 9;
     pub const DRAW_SCALED: u32 = 0xB;
     pub const DRAW_PIXEL: u32 = 0xD;
 }

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

@@ -36,6 +36,74 @@ unsafe extern "cdecl" fn draw_pixel_impl(
     }
 }
 
+// ---------------------------------------------------------------------------
+// DrawLineStrip (0x541DD0) — type 8, EAX=this, EDI=count, 2 stack, RET 0x8
+// Allocation: count * 0xC + 0x1C (variable size)
+// ---------------------------------------------------------------------------
+
+usercall_trampoline!(fn trampoline_draw_line_strip; impl_fn = draw_line_strip_impl;
+    regs = [eax, edi]; stack_params = 2; ret_bytes = "0x8");
+
+unsafe extern "cdecl" fn draw_line_strip_impl(
+    this: u32,
+    count: u32,
+    vertex_ptr: u32,
+    param_1: u32,
+) {
+    let q = &mut *(this as *mut RenderQueue);
+    let total_size = count as usize * 0xC + 0x1C;
+
+    if let Some(ptr) = q.alloc_raw(total_size) {
+        let header = &mut *(ptr as *mut DrawLineStripHeader);
+        *header = DrawLineStripHeader {
+            command_type: command_type::DRAW_LINE_STRIP,
+            layer: 0xE_0000,
+            count,
+            param_1,
+        };
+        core::ptr::copy_nonoverlapping(
+            vertex_ptr as *const u8,
+            ptr.add(core::mem::size_of::<DrawLineStripHeader>()),
+            count as usize * 0xC,
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------
+// DrawPolygon (0x541E50) — type 9, ECX=this, ESI=count, 3 stack, RET 0xC
+// Allocation: count * 0xC + 0x20 (variable size)
+// ---------------------------------------------------------------------------
+
+usercall_trampoline!(fn trampoline_draw_polygon; impl_fn = draw_polygon_impl;
+    regs = [ecx, esi]; stack_params = 3; ret_bytes = "0xC");
+
+unsafe extern "cdecl" fn draw_polygon_impl(
+    this: u32,
+    count: u32,
+    vertex_ptr: u32,
+    param_1: u32,
+    param_2: u32,
+) {
+    let q = &mut *(this as *mut RenderQueue);
+    let total_size = count as usize * 0xC + 0x20;
+
+    if let Some(ptr) = q.alloc_raw(total_size) {
+        let header = &mut *(ptr as *mut DrawPolygonHeader);
+        *header = DrawPolygonHeader {
+            command_type: command_type::DRAW_POLYGON,
+            layer: 0xE_0000,
+            count,
+            param_1,
+            param_2,
+        };
+        core::ptr::copy_nonoverlapping(
+            vertex_ptr as *const u8,
+            ptr.add(core::mem::size_of::<DrawPolygonHeader>()),
+            count as usize * 0xC,
+        );
+    }
+}
+
 // ---------------------------------------------------------------------------
 // DrawScaled (0x541ED0) — type 0xB, ECX=this, 5 stack, RET 0x14
 // ---------------------------------------------------------------------------
@@ -276,6 +344,18 @@ pub unsafe fn install() -> Result<(), String> {
         trampoline_draw_pixel as *const (),
     )?;
 
+    let _ = hook::install(
+        "DrawLineStrip",
+        va::DRAW_LINE_STRIP,
+        trampoline_draw_line_strip as *const (),
+    )?;
+
+    let _ = hook::install(
+        "DrawPolygon",
+        va::DRAW_POLYGON,
+        trampoline_draw_polygon as *const (),
+    )?;
+
     let _ = hook::install(
         "DrawScaled",
         va::DRAW_SCALED,