feat: add CTaskFire struct and debug inspector support

- address.rs: CTASK_FIRE_VTABLE = 0x00669DD8
- task.rs: CTaskFire (0xD8 bytes, extends CTask) with spawn_x/y, timer,
burn_rate, spread_counter, lifetime, slot_index fields
- app.rs: add CTaskFire to KNOWN_VTABLES; add inspector section showing
key fields (position, timer, burn rate, lifetime, slot)

Vtable labeled in Ghidra: CTaskFire__Init, __Free, __HandleMessage,
__ProcessFrame all renamed.

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

crates/openwa-core/src/address.rs

@@ -73,6 +73,8 @@ pub mod va {
     pub const CTASK_CLOUD_VTABLE: u32 = 0x0066_9D38;
     /// CTaskSeaBubble vtable - water bubble particle (constructor 0x554FE0)
     pub const CTASK_SEA_BUBBLE_VTABLE: u32 = 0x0066_9E88;
+    /// CTaskFire vtable - fire/flame entity (constructor 0x54F4C0, 0xD8 bytes)
+    pub const CTASK_FIRE_VTABLE: u32 = 0x0066_9DD8;
     /// Sprite vtable (0x70-byte objects, 8 entries)
     pub const SPRITE_VTABLE: u32 = 0x0066_418C;
 

crates/openwa-core/src/task.rs

@@ -566,6 +566,51 @@ impl CTaskOilDrum {
     }
 }
 
+/// Fire/flame entity task.
+///
+/// Extends CTask (not CGameTask) — no physics body.
+/// class_type = 0x18. Allocated 0xD8 bytes.
+/// Constructor: CTaskFire__Constructor (0x54F4C0).
+/// vtable: CTaskFire__vtable (0x00669DD8).
+///
+/// One CTaskFire is spawned per flame sprite.  The `timer` field starts
+/// at 0xFFFF and counts down each frame; when it reaches zero the fire
+/// dies.  `lifetime` at +0xB1 is a signed byte: 0xFF (= -1i8) means alive,
+/// 0 means the task is being destroyed.
+#[repr(C)]
+pub struct CTaskFire {
+    /// 0x00-0x2F: CTask base
+    pub base: CTask,
+    /// 0x30: spread counter (incremented while fire is spreading)
+    pub spread_counter: i32,
+    /// 0x34: frame countdown; starts at 0xFFFF, decrements each ProcessFrame
+    pub timer: i32,
+    /// 0x38: random seed / initial offset for sprite variation
+    pub rand_offset: u32,
+    /// 0x3C: burn rate / intensity (higher = more damage per frame)
+    pub burn_rate: u32,
+    pub _unknown_40: u32,
+    /// 0x44: spawn X position (Fixed 16.16)
+    pub spawn_x: crate::fixed::Fixed,
+    /// 0x48: spawn Y position (Fixed 16.16)
+    pub spawn_y: crate::fixed::Fixed,
+    pub _unknown_4c: [u8; 0x24],
+    /// 0x70: absolute tick (frame counter) when this flame was spawned
+    pub spawn_time: u32,
+    pub _unknown_74: u32,
+    /// 0x78-0xA7: per-frame spawn parameter table (12 DWORDs)
+    pub spawn_params: [u32; 12],
+    /// 0xA8: slot index in the fire-object pool
+    pub slot_index: u32,
+    pub _unknown_ac: u32,
+    pub _flags_b0: u8,
+    /// 0xB1: lifetime byte; -1 (0xFF as i8) = alive, 0 = dying/dead
+    pub lifetime: i8,
+    pub _unknown_b2: [u8; 0x26],
+}
+
+const _: () = assert!(core::mem::size_of::<CTaskFire>() == 0xD8);
+
 // ============================================================
 // Derived task overlays — for accessing task-specific fields
 // beyond or within CGameTask that differ per task type.

crates/openwa-debugui/src/app.rs

@@ -3,7 +3,7 @@ use openwa_core::address::va;
 use openwa_core::ddgame::DDGame;
 use openwa_core::ddgame_wrapper::DDGameWrapper;
 use openwa_core::rebase::rb;
-use openwa_core::task::{CTask, CTaskCloud, CTaskMine, CTaskOilDrum, CTaskWorm};
+use openwa_core::task::{CTask, CTaskCloud, CTaskFire, CTaskMine, CTaskOilDrum, CTaskWorm};
 
 use crate::log;
 
@@ -25,6 +25,7 @@ const KNOWN_VTABLES: &[(u32, &str)] = &[
     (va::CTASK_OILDRUM_VTABLE,     "CTaskOilDrum"),
     (va::CTASK_CLOUD_VTABLE,       "CTaskCloud"),
     (va::CTASK_SEA_BUBBLE_VTABLE,  "CTaskSeaBubble"),
+    (va::CTASK_FIRE_VTABLE,        "CTaskFire"),
 ];
 
 /// Vtables of entities that are created/destroyed every frame (particles,
@@ -459,6 +460,24 @@ impl DebugApp {
                     });
             }
 
+            // --- CTaskFire-specific fields ---
+            if name == "CTaskFire" {
+                let fire = addr as *const CTaskFire;
+                egui::CollapsingHeader::new("CTaskFire")
+                    .default_open(true)
+                    .show(ui, |ui| {
+                        egui::Grid::new("fire_grid").striped(true).show(ui, |ui| {
+                            ui.label("spawn_x");       ui.label(format!("{:.1}", (*fire).spawn_x.to_f32()));    ui.end_row();
+                            ui.label("spawn_y");       ui.label(format!("{:.1}", (*fire).spawn_y.to_f32()));    ui.end_row();
+                            ui.label("timer");         ui.label(format!("{}", (*fire).timer));                  ui.end_row();
+                            ui.label("burn_rate");     ui.label(format!("{}", (*fire).burn_rate));              ui.end_row();
+                            ui.label("spread_ctr");    ui.label(format!("{}", (*fire).spread_counter));         ui.end_row();
+                            ui.label("lifetime");      ui.label(format!("{}", (*fire).lifetime));               ui.end_row();
+                            ui.label("slot_index");    ui.label(format!("{}", (*fire).slot_index));             ui.end_row();
+                        });
+                    });
+            }
+
             // --- CTaskWorm-specific fields ---
             if name == "CTaskWorm" || (*task).class_type == openwa_core::class_type::ClassType::Worm {
                 let worm = addr as *const CTaskWorm;