feat: line-drawing snapshot test infrastructure

Add PixelGrid (pure-Rust test grid) and PixelWriter trait for unit
testing line algorithms without WA runtime. Add snapshot capture in
DLL (OPENWA_CAPTURE_LINE_SNAPSHOTS=1, triggered at frame 10) that
draws test lines on a BitGrid using WA's native functions and saves
pixel data for comparison.

Also fix headful test crash: remove --minimized flag which became
incompatible with WA's DirectDraw initialization.

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

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

@@ -0,0 +1,289 @@
+//! Line-drawing algorithms for 8bpp BitGrid surfaces.
+//!
+//! Pure Rust ports of WA's thick-line drawing system (0x4F7500 / 0x4F7A60).
+//! The original draws 2-pixel-wide Bresenham-style lines with Fixed-point
+//! Cohen-Sutherland clipping.
+//!
+//! ## Architecture
+//!
+//! ```text
+//! draw_line_clipped / draw_line_two_color (outer dispatch)
+//!   ├── Determine dominant axis (|dx| vs |dy|)
+//!   ├── Sort endpoints in positive direction
+//!   ├── clip_line() — Cohen-Sutherland, Fixed-point
+//!   ├── Rasterizer (horizontal-major or vertical-major)
+//!   │     └── put_pixel_clipped × 8 per step (outline)
+//!   └── Fill rasterizer — 4 pixels per step (body color)
+//! ```
+
+use crate::fixed::Fixed;
+
+/// Trait for pixel-addressable surfaces used by line-drawing algorithms.
+///
+/// Implemented for `PixelGrid` (test-only, pure Rust) and can be implemented
+/// for `DisplayBitGrid` (runtime, via vtable dispatch).
+pub trait PixelWriter {
+    fn put_pixel_clipped(&mut self, x: i32, y: i32, color: u8);
+    fn clip_left(&self) -> i32;
+    fn clip_top(&self) -> i32;
+    fn clip_right(&self) -> i32;
+    fn clip_bottom(&self) -> i32;
+}
+
+/// Pure-Rust 8bpp pixel grid for unit testing. No vtable, no WA heap.
+///
+/// Row-major layout: `data[y * row_stride + x]`.
+/// Row stride is 4-byte aligned (matching WA's BitGrid allocation).
+pub struct PixelGrid {
+    pub data: Vec<u8>,
+    pub width: u32,
+    pub height: u32,
+    pub row_stride: u32,
+    pub clip_left: u32,
+    pub clip_top: u32,
+    pub clip_right: u32,
+    pub clip_bottom: u32,
+}
+
+impl PixelGrid {
+    /// Create a new zeroed pixel grid with default clip rect covering the full surface.
+    pub fn new(width: u32, height: u32) -> Self {
+        let row_stride = (width + 3) & !3; // 4-byte aligned
+        let size = (row_stride * height) as usize;
+        Self {
+            data: vec![0u8; size],
+            width,
+            height,
+            row_stride,
+            clip_left: 0,
+            clip_top: 0,
+            clip_right: width,
+            clip_bottom: height,
+        }
+    }
+
+    /// Clear all pixels to zero.
+    pub fn clear(&mut self) {
+        self.data.fill(0);
+    }
+}
+
+impl PixelWriter for PixelGrid {
+    #[inline]
+    fn put_pixel_clipped(&mut self, x: i32, y: i32, color: u8) {
+        if x >= self.clip_left as i32
+            && x < self.clip_right as i32
+            && y >= self.clip_top as i32
+            && y < self.clip_bottom as i32
+        {
+            self.data[(y as u32 * self.row_stride + x as u32) as usize] = color;
+        }
+    }
+
+    #[inline]
+    fn clip_left(&self) -> i32 {
+        self.clip_left as i32
+    }
+    #[inline]
+    fn clip_top(&self) -> i32 {
+        self.clip_top as i32
+    }
+    #[inline]
+    fn clip_right(&self) -> i32 {
+        self.clip_right as i32
+    }
+    #[inline]
+    fn clip_bottom(&self) -> i32 {
+        self.clip_bottom as i32
+    }
+}
+
+// =========================================================================
+// Fixed-point line clipping (port of 0x4F7150)
+// =========================================================================
+
+/// Cohen-Sutherland outcode bits for line clipping.
+const LEFT: u8 = 1;
+const RIGHT: u8 = 2;
+const TOP: u8 = 4;
+const BOTTOM: u8 = 8;
+
+/// Compute Cohen-Sutherland outcode for a Fixed-point coordinate.
+fn outcode(x: Fixed, y: Fixed, clip: &ClipRect) -> u8 {
+    let mut code = 0u8;
+    if x.to_raw() < clip.left.to_raw() {
+        code |= LEFT;
+    }
+    if x.to_raw() > clip.right.to_raw() {
+        code |= RIGHT;
+    }
+    if y.to_raw() < clip.top.to_raw() {
+        code |= TOP;
+    }
+    if y.to_raw() > clip.bottom.to_raw() {
+        code |= BOTTOM;
+    }
+    code
+}
+
+/// Clip rectangle in Fixed-point coordinates.
+struct ClipRect {
+    left: Fixed,
+    top: Fixed,
+    right: Fixed,
+    bottom: Fixed,
+}
+
+/// Fixed-point multiply then shift: `(a * b) >> 16`.
+///
+/// Port of the pattern used throughout the WA line clipper.
+#[inline]
+fn fixed_mul_shift(a: i32, b: i32) -> i32 {
+    ((a as i64 * b as i64) >> 16) as i32
+}
+
+/// Clip a line segment to the clip rectangle.
+///
+/// Port of 0x4F7150. Returns true if the clipped line is visible.
+/// Modifies coordinates in-place.
+///
+/// The clip rectangle is read from the PixelWriter's bounds, scaled to Fixed.
+fn clip_line(
+    x1: &mut Fixed,
+    y1: &mut Fixed,
+    x2: &mut Fixed,
+    y2: &mut Fixed,
+    writer: &dyn PixelWriter,
+) -> bool {
+    let clip = ClipRect {
+        left: Fixed::from_int(writer.clip_left()),
+        top: Fixed::from_int(writer.clip_top()),
+        right: Fixed::from_int(writer.clip_right()),
+        bottom: Fixed::from_int(writer.clip_bottom()),
+    };
+
+    let code1 = outcode(*x1, *y1, &clip);
+    let code2 = outcode(*x2, *y2, &clip);
+
+    // Trivial reject: both endpoints on same side
+    if code1 & code2 != 0 {
+        return false;
+    }
+
+    // Clip x1 against left/right bounds
+    if x1.to_raw() < clip.left.to_raw() {
+        let ratio = fixed_div(clip.left.to_raw() - x1.to_raw(), x2.to_raw() - x1.to_raw());
+        y1.0 += fixed_mul_shift(y2.to_raw() - y1.to_raw(), ratio);
+        *x1 = clip.left;
+    } else if x1.to_raw() > clip.right.to_raw() {
+        let ratio = fixed_div(clip.right.to_raw() - x1.to_raw(), x2.to_raw() - x1.to_raw());
+        y1.0 += fixed_mul_shift(y2.to_raw() - y1.to_raw(), ratio);
+        *x1 = clip.right;
+    }
+
+    // Clip x2 against left/right bounds
+    if x2.to_raw() < clip.left.to_raw() {
+        let ratio = fixed_div(clip.left.to_raw() - x2.to_raw(), x1.to_raw() - x2.to_raw());
+        y2.0 += fixed_mul_shift(y1.to_raw() - y2.to_raw(), ratio);
+        *x2 = clip.left;
+    } else if x2.to_raw() > clip.right.to_raw() {
+        let ratio = fixed_div(clip.right.to_raw() - x2.to_raw(), x1.to_raw() - x2.to_raw());
+        y2.0 += fixed_mul_shift(y1.to_raw() - y2.to_raw(), ratio);
+        *x2 = clip.right;
+    }
+
+    // Check y bounds after x clipping
+    if y1.to_raw() > clip.bottom.to_raw() || y2.to_raw() > clip.bottom.to_raw() {
+        return false;
+    }
+    if y1.to_raw() < clip.top.to_raw() && y2.to_raw() < clip.top.to_raw() {
+        return false;
+    }
+
+    // Clip y1 against top/bottom bounds
+    if y1.to_raw() < clip.top.to_raw() {
+        let ratio = fixed_div(clip.top.to_raw() - y1.to_raw(), y2.to_raw() - y1.to_raw());
+        x1.0 += fixed_mul_shift(x2.to_raw() - x1.to_raw(), ratio);
+        *y1 = clip.top;
+    } else if y1.to_raw() > clip.bottom.to_raw() {
+        let ratio = fixed_div(
+            clip.bottom.to_raw() - y1.to_raw(),
+            y2.to_raw() - y1.to_raw(),
+        );
+        x1.0 += fixed_mul_shift(x2.to_raw() - x1.to_raw(), ratio);
+        *y1 = clip.bottom;
+    }
+
+    // Clip y2 against top/bottom bounds
+    if y2.to_raw() < clip.top.to_raw() {
+        let ratio = fixed_div(clip.top.to_raw() - y2.to_raw(), y1.to_raw() - y2.to_raw());
+        x2.0 += fixed_mul_shift(x1.to_raw() - x2.to_raw(), ratio);
+        *y2 = clip.top;
+    } else if y2.to_raw() > clip.bottom.to_raw() {
+        let ratio = fixed_div(
+            clip.bottom.to_raw() - y2.to_raw(),
+            y1.to_raw() - y2.to_raw(),
+        );
+        x2.0 += fixed_mul_shift(x1.to_raw() - x2.to_raw(), ratio);
+        *y2 = clip.bottom;
+    }
+
+    // Final check: both endpoints must be within bounds
+    if (x1.to_raw() < clip.left.to_raw() || x1.to_raw() > clip.right.to_raw())
+        && (x2.to_raw() < clip.left.to_raw() || x2.to_raw() > clip.right.to_raw())
+    {
+        return false;
+    }
+
+    true
+}
+
+/// Fixed-point divide used by the line clipper.
+///
+/// Port of FUN_005b3501: computes `(numerator << 16) / denominator`.
+#[inline]
+fn fixed_div(numerator: i32, denominator: i32) -> i32 {
+    if denominator == 0 {
+        return 0;
+    }
+    (((numerator as i64) << 16) / denominator as i64) as i32
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pixel_grid_basic() {
+        let mut grid = PixelGrid::new(16, 16);
+        grid.put_pixel_clipped(5, 5, 0xFF);
+        assert_eq!(grid.data[5 * grid.row_stride as usize + 5], 0xFF);
+
+        // Out of bounds — should be no-op
+        grid.put_pixel_clipped(-1, 5, 0xAA);
+        grid.put_pixel_clipped(16, 5, 0xAA);
+        grid.put_pixel_clipped(5, -1, 0xAA);
+        grid.put_pixel_clipped(5, 16, 0xAA);
+    }
+
+    #[test]
+    fn pixel_grid_clipping() {
+        let mut grid = PixelGrid::new(16, 16);
+        grid.clip_left = 4;
+        grid.clip_top = 4;
+        grid.clip_right = 12;
+        grid.clip_bottom = 12;
+
+        // Inside clip rect — should write
+        grid.put_pixel_clipped(4, 4, 1);
+        assert_eq!(grid.data[4 * grid.row_stride as usize + 4], 1);
+
+        // At clip boundary (exclusive) — should NOT write
+        grid.put_pixel_clipped(12, 4, 2);
+        assert_eq!(grid.data[4 * grid.row_stride as usize + 12], 0);
+
+        // Outside clip rect — should NOT write
+        grid.put_pixel_clipped(3, 4, 3);
+        assert_eq!(grid.data[4 * grid.row_stride as usize + 3], 0);
+    }
+}

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

