refactor: typed BitGrid variants with alloc constructors

Make BitGrid<V> generic over a typed vtable pointer (default =
*const BitGridBaseVtable), removing the unsafe impl Vtable for u32.

Three typed variants, each with its own vtable and alloc constructor:
- BitGrid (base, 0x6640EC) — passive data container, gradient images
- CollisionBitGrid (0x664118) — DDGame+0x380 terrain collision grid
- DisplayBitGrid (0x664144) — rendering layers, sprite pixel buffers

Convenience constructors handle malloc + init + vtable override:
CollisionBitGrid::alloc(1, width, height)
DisplayBitGrid::alloc(8, 0x100, 0x1E0)

Move all BitGrid vtable addresses from address.rs into bitgrid.rs.
Update DDGame fields to use typed pointers (collision_grid, display_bitgrid).

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

crates/openwa-core/src/address.rs

@@ -71,7 +71,10 @@ pub mod va {
         STREAMING_AUDIO_RESET, STREAMING_AUDIO_STOP, STREAMING_AUDIO_TIMER_CALLBACK,
     };
     pub use crate::display::base::DISPLAY_BASE_VTABLE;
-    pub use crate::display::bitgrid::{BitGridDisplayVtable, BIT_GRID_DISPLAY_VTABLE};
+    pub use crate::display::bitgrid::{
+        BitGridBaseVtable, BitGridCollisionVtable, BitGridDisplayVtable, BIT_GRID_BASE_VTABLE,
+        BIT_GRID_COLLISION_VTABLE, BIT_GRID_DISPLAY_VTABLE, BIT_GRID_INIT,
+    };
     pub use crate::display::compat_renderer::{
         CompatRendererVtable, COMPAT_RENDERER_VTABLE, DDRAW8_RENDERER_VTABLE,
     };
@@ -182,8 +185,7 @@ pub mod va {
             fn/Usercall INPUT_CTRL_INIT = 0x0058_C0D0;
         }
 
-        // TaskStateMachine was our old name for BitGrid before we understood it.
-        // Vtable 0x664118 is now BIT_GRID_VARIANT_VTABLE in the BitGrid class block.
+        // BitGrid vtables and init are now in display::bitgrid via define_addresses! + #[vtable].
 
         class "OpenGLCPU" {
             /// OpenGLCPU vtable (0x48-byte object)
@@ -225,15 +227,6 @@ pub mod va {
             fn GFX_DIR_LOAD_IMAGE = 0x0056_66D0;
         }
 
-        class "BitGrid" {
-            /// BitGrid base vtable
-            vtable BIT_GRID_VTABLE = 0x0066_40EC;
-            /// BitGrid variant vtable (used for DDGame+0x380 collision grid)
-            vtable BIT_GRID_VARIANT_VTABLE = 0x0066_4118;
-            /// BitGrid init
-            fn BIT_GRID_INIT = 0x004F_6370;
-        }
-
         class "DisplayGfx" {
             /// DisplayGfx constructor
             ctor/Stdcall DISPLAYGFX_CTOR = 0x0056_9C10;

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

@@ -1,40 +1,73 @@
-//! BitGrid — 2D pixel/bit buffer used for rendering layers and spatial queries.
+//! BitGrid — general-purpose 2D grid buffer.
 //!
-//! Two vtables:
-//! - **Base** (0x6640EC): Bitfield grid for spatial queries (collision, visibility).
-//!   Initialized by `BitGrid::init` (0x4F6370). Size: 0x2C bytes.
-//! - **Display layer** (0x664144, 8 slots): Pixel buffer with drawing primitives.
-//!   Used as rendering layers in DisplayGfx (+0x3D9C/+0x3DA0/+0x3DA4).
-//!   Allocated at 0x4C bytes; first 0x2C bytes share the base layout.
+//! A polymorphic pixel/bit buffer used across WA's rendering and physics systems.
+//! The same struct layout serves multiple roles, distinguished by vtable:
 //!
-//! ## Field reinterpretation (display-layer context)
+//! | Vtable     | Type                | Role                         |
+//! |------------|---------------------|------------------------------|
+//! | 0x6640EC   | `BitGrid`           | Base — set by `init`, passive data container |
+//! | 0x664118   | `CollisionBitGrid`  | Collision grid (DDGame+0x380), bit-level spatial queries |
+//! | 0x664144   | `DisplayBitGrid`    | Display layers and sprite pixel buffers, 8bpp byte-level ops |
 //!
-//! Some fields have different semantics when used as a display layer:
-//! - `cells_per_unit` (+0x0C) → bit depth (8 for 8bpp)
-//! - `width/height` (+0x14/+0x18) → unused
-//! - `_unused_1c/_unused_20` (+0x1C/+0x20) → clip_left / clip_top
-//! - `width_dup/height_dup` (+0x24/+0x28) → clip_right / clip_bottom
+//! All three vtables share the same 8-slot interface:
+//!
+//! | Slot | Method           | Base          | Collision     | Display       |
+//! |------|------------------|---------------|---------------|---------------|
+//! | 0    | fill_rect        | bit-level     | bit-level     | byte-level    |
+//! | 1    | fill_hline       | bit-level *   | bit-level *   | byte-level    |
+//! | 2    | fill_vline       | bit-level *   | bit-level *   | byte-level    |
+//! | 3    | destructor       | shared *      | shared *      | shared *      |
+//! | 4    | get_clipped      | bit-level     | bit-level     | byte-level    |
+//! | 5    | put_clipped      | bit-level     | bit-level     | byte-level    |
+//! | 6    | get              | stub          | bit-level     | byte-level    |
+//! | 7    | put              | stub          | bit-level     | byte-level    |
+//!
+//! * = same function pointer shared between variants.
+//!
+//! ## Initialization pattern
+//!
+//! `BitGrid::init` allocates the data buffer, fills in all fields, and sets
+//! the base vtable (0x6640EC). Callers then cast and override the vtable:
+//!
+//! ```text
+//! BitGrid::init(grid, cells_per_unit, width, height);
+//! let display_grid = grid as *mut DisplayBitGrid;
+//! (*display_grid).vtable = rb_ptr(BIT_GRID_DISPLAY_VTABLE);
+//! ```
 
-use crate::address::va;
 use crate::rebase::rb;
-use crate::wa_alloc::wa_malloc;
+use crate::task::base::Vtable;
+use crate::wa_alloc::{wa_malloc, wa_malloc_struct_zeroed};
 use crate::FieldRegistry;
 
-/// BitGrid — 2D pixel/bit buffer.
+crate::define_addresses! {
+    class "BitGrid" {
+        /// BitGrid::init (0x4F6370) — allocates buffer, sets base vtable
+        fn BIT_GRID_INIT = 0x004F_6370;
+    }
+}
+
+/// BitGrid — general-purpose 2D grid buffer.
+///
+/// Generic over vtable pointer type `V`:
+/// - `BitGrid` (default): base form with passive data vtable (0x6640EC).
+/// - `CollisionBitGrid`: collision variant for spatial queries (0x664118).
+/// - `DisplayBitGrid`: display variant for 8bpp pixel rendering (0x664144).
 ///
-/// Base vtable at 0x6640EC (bitfield spatial grid).
-/// Display-layer vtable at 0x664144 (pixel drawing).
-/// Size: 0x2C bytes (base), 0x4C bytes (display layer).
+/// Size: 0x2C bytes (base). Display layers are allocated at 0x4C bytes, with
+/// the extra 0x20 bytes holding layer-specific state beyond this struct.
 #[derive(FieldRegistry)]
 #[repr(C)]
-pub struct BitGrid {
-    pub vtable: u32,
+pub struct BitGrid<V: Vtable = *const BitGridBaseVtable> {
+    /// 0x00: Vtable pointer. Set by `init` to base (0x6640EC),
+    /// then overridden to collision (0x664118) or display (0x664144).
+    pub vtable: V,
     /// 0x04: External buffer flag. 0 = BitGrid owns data (frees on destroy),
     /// nonzero = external ownership.
     pub external_buffer: u32,
-    /// 0x08: Pixel/bit data pointer
+    /// 0x08: Pixel/bit data pointer (row-major, row-aligned to 4 bytes)
     pub data: *mut u8,
-    /// 0x0C: Cells per unit (spatial) / bit depth (display, typically 8)
+    /// 0x0C: Cells per unit — 1 for bit grids, 8 for 8bpp pixel buffers
     pub cells_per_unit: u32,
     /// 0x10: Row stride in bytes
     pub row_stride: u32,
@@ -42,13 +75,13 @@ pub struct BitGrid {
     pub width: u32,
     /// 0x18: Height in pixels/cells
     pub height: u32,
-    /// 0x1C: Clip left / x minimum (display), init 0 (spatial)
+    /// 0x1C: Clip/bounds left (x minimum)
     pub clip_left: u32,
-    /// 0x20: Clip top / y minimum (display), init 0 (spatial)
+    /// 0x20: Clip/bounds top (y minimum)
     pub clip_top: u32,
-    /// 0x24: Clip right / x maximum (display), init = width (spatial)
+    /// 0x24: Clip/bounds right (x maximum)
     pub clip_right: u32,
-    /// 0x28: Clip bottom / y maximum (display), init = height (spatial)
+    /// 0x28: Clip/bounds bottom (y maximum)
     pub clip_bottom: u32,
 }
 
@@ -57,9 +90,11 @@ const _: () = assert!(core::mem::size_of::<BitGrid>() == 0x2C);
 impl BitGrid {
     /// Pure Rust implementation of BitGrid__Init (0x4F6370).
     ///
-    /// Allocates a bit-per-cell grid buffer. `cells_per_unit` is typically 1.
-    /// `width` and `height` are pixel dimensions. The buffer is a row-major
-    /// bitfield with rows aligned to 4 bytes.
+    /// Allocates a row-aligned data buffer and initializes all fields.
+    /// Sets the base vtable (0x6640EC); callers cast and override to specialize.
+    ///
+    /// `cells_per_unit`: 1 for bit grids (collision), 8 for 8bpp pixel buffers.
+    /// `width` and `height`: dimensions in pixels/cells.
     ///
     /// # Safety
     /// `this` must point to a zero-filled allocation of at least 0x2C bytes.
@@ -83,7 +118,7 @@ impl BitGrid {
         // second write is a no-op that modern compilers would eliminate anyway.
         core::ptr::write_bytes(buffer, 0, total_size as usize);
 
-        (*this).vtable = rb(va::BIT_GRID_VTABLE);
+        (*this).vtable = rb(BIT_GRID_BASE_VTABLE) as *const BitGridBaseVtable;
         (*this).external_buffer = 0;
         (*this).data = buffer;
         (*this).cells_per_unit = cells_per_unit;
@@ -97,45 +132,190 @@ impl BitGrid {
     }
 }
 
+// =========================================================================
+// Base variant (vtable 0x6640EC)
+// =========================================================================
+
+/// BitGrid base vtable (0x6640EC, 8 slots).
+///
+/// Bit-level operations. Used as a passive data container (gradient images)
+/// and as the initial vtable set by `BitGrid::init` before callers specialize.
+/// Slots 6-7 are stubs (get/put pixel not supported in base form).
+#[openwa_core::vtable(size = 8, va = 0x0066_40EC, class = "BitGridBase")]
+pub struct BitGridBaseVtable {
+    /// fill rectangle — bit-level fill (0x4F6760, RET 0x14)
+    #[slot(0)]
+    pub fill_rect: fn(this: *mut BitGrid, x1: i32, y1: i32, x2: i32, y2: i32, color: u8),
+    /// fill horizontal line — bit-level, shared with collision (0x4F67B0, RET 0x10)
+    #[slot(1)]
+    pub fill_hline: fn(this: *mut BitGrid, x1: i32, x2: i32, y: i32, color: u8),
+    /// fill vertical line — bit-level, shared with collision (0x4F6860, RET 0x10)
+    #[slot(2)]
+    pub fill_vline: fn(this: *mut BitGrid, x: i32, y1: i32, y2: i32, color: u8),
+    /// destructor — shared across all variants (0x4F5DE0, RET 0x4)
+    #[slot(3)]
+    pub destructor: fn(this: *mut BitGrid, flags: u8) -> *mut BitGrid,
+    /// get bit (clipped) — bit-level read (0x505430, RET 0x8)
+    #[slot(4)]
+    pub get_clipped: fn(this: *mut BitGrid, x: i32, y: i32) -> u8,
+    /// set bit (clipped) — bit-level write (0x482860, RET 0xC)
+    #[slot(5)]
+    pub put_clipped: fn(this: *mut BitGrid, x: i32, y: i32, value: u8),
+    // Slots 6-7: stubs (0x5D4E16) — get/put pixel not supported in base form
+}
+
+bind_BitGridBaseVtable!(BitGrid, vtable);
+
+impl BitGrid {
+    /// Allocate and initialize a base BitGrid on WA's heap.
+    ///
+    /// Used internally by variant `alloc` methods. For external use,
+    /// prefer `CollisionBitGrid::alloc` or `DisplayBitGrid::alloc`.
+    /// Returns null if allocation fails.
+    ///
+    /// # Safety
+    /// Must be called from within the WA.exe process.
+    pub(crate) unsafe fn alloc_base(cells_per_unit: u32, width: u32, height: u32) -> *mut BitGrid {
+        let grid = wa_malloc_struct_zeroed::<BitGrid>();
+        if !grid.is_null() {
+            BitGrid::init(grid, cells_per_unit, width, height);
+        }
+        grid
+    }
+}
+
+// =========================================================================
+// Collision variant (vtable 0x664118)
+// =========================================================================
+
+/// Typed alias for collision BitGrids (vtable 0x664118).
+///
+/// Used at DDGame+0x380 for terrain collision/spatial queries.
+/// Bit-level operations — one bit per cell.
+pub type CollisionBitGrid = BitGrid<*const BitGridCollisionVtable>;
+
+/// BitGrid collision vtable (0x664118, 8 slots).
+///
+/// Bit-level spatial query operations. Shares fill_hline/fill_vline
+/// implementations with the base vtable, but has distinct get/put methods
+/// for bit-level access including unchecked variants.
+#[openwa_core::vtable(size = 8, va = 0x0066_4118, class = "BitGridCollision")]
+pub struct BitGridCollisionVtable {
+    /// fill rectangle — bit-level fill (0x4F8F90, RET 0x14)
+    #[slot(0)]
+    pub fill_rect: fn(this: *mut CollisionBitGrid, x1: i32, y1: i32, x2: i32, y2: i32, color: u8),
+    /// fill horizontal line — bit-level, shared with base (0x4F67B0, RET 0x10)
+    #[slot(1)]
+    pub fill_hline: fn(this: *mut CollisionBitGrid, x1: i32, x2: i32, y: i32, color: u8),
+    /// fill vertical line — bit-level, shared with base (0x4F6860, RET 0x10)
+    #[slot(2)]
+    pub fill_vline: fn(this: *mut CollisionBitGrid, x: i32, y1: i32, y2: i32, color: u8),
+    /// destructor — shared across all variants (0x4F5DE0, RET 0x4)
+    #[slot(3)]
+    pub destructor: fn(this: *mut CollisionBitGrid, flags: u8) -> *mut CollisionBitGrid,
+    /// get bit (clipped) — bit-level read with bounds check (0x4F9020, RET 0x8)
+    #[slot(4)]
+    pub get_clipped: fn(this: *mut CollisionBitGrid, x: i32, y: i32) -> u8,
+    /// set bit (clipped) — bit-level write with bounds check (0x4F9050, RET 0xC)
+    #[slot(5)]
+    pub put_clipped: fn(this: *mut CollisionBitGrid, x: i32, y: i32, value: u8),
+    /// get bit (unchecked) — direct bit read (0x4F5D70, RET 0x8)
+    #[slot(6)]
+    pub get: fn(this: *mut CollisionBitGrid, x: i32, y: i32) -> u8,
+    /// set bit (unchecked) — direct bit write (0x4F5DA0, RET 0xC)
+    #[slot(7)]
+    pub put: fn(this: *mut CollisionBitGrid, x: i32, y: i32, value: u8),
+}
+
+bind_BitGridCollisionVtable!(CollisionBitGrid, vtable);
+
+impl CollisionBitGrid {
+    /// Allocate and initialize a collision BitGrid on WA's heap.
+    ///
+    /// Calls `BitGrid::init` then overrides the vtable to 0x664118.
+    /// Returns null if allocation fails.
+    ///
+    /// # Safety
+    /// Must be called from within the WA.exe process.
+    pub unsafe fn alloc(cells_per_unit: u32, width: u32, height: u32) -> *mut CollisionBitGrid {
+        let grid = BitGrid::alloc_base(cells_per_unit, width, height);
+        if !grid.is_null() {
+            let collision = grid as *mut CollisionBitGrid;
+            (*collision).vtable = rb(BIT_GRID_COLLISION_VTABLE) as *const BitGridCollisionVtable;
+            return collision;
+        }
+        core::ptr::null_mut()
+    }
+}
+
+// =========================================================================
+// Display layer variant (vtable 0x664144)
+// =========================================================================
+
+/// Typed alias for display-layer BitGrids (vtable 0x664144).
+///
+/// Used as rendering layers in DisplayGfx (+0x3D9C, +0x3DA0, +0x3DA4)
+/// and as sprite pixel buffers (Sprite+0x34). Provides typed vtable
+/// access and bind wrappers for 8bpp pixel drawing operations.
+pub type DisplayBitGrid = BitGrid<*const BitGridDisplayVtable>;
+
 /// BitGrid display-layer vtable (0x664144, 8 slots).
 ///
-/// Pixel buffer operations for 8-bit paletted rendering layers.
+/// Byte-level (8bpp) pixel buffer operations for rendering layers.
 /// All pixel addressing uses: `data[y * row_stride + x]`
 ///
 /// DDDisplay creates 3 layer objects in DDDisplay__Init:
 /// - Layer 0 at DisplayGfx+0x3D9C
 /// - Layer 1 at DisplayGfx+0x3DA0
-/// - Layer 2 at DisplayGfx+0x3DA4 (uses BitGrid__Init for extended setup)
+/// - Layer 2 at DisplayGfx+0x3DA4
 #[openwa_core::vtable(size = 8, va = 0x0066_4144, class = "BitGridDisplay")]
 pub struct BitGridDisplayVtable {
     /// fill rectangle — memset rows [y1..y2) from x1 to x2 with color (0x4F9090, RET 0x14)
     #[slot(0)]
-    pub fill_rect: fn(this: *mut BitGrid, x1: i32, y1: i32, x2: i32, y2: i32, color: u8),
+    pub fill_rect: fn(this: *mut DisplayBitGrid, x1: i32, y1: i32, x2: i32, y2: i32, color: u8),
     /// fill horizontal line — memset row y from x1 to x2 with color (0x4F90E0, RET 0x10)
     #[slot(1)]
-    pub fill_hline: fn(this: *mut BitGrid, x1: i32, x2: i32, y: i32, color: u8),
+    pub fill_hline: fn(this: *mut DisplayBitGrid, x1: i32, x2: i32, y: i32, color: u8),
     /// fill vertical line — set pixels in column x from y1 to y2 (0x4F9110, RET 0x10)
     #[slot(2)]
-    pub fill_vline: fn(this: *mut BitGrid, x: i32, y1: i32, y2: i32, color: u8),
-    /// destructor — reverts vtable to 0x6640EC, frees data if owned (0x4F5DE0, RET 0x4)
+    pub fill_vline: fn(this: *mut DisplayBitGrid, x: i32, y1: i32, y2: i32, color: u8),
+    /// destructor — shared across all variants (0x4F5DE0, RET 0x4)
     #[slot(3)]
-    pub destructor: fn(this: *mut BitGrid, flags: u8) -> *mut BitGrid,
-    /// get pixel (clipped) — returns 0 if (x, y) is outside clip rect (0x4F9140, RET 0x8)
+    pub destructor: fn(this: *mut DisplayBitGrid, flags: u8) -> *mut DisplayBitGrid,
+    /// get pixel (clipped) — returns 0 if outside clip rect (0x4F9140, RET 0x8)
     #[slot(4)]
-    pub get_pixel_clipped: fn(this: *mut BitGrid, x: i32, y: i32) -> u8,
-    /// put pixel (clipped) — no-op if (x, y) is outside clip rect (0x4F9180, RET 0xC)
+    pub get_pixel_clipped: fn(this: *mut DisplayBitGrid, x: i32, y: i32) -> u8,
+    /// put pixel (clipped) — no-op if outside clip rect (0x4F9180, RET 0xC)
     ///
     /// This is the main rendering primitive — DDDisplay dispatches drawing
     /// operations through these layer objects.
     #[slot(5)]
-    pub put_pixel_clipped: fn(this: *mut BitGrid, x: i32, y: i32, color: u8),
+    pub put_pixel_clipped: fn(this: *mut DisplayBitGrid, x: i32, y: i32, color: u8),
     /// get pixel (unchecked) — direct read, no bounds checking (0x4F5E20, RET 0x8)
     #[slot(6)]
-    pub get_pixel: fn(this: *mut BitGrid, x: i32, y: i32) -> u8,
+    pub get_pixel: fn(this: *mut DisplayBitGrid, x: i32, y: i32) -> u8,
     /// put pixel (unchecked) — direct write, no bounds checking (0x4F5E40, RET 0xC)
     #[slot(7)]
-    pub put_pixel: fn(this: *mut BitGrid, x: i32, y: i32, color: u8),
+    pub put_pixel: fn(this: *mut DisplayBitGrid, x: i32, y: i32, color: u8),
 }
 
-// Note: no bind macro here because BitGrid.vtable is u32, not a typed pointer.
-// Use vcall! or manual vtable dispatch for calling these methods.
+bind_BitGridDisplayVtable!(DisplayBitGrid, vtable);
+
+impl DisplayBitGrid {
+    /// Allocate and initialize a display BitGrid on WA's heap.
+    ///
+    /// Calls `BitGrid::init` then overrides the vtable to 0x664144.
+    /// Returns null if allocation fails.
+    ///
+    /// # Safety
+    /// Must be called from within the WA.exe process.
+    pub unsafe fn alloc(cells_per_unit: u32, width: u32, height: u32) -> *mut DisplayBitGrid {
+        let grid = BitGrid::alloc_base(cells_per_unit, width, height);
+        if !grid.is_null() {
+            let display = grid as *mut DisplayBitGrid;
+            (*display).vtable = rb(BIT_GRID_DISPLAY_VTABLE) as *const BitGridDisplayVtable;
+            return display;
+        }
+        core::ptr::null_mut()
+    }
+}

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

@@ -1,5 +1,5 @@
 use super::base::DisplayBase;
-use super::bitgrid::BitGrid;
+use super::bitgrid::DisplayBitGrid;
 use core::ffi::c_void;
 
 /// DisplayGfx — full display/graphics subsystem (derived from DisplayBase).
@@ -99,11 +99,11 @@ pub struct DisplayGfx {
     pub render_lock: u32,
     /// 0x3D9C: Layer 0 — BitGrid pixel buffer (0x4C bytes, vtable 0x664144).
     /// Allocated and initialized in DDDisplay__Init.
-    pub layer_0: *mut BitGrid,
+    pub layer_0: *mut DisplayBitGrid,
     /// 0x3DA0: Layer 1 — BitGrid pixel buffer (same type as layer_0)
-    pub layer_1: *mut BitGrid,
+    pub layer_1: *mut DisplayBitGrid,
     /// 0x3DA4: Layer 2 — BitGrid pixel buffer (uses BitGrid__Init for extended setup)
-    pub layer_2: *mut BitGrid,
+    pub layer_2: *mut DisplayBitGrid,
     /// 0x3DA8: BitGrid vtable pointer (0x664144). Set in constructor.
     pub bitgrid_vtable: *const c_void,
     /// 0x3DAC: Layer active flag (init 1)

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

@@ -6,7 +6,7 @@
 //! may have subtle color differences due to the tangled decompiler output.
 
 use crate::address::va;
-use crate::display::bitgrid::BitGrid;
+use crate::display::bitgrid::{BitGrid, BitGridBaseVtable};
 use crate::engine::ddgame::DDGame;
 use crate::rebase::rb;
 use crate::render::gfx_dir::call_gfx_find_and_load;
@@ -248,7 +248,7 @@ pub(crate) unsafe fn compute_complex_gradient(
         return;
     }
     core::ptr::write_bytes(gfx_obj as *mut u8, 0, core::mem::size_of::<BitGrid>());
-    (*gfx_obj).vtable = rb(va::BIT_GRID_VTABLE);
+    (*gfx_obj).vtable = rb(va::BIT_GRID_BASE_VTABLE) as *const BitGridBaseVtable;
     (*gfx_obj).data = data;
     (*gfx_obj).row_stride = stride;
     (*gfx_obj).width = 0;

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

@@ -9,7 +9,10 @@ pub mod opengl;
 pub mod palette;
 
 pub use base::{DisplayBase, DisplayBaseVtable, SpriteBufferCtrl, SpriteCacheWrapper};
-pub use bitgrid::{BitGrid, BitGridDisplayVtable};
+pub use bitgrid::{
+    BitGrid, BitGridBaseVtable, BitGridCollisionVtable, BitGridDisplayVtable, CollisionBitGrid,
+    DisplayBitGrid,
+};
 pub use compat_renderer::CompatRenderer;
 pub use dd_display::DDDisplay;
 pub use display_wrapper::DDDisplayWrapper;

crates/openwa-core/src/engine/ddgame.rs

@@ -4,7 +4,7 @@ use crate::audio::music::Music;
 use crate::audio::speech::SpeechSlotTable;
 use crate::display::dd_display::DDDisplay;
 use crate::display::palette::Palette;
-use crate::display::BitGrid;
+use crate::display::{CollisionBitGrid, DisplayBitGrid};
 use crate::engine::game_info::GameInfo;
 use crate::engine::{
     CoordEntry, CoordList, RenderEntry, SoundQueueEntry, TeamArenaState, TeamIndexMap,
@@ -71,14 +71,15 @@ pub struct DDGame {
     pub arrow_gfxdirs: [*mut u8; 32],
     /// 0x138: Primary display BitGrid (vtable 0x664144, 8bpp pixel buffer).
     /// Allocated as 0x4C bytes, initialized with BitGrid::init(8, 0x100, 0x1E0).
-    pub display_bitgrid: *mut BitGrid,
+    pub display_bitgrid: *mut DisplayBitGrid,
     /// 0x13C-0x37F: Sprite/image BitGrid cache (145 pointer slots).
     /// All populated entries have vtable 0x664144 (same class as `display_bitgrid`).
     /// Not initialized in DDGame__Constructor — filled during gameplay with
     /// weapon sprites, effect images, cursor graphics, etc.
     pub sprite_cache: [*mut u8; 145],
-    /// 0x380: BitGrid pointer (vtable 0x664118, 0x2C bytes)
-    pub bit_grid: *mut BitGrid,
+    /// 0x380: Collision BitGrid pointer (vtable 0x664118, 0x2C bytes).
+    /// Used for terrain collision/spatial queries.
+    pub collision_grid: *mut CollisionBitGrid,
     /// 0x384-0x467: Additional sprite/image object slots.
     /// Same vtable 0x664144 as sprite_cache. ~20 entries populated at runtime.
     pub sprite_cache_2: [*mut u8; 57],

crates/openwa-core/src/engine/ddgame_constructor.rs

@@ -12,7 +12,7 @@ use crate::address::va;
 use crate::audio::active_sound::ActiveSoundTable;
 use crate::audio::dssound::DSSound;
 use crate::audio::music::Music;
-use crate::display::bitgrid::BitGrid;
+use crate::display::bitgrid::{BitGrid, BitGridBaseVtable, CollisionBitGrid, DisplayBitGrid};
 use crate::display::dd_display::DDDisplay;
 use crate::display::gradient::compute_complex_gradient;
 use crate::display::palette::Palette;
@@ -705,18 +705,11 @@ unsafe fn init_graphics_and_resources(
         }
     };
 
-    // ── BitGrid at DDGame+0x380 ──
+    // ── Collision BitGrid at DDGame+0x380 ──
     {
-        use crate::wa_alloc::wa_malloc_struct_zeroed;
-
-        let bit_grid = wa_malloc_struct_zeroed::<BitGrid>();
-        if !bit_grid.is_null() {
-            let width = (*ddgame).level_width;
-            let height = (*ddgame).level_height;
-            BitGrid::init(bit_grid as *mut BitGrid, 1, width, height);
-            (*bit_grid).vtable = rb(va::BIT_GRID_VARIANT_VTABLE);
-        }
-        (*ddgame).bit_grid = bit_grid;
+        let width = (*ddgame).level_width;
+        let height = (*ddgame).level_height;
+        (*ddgame).collision_grid = CollisionBitGrid::alloc(1, width, height);
     }
 
     // ── 8× SpriteRegion at DDGame+0x46C..0x488 ──
@@ -844,16 +837,7 @@ unsafe fn init_graphics_and_resources(
     }
 
     // ── Display BitGrid at DDGame+0x138 ──
-    {
-        use crate::wa_alloc::wa_malloc_struct_zeroed;
-
-        let grid = wa_malloc_struct_zeroed::<BitGrid>();
-        if !grid.is_null() {
-            BitGrid::init(grid, 8, 0x100, 0x1E0);
-            *(grid as *mut u32) = rb(va::BIT_GRID_DISPLAY_VTABLE);
-        }
-        (*ddgame).display_bitgrid = grid as *mut BitGrid;
-    }
+    (*ddgame).display_bitgrid = DisplayBitGrid::alloc(8, 0x100, 0x1E0);
 
     // ── CoordList at DDGame+0x50C (capacity 600, 0x12C0 buffer) ──
     {
@@ -1025,9 +1009,11 @@ unsafe fn init_graphics_and_resources(
     // ── Gradient image stub (DDGame+0x30) ──
     // Minimal stub: [6]=0 (zero-width) so CTaskLand skips the gradient column loop.
     if (*ddgame).gradient_image.is_null() {
-        let obj = wa_malloc_zeroed(core::mem::size_of::<BitGrid>() as u32) as *mut BitGrid;
+        use crate::wa_alloc::wa_malloc_struct_zeroed;
+
+        let obj = wa_malloc_struct_zeroed::<BitGrid>();
         if !obj.is_null() {
-            (*obj).vtable = rb(va::BIT_GRID_VTABLE);
+            (*obj).vtable = rb(va::BIT_GRID_BASE_VTABLE) as *const BitGridBaseVtable;
             // height = 0 → CTaskLand skips the gradient column loop
             (*ddgame).gradient_image = obj as *mut u8;
         }