feat: port DDDisplay draw_line, draw_line_clipped, draw_pixel_strip

draw_line (slot 13) and draw_line_clipped (slot 14) apply Fixed-point
camera offset and delegate to BitGrid line-drawing routines at 0x4F7A60
and 0x4F7500 (both stdcall). draw_pixel_strip (slot 15) iterates
count+1 pixels along a Fixed-point vector using put_pixel_clipped.

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

crates/openwa-core/src/address.rs

@@ -73,7 +73,8 @@ pub mod va {
     pub use crate::display::base::DISPLAY_BASE_VTABLE;
     pub use crate::display::bitgrid::{
         BitGridBaseVtable, BitGridCollisionVtable, BitGridDisplayVtable, BIT_GRID_BASE_VTABLE,
-        BIT_GRID_COLLISION_VTABLE, BIT_GRID_DISPLAY_VTABLE, BIT_GRID_INIT,
+        BIT_GRID_COLLISION_VTABLE, BIT_GRID_DISPLAY_VTABLE, BIT_GRID_INIT, DRAW_LINE_CLIPPED,
+        DRAW_LINE_TWO_COLOR,
     };
     pub use crate::display::compat_renderer::{
         CompatRendererVtable, COMPAT_RENDERER_VTABLE, DDRAW8_RENDERER_VTABLE,

crates/openwa-core/src/display/bitgrid.rs

@@ -44,6 +44,10 @@ crate::define_addresses! {
     class "BitGrid" {
         /// BitGrid::init (0x4F6370) — allocates buffer, sets base vtable
         fn BIT_GRID_INIT = 0x004F_6370;
+        /// Clipped line draw on 8bpp BitGrid (0x4F7500)
+        fn DRAW_LINE_CLIPPED = 0x004F_7500;
+        /// Two-color line draw on 8bpp BitGrid (0x4F7A60)
+        fn DRAW_LINE_TWO_COLOR = 0x004F_7A60;
     }
 }
 

crates/openwa-core/src/display/dd_display.rs

@@ -640,3 +640,105 @@ pub unsafe extern "thiscall" fn draw_crosshair(
     DisplayBitGrid::put_pixel_clipped_raw(layer, cx, cy + 1, fg);
     DisplayBitGrid::put_pixel_clipped_raw(layer, cx + 1, cy + 1, fg);
 }
+
+/// Port of DDDisplay::DrawLine (vtable slot 13, 0x56BDB0).
+///
+/// Draws a two-color line. Fixed-point coordinates with camera offset
+/// applied as `camera * 0x10000 + coord`. Delegates to the BitGrid
+/// line-drawing routine at 0x4F7A60.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn draw_line(
+    this: *mut DDDisplay,
+    x1: Fixed,
+    y1: Fixed,
+    x2: Fixed,
+    y2: Fixed,
+    color1: u32,
+    color2: u32,
+) {
+    let gfx = this as *mut DisplayGfx;
+    let cam_x = Fixed::from_int((*gfx).camera_x);
+    let cam_y = Fixed::from_int((*gfx).camera_y);
+
+    acquire_render_lock(gfx);
+
+    let draw: unsafe extern "stdcall" fn(*mut DisplayBitGrid, i32, i32, i32, i32, u32, u32) =
+        core::mem::transmute(rb(va::DRAW_LINE_TWO_COLOR) as usize);
+    draw(
+        (*gfx).layer_0,
+        (x1 + cam_x).to_raw(),
+        (y1 + cam_y).to_raw(),
+        (x2 + cam_x).to_raw(),
+        (y2 + cam_y).to_raw(),
+        color1,
+        color2,
+    );
+}
+
+/// Port of DDDisplay::DrawLineClipped (vtable slot 14, 0x56BD50).
+///
+/// Draws a single-color clipped line. Fixed-point coordinates with camera
+/// offset. Delegates to the BitGrid clipped line routine at 0x4F7500.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn draw_line_clipped(
+    this: *mut DDDisplay,
+    x1: Fixed,
+    y1: Fixed,
+    x2: Fixed,
+    y2: Fixed,
+    color: u32,
+) {
+    let gfx = this as *mut DisplayGfx;
+    let cam_x = Fixed::from_int((*gfx).camera_x);
+    let cam_y = Fixed::from_int((*gfx).camera_y);
+
+    acquire_render_lock(gfx);
+
+    let draw: unsafe extern "stdcall" fn(*mut DisplayBitGrid, i32, i32, i32, i32, u32) =
+        core::mem::transmute(rb(va::DRAW_LINE_CLIPPED) as usize);
+    draw(
+        (*gfx).layer_0,
+        (x1 + cam_x).to_raw(),
+        (y1 + cam_y).to_raw(),
+        (x2 + cam_x).to_raw(),
+        (y2 + cam_y).to_raw(),
+        color,
+    );
+}
+
+/// Port of DDDisplay::DrawPixelStrip (vtable slot 15, 0x56BE10).
+///
+/// Draws `count + 1` pixels starting at (x, y), stepping by (dx, dy) each
+/// iteration. All coordinates are Fixed-point. Camera applied as
+/// `camera * 0x10000 + coord`.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn draw_pixel_strip(
+    this: *mut DDDisplay,
+    x: Fixed,
+    y: Fixed,
+    dx: Fixed,
+    dy: Fixed,
+    count: i32,
+    color: u32,
+) {
+    let gfx = this as *mut DisplayGfx;
+    let mut cx = Fixed::from_int((*gfx).camera_x) + x;
+    let mut cy = Fixed::from_int((*gfx).camera_y) + y;
+
+    acquire_render_lock(gfx);
+
+    let layer = (*gfx).layer_0;
+    if count >= 0 {
+        for _ in 0..=count {
+            DisplayBitGrid::put_pixel_clipped_raw(layer, cx.to_int(), cy.to_int(), color as u8);
+            cx += dx;
+            cy += dy;
+        }
+    }
+}

crates/openwa-dll/src/replacements/display.rs

@@ -82,6 +82,9 @@ pub fn install() -> Result<(), String> {
         // Patch DDDisplay vtable (0x66A218): replace ported methods with Rust.
         vtable_replace!(DDDisplayVtable, va::DD_DISPLAY_VTABLE, {
             get_dimensions      => dd_display::get_dimensions,
+            draw_line           => dd_display::draw_line,
+            draw_line_clipped   => dd_display::draw_line_clipped,
+            draw_pixel_strip    => dd_display::draw_pixel_strip,
             draw_crosshair      => dd_display::draw_crosshair,
             draw_outlined_pixel => dd_display::draw_outlined_pixel,
             fill_rect           => dd_display::fill_rect,
@@ -89,7 +92,7 @@ pub fn install() -> Result<(), String> {
             set_camera_offset   => dd_display::set_camera_offset,
             set_clip_rect       => dd_display::set_clip_rect,
         })?;
-        let _ = log_line("[Display]   DDDisplay: patched 7 methods → Rust");
+        let _ = log_line("[Display]   DDDisplay: patched 10 methods → Rust");
     }
 
     Ok(())