@@ -5,6 +5,7 @@ pub mod dd_display;
 pub mod display_wrapper;
 pub mod gfx;
 pub mod gradient;
+pub mod line_draw;
 pub mod opengl;
 pub mod palette;
 

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

@@ -48,6 +48,134 @@ unsafe extern "thiscall" fn headless_destructor(
     this
 }
 
+/// Capture line-drawing snapshots from WA's native BitGrid line functions.
+///
+/// Creates a test BitGrid, calls WA line functions with known inputs,
+/// saves pixel data to `testdata/snapshots/`. Activated by
+/// `OPENWA_CAPTURE_LINE_SNAPSHOTS=1`.
+pub unsafe fn capture_line_snapshots() {
+    use openwa_core::display::bitgrid::DisplayBitGrid;
+    use std::fs;
+    use std::io::Write;
+
+    let grid_w: u32 = 128;
+    let grid_h: u32 = 128;
+    let grid = DisplayBitGrid::alloc(8, grid_w, grid_h);
+    if grid.is_null() {
+        let _ = log_line("[Display] SNAPSHOT: Failed to allocate test BitGrid");
+        return;
+    }
+
+    let row_stride = (*grid).row_stride;
+    let data_ptr = (*grid).data;
+    let data_size = (row_stride * grid_h) as usize;
+
+    // WA line functions (stdcall)
+    let draw_clipped: unsafe extern "stdcall" fn(*mut DisplayBitGrid, i32, i32, i32, i32, u32) =
+        core::mem::transmute(rb(va::DRAW_LINE_CLIPPED) as usize);
+
+    let draw_two: unsafe extern "stdcall" fn(*mut DisplayBitGrid, i32, i32, i32, i32, u32, u32) =
+        core::mem::transmute(rb(va::DRAW_LINE_TWO_COLOR) as usize);
+
+    let dir = "testdata/snapshots";
+    let _ = fs::create_dir_all(dir);
+
+    // Macro: clear grid, reset clip, run drawing code, save to file.
+    macro_rules! snap {
+        ($name:expr, $body:expr) => {{
+            core::ptr::write_bytes(data_ptr, 0, data_size);
+            (*grid).clip_left = 0;
+            (*grid).clip_top = 0;
+            (*grid).clip_right = grid_w;
+            (*grid).clip_bottom = grid_h;
+            $body;
+            let path = format!("{}/{}.bin", dir, $name);
+            if let Ok(mut file) = fs::File::create(&path) {
+                let _ = file.write_all(&grid_w.to_le_bytes());
+                let _ = file.write_all(&grid_h.to_le_bytes());
+                let _ = file.write_all(&row_stride.to_le_bytes());
+                let _ = file.write_all(core::slice::from_raw_parts(data_ptr, data_size));
+            }
+        }};
+    }
+
+    let f = |x: i32| x << 16; // int to Fixed raw
+    let mut count = 0u32;
+
+    // Single-color line tests
+    for &(name, x1, y1, x2, y2, color) in &[
+        ("clipped_horizontal", f(10), f(64), f(118), f(64), 1u32),
+        ("clipped_vertical", f(64), f(10), f(64), f(118), 2),
+        ("clipped_diagonal_45", f(10), f(10), f(118), f(118), 3),
+        ("clipped_diagonal_steep", f(60), f(10), f(68), f(118), 4),
+        ("clipped_diagonal_shallow", f(10), f(60), f(118), f(68), 5),
+        ("clipped_negative_slope", f(118), f(10), f(10), f(118), 6),
+        (
+            "clipped_subpixel",
+            f(10) + 0x8000,
+            f(20) + 0x4000,
+            f(100) + 0xC000,
+            f(80) + 0x2000,
+            7,
+        ),
+        ("clipped_zero_length", f(64), f(64), f(64), f(64), 8),
+        ("clipped_partially_outside", f(-20), f(64), f(148), f(64), 9),
+        ("clipped_fully_outside", f(-50), f(-50), f(-10), f(-10), 10),
+    ] {
+        snap!(name, draw_clipped(grid, x1, y1, x2, y2, color));
+        count += 1;
+    }
+
+    // Two-color line tests
+    for &(name, x1, y1, x2, y2, c1, c2) in &[
+        ("twocol_horizontal", f(10), f(64), f(118), f(64), 1u32, 2u32),
+        ("twocol_vertical", f(64), f(10), f(64), f(118), 1, 2),
+        ("twocol_diagonal_45", f(10), f(10), f(118), f(118), 1, 2),
+        ("twocol_steep", f(60), f(10), f(68), f(118), 3, 4),
+        ("twocol_shallow", f(10), f(60), f(118), f(68), 3, 4),
+        ("twocol_negative", f(118), f(10), f(10), f(118), 5, 6),
+        (
+            "twocol_subpixel",
+            f(10) + 0x8000,
+            f(20) + 0x4000,
+            f(100) + 0xC000,
+            f(80) + 0x2000,
+            7,
+            8,
+        ),
+    ] {
+        snap!(name, draw_two(grid, x1, y1, x2, y2, c1, c2));
+        count += 1;
+    }
+
+    // Restricted clip rect tests
+    snap!("clipped_restricted_clip", {
+        (*grid).clip_left = 30;
+        (*grid).clip_top = 30;
+        (*grid).clip_right = 98;
+        (*grid).clip_bottom = 98;
+        draw_clipped(grid, f(10), f(10), f(118), f(118), 11)
+    });
+    count += 1;
+
+    snap!("twocol_restricted_clip", {
+        (*grid).clip_left = 30;
+        (*grid).clip_top = 30;
+        (*grid).clip_right = 98;
+        (*grid).clip_bottom = 98;
+        draw_two(grid, f(10), f(10), f(118), f(118), 9, 10)
+    });
+    count += 1;
+
+    let _ = log_line(&format!(
+        "[Display] SNAPSHOT: Saved {count} line snapshots to {dir}/"
+    ));
+
+    // Free the grid
+    let destructor = (*(*grid).vtable).destructor;
+    destructor(grid, 1);
+}
+
 pub fn install() -> Result<(), String> {
     let _ = log_line("[Display] Patching DisplayBase vtables");
 

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

@@ -63,6 +63,13 @@ unsafe extern "stdcall" fn hook_turn_manager(turngame: u32) {
 
     let frame = FRAMES_PROCESSED.fetch_add(1, Ordering::Relaxed) + 1;
 
+    // Line snapshot capture: run once at frame 10 when env var is set
+    if frame == 10 {
+        if std::env::var("OPENWA_CAPTURE_LINE_SNAPSHOTS").is_ok() {
+            super::display::capture_line_snapshots();
+        }
+    }
+
     // Replay test: fast-forward + milestone tracking (no-op if not in replay test mode)
     super::replay_test::on_frame(frame);
 }

crates/openwa-test-runner/src/main.rs

@@ -816,7 +816,6 @@ fn run_headful_test(
     let errorlog_path = run_dir.join(format!("{}.errorlog.txt", test.name));
 
     let result = Command::new(launcher)
-        .arg("--minimized")
         .arg(wa_exe)
         .arg(&test.replay_path)
         .env("OPENWA_REPLAY_TEST", "1")

testdata/snapshots/clipped_diagonal_45.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6d578b7421ee45ef7d10700614024892972c3ab255705fc7ec750dc4b70852b
+size 16396

testdata/snapshots/clipped_diagonal_shallow.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4154d14e49950ce44801998957d4d316287a574d2006db21e262c5b7459521e
+size 16396

testdata/snapshots/clipped_diagonal_steep.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4f9440349534e65a92869a779075877c14fd169bf58ff1074c438b80919e72c
+size 16396

testdata/snapshots/clipped_fully_outside.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60d2f81832d645fd3abf309ea419b7c75bfa3516cd69f8105fa35c89a0c58c1d
+size 16396

testdata/snapshots/clipped_horizontal.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd0f3f8abfa05ba3d0483c8c2b974d9a1efbbc7558d32d8d32666c723cba9801
+size 16396

testdata/snapshots/clipped_negative_slope.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ceedb4d2c03ad3b6ebf3f1be84a8b13580d7500b991b496d0077004cbeb8e79
+size 16396

testdata/snapshots/clipped_partially_outside.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6e4be906d80defb36b321eff3f64be21c13ac43f5f24749be5119dbf97b010e
+size 16396

testdata/snapshots/clipped_restricted_clip.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd3afc44b242bbc7c03109e564660e8ca8aa3af2d6558730025044601ae5bdb6
+size 16396

testdata/snapshots/clipped_subpixel.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc55020f352f34210d0e0ca685979f3a5a94552fbda4303b55d2b6206a20c665
+size 16396

testdata/snapshots/clipped_vertical.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d858f5c4aafd68f2fa4ae6cbeea4ea8443889db40a7c70817734b1edd80c7bd9
+size 16396

testdata/snapshots/clipped_zero_length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60d2f81832d645fd3abf309ea419b7c75bfa3516cd69f8105fa35c89a0c58c1d
+size 16396

testdata/snapshots/twocol_diagonal_45.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dd5a7b9994e85f003fe1c19ca8fdb34e94894ebe9e710124d1fc6b6b31aa1ea
+size 16396

testdata/snapshots/twocol_horizontal.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afb48702dc248c6fc3a0e6a6dcd603420997b2b894034114e641bfddec57170b
+size 16396

testdata/snapshots/twocol_negative.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2cb64e70b3dfc6ff185ff08494ffd0f799d872492470611fcea89c53b51518d
+size 16396

testdata/snapshots/twocol_restricted_clip.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cef5d61f71bc09964371eed8157c000bd0f404678d9bd6b5e78cff68f8379845
+size 16396

testdata/snapshots/twocol_shallow.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b1ea09b4e78cd1f0fa1ad38665f3225cc016ff957c680c1a1fe42b656e3ffe6
+size 16396

testdata/snapshots/twocol_steep.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d545b902251a860bd4f6753b0e8b6d8181cd21fc512dddf6fd4d93abf4b9ac94
+size 16396

testdata/snapshots/twocol_subpixel.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e47b85680ab580348b4abf968d1c4b9dd3b0491f84fd2f95bf919f237b98d1f
+size 16396

testdata/snapshots/twocol_vertical.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f98dec117c9422729adf2ce21d479d8513e3b1a62ef6de8b17a50c27244f4a50
+size 16396