feat: add CTaskMissile struct, CTaskBfsIter, and missile memory dump

- CTaskMissile (0x41C bytes): fully decompiled constructor layout with
spawn_params (11 DWORDs), weapon_data (94 DWORDs), render_data (42 DWORDs).
render_data is a shifted copy of weapon_data (weapon_data[N+3] for single
shots, weapon_data[N+52] for cluster sub-pellets) — likely for frame
interpolation support in the Steam version.
- MissileType enum: Standard=2, Homing=3, Sheep=4, Cluster=5 (confirmed via
constructor switch analysis).
- CTaskBfsIter: general-purpose BFS tree walker over CTask children using
VecDeque. Replaces inline fixed-size queue arrays in validation code.
- dump_missile_tasks(): uses CTaskBfsIter, routes raw DWORD dump to
OpenWA_validation.log (not OpenWA.log).
- Validation log now cleared unconditionally on DLL load (not just when
OPENWA_VALIDATE=1).

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

crates/openwa-core/src/task/base.rs

@@ -150,6 +150,63 @@ impl SharedDataTable {
     }
 }
 
+/// Breadth-first iterator over the CTask tree.
+///
+/// Visits every node reachable from `root` by following `children_data`
+/// arrays. Null slots in the sparse children array are skipped automatically.
+///
+/// Yields raw `*const CTask` pointers. The caller is responsible for casting
+/// to the correct derived type (e.g., by checking the vtable pointer at `[0]`).
+///
+/// # Example
+/// ```ignore
+/// let iter = unsafe { CTaskBfsIter::new(root_ptr) };
+/// for task in iter {
+///     if unsafe { *(task as *const u32) } == rb(va::CTASK_MISSILE_VTABLE) {
+///         let m = unsafe { &*(task as *const CTaskMissile) };
+///         // ...
+///     }
+/// }
+/// ```
+pub struct CTaskBfsIter {
+    queue: std::collections::VecDeque<*const CTask>,
+}
+
+impl CTaskBfsIter {
+    /// Create a new BFS iterator rooted at `root`.
+    ///
+    /// # Safety
+    /// `root` must be a valid, aligned `*const CTask`. All reachable
+    /// `children_data` entries must be either null or valid `*const CTask`.
+    pub unsafe fn new(root: *const CTask) -> Self {
+        let mut queue = std::collections::VecDeque::new();
+        queue.push_back(root);
+        Self { queue }
+    }
+}
+
+impl Iterator for CTaskBfsIter {
+    type Item = *const CTask;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // SAFETY: caller of CTaskBfsIter::new() guarantees node validity.
+        unsafe {
+            let node = self.queue.pop_front()?;
+            let watermark = (*node).children_watermark as usize;
+            let data = (*node).children_data as *const u32;
+            if !data.is_null() {
+                for i in 0..watermark {
+                    let child_ptr = *data.add(i);
+                    if child_ptr != 0 {
+                        self.queue.push_back(child_ptr as *const CTask);
+                    }
+                }
+            }
+            Some(node)
+        }
+    }
+}
+
 /// Iterator over all [`SharedDataNode`]s in a [`SharedDataTable`].
 ///
 /// Created by [`SharedDataTable::iter`]. Walks all 256 buckets in order,

crates/openwa-core/src/task/missile.rs

@@ -0,0 +1,189 @@
+use crate::fixed::Fixed;
+use super::game_task::CGameTask;
+
+/// Projectile / missile entity task.
+///
+/// Extends CGameTask (0xFC bytes). One instance per airborne projectile
+/// (rockets, grenades, mortar shells, homing missiles, sheep, etc.).
+///
+/// Inheritance: CTask → CGameTask → CTaskMissile. class_type = 0x0B (11).
+/// Constructor: `CTaskMissile__Constructor` (0x507D10, stdcall, 4 params).
+/// Vtable: `CTaskMissile__vtable` (0x00664438).
+///
+/// Constructor params:
+///   param_1 = this
+///   param_2 = parent task pointer (passed to CGameTask ctor)
+///   param_3 = scheme weapon data (94 DWORDs from WGT blob)
+///   param_4 = spawn data (11 DWORDs: position, velocity, owner, pellet index)
+///
+/// Source: Ghidra decompilation of 0x507D10 (constructor) and
+///         wkJellyWorm CTaskMissile.h (field layout reference).
+#[repr(C)]
+pub struct CTaskMissile {
+    /// 0x00–0xFB: CGameTask base (pos at 0x84/0x88, speed at 0x90/0x94).
+    pub base: CGameTask,
+
+    // ---- 0xFC–0x12F: missile init fields ----
+
+    /// 0xFC–0x10F: Unknown missile flags and state
+    pub _unknown_fc: [u8; 0x14],
+    /// 0x110: Unknown
+    pub _unknown_110: u32,
+    /// 0x114: Unknown
+    pub _unknown_114: u32,
+    /// 0x118: Unknown — observed being set from scheme data at construction
+    pub _unknown_118: u32,
+    /// 0x11C: Unknown
+    pub _unknown_11c: u32,
+    /// 0x120: Unknown
+    pub _unknown_120: u32,
+    /// 0x124: Unknown
+    pub _unknown_124: u32,
+    /// 0x128: Position-derived launch seed. Computed by constructor as:
+    /// `((spawn_x + spawn_y) / 256 / 20) + 0x10000`. param_1[0x4A].
+    pub launch_seed: u32,
+    /// 0x12C: Object pool slot index (assigned from DDGame+0x3600 pool).
+    /// param_1[0x4B].
+    pub slot_id: u32,
+
+    // ---- 0x130–0x15B: spawn data (11 DWORDs, from param_4) ----
+
+    /// 0x130–0x15B: Spawn parameters (11 DWORDs copied from param_4).
+    ///
+    /// Runtime-confirmed indices:
+    ///   [0x00] owner_id         — team index that fired this missile
+    ///   [0x01] unknown (= 1 observed)
+    ///   [0x02] spawn_x          — Fixed16.16 X at launch
+    ///   [0x03] spawn_y          — Fixed16.16 Y at launch
+    ///   [0x04] initial_speed_x  — Fixed16.16 horizontal velocity (→ CGameTask.speed_x)
+    ///   [0x05] initial_speed_y  — Fixed16.16 vertical velocity (→ CGameTask.speed_y)
+    ///   [0x06] cursor_x         — Fixed16.16 aim cursor X (observed = level_width/2)
+    ///   [0x07] cursor_y         — Fixed16.16 aim cursor Y (observed = level_height/2)
+    ///   [0x08] pellet_index     — index within a cluster volley (0 for single shot)
+    ///   [0x09] fallback_timer   — copied to render_data[0x19] only if it was zero
+    ///   [0x0A] fallback_param   — copied to render_data[0x11] only if it was zero
+    pub spawn_params: [u32; 0x0B],
+
+    // ---- 0x15C–0x2D3: weapon/scheme data (94 DWORDs, from param_3) ----
+
+    /// 0x15C–0x2D3: Weapon/scheme properties (94 DWORDs copied verbatim from param_3).
+    ///
+    /// The WGT scheme blob is split into two logical halves:
+    ///   [0x00..0x34] primary projectile params (→ also mirrored in render_data)
+    ///   [0x34..0x5E] cluster sub-pellet params (→ render_data when pellet_index > 0)
+    ///
+    /// Runtime-observed for bazooka:
+    ///   [0x03] = 137342 → Fixed16.16 ≈ 2.10 (some radius/size)
+    ///   [0x05] = 100, [0x06] = 50, [0x09] = 48
+    ///   [0x0F] gravity_pct  — 100 → gravity_factor = 1.0  (→ CGameTask+0x58 via render_data)
+    ///   [0x10] bounce_pct   — 100 → bounce_factor  = 1.0  (→ CGameTask+0x5C via render_data)
+    ///   [0x12] friction_pct — 100 → friction_factor = 1.0 (→ CGameTask+0x60 via render_data)
+    ///   [0x14] = 9000
+    ///   [0x1A] missile_type — discriminator (2=Standard, 3=Homing, 4=Sheep, 5=Cluster)
+    ///   [0x1B] = 4194304 → Fixed16.16 = 64.0
+    ///   [0x1C] render_timer — 1 for bazooka, 30 for grenade (3s fuse @ 10fps)
+    pub weapon_data: [u32; 0x5E],
+
+    // ---- 0x2D4–0x37B: render/physics parameters (42 DWORDs) ----
+
+    /// 0x2D4–0x37B: Per-projectile render and physics parameters (42 DWORDs).
+    ///
+    /// This is NOT a separate data block — it is a shifted copy of weapon_data:
+    ///   if spawn_params[8] == 0 (single shot):   render_data[N] = weapon_data[N+3]
+    ///   if spawn_params[8]  > 0 (cluster pellet): render_data[N] = weapon_data[N+52]
+    ///
+    /// The constructor copies 42 DWORDs from the appropriate source range
+    /// into this region (param_1[0xB5..0xDE]). Dynamic physics values update
+    /// some entries during flight (e.g. render_data[0x29] @ 0x37C).
+    ///
+    /// Key indices (relative to render_data, = weapon_data[N+3] for single shots):
+    ///   [0x0C] gravity_pct  → (value << 16) / 100 → CGameTask+0x58 (gravity_factor)
+    ///   [0x0D] bounce_pct   → (value << 16) / 100 → CGameTask+0x5C (bounce_factor)
+    ///   [0x0F] friction_pct → (value << 16) / 100 → CGameTask+0x60 (friction_factor)
+    ///   [0x11] = 9000 for bazooka (→ also copied to post-render field at 0x37C)
+    ///   [0x17] missile_type — type discriminator (see MissileType)
+    ///   [0x18] = 4194304 → Fixed16.16 = 64.0 (sprite/render size)
+    ///   [0x19] render_timer — 1 for bazooka, 30 for grenade (3s fuse timer)
+    pub render_data: [u32; 0x2A],
+
+    // ---- 0x37C–0x41B: post-render physics and state ----
+
+    /// 0x37C–0x39F: Post-render dynamic state. render_data[0x11] is copied to
+    /// [0x37C] by the constructor; physics updates the values each frame.
+    pub _unknown_37c: [u8; 0x24],
+    /// 0x3A0: Fixed16.16 launch speed magnitude (computed from initial velocity).
+    /// Observed as 0 for bazooka — may only be populated for specific types.
+    pub launch_speed_raw: Fixed,
+    /// 0x3A4: Unknown
+    pub _unknown_3a4: u32,
+    /// 0x3A8: Homing mode enabled flag (nonzero = active homing).
+    /// param_1[0xEA] in constructor. Set to 1 when missile_type == 3 and conditions
+    /// are met (target acquired).
+    pub homing_enabled: u32,
+    /// 0x3AC–0x3BF: Unknown homing state fields
+    pub _unknown_3ac: [u8; 0x14],
+    /// 0x3C0–0x3C7: Unknown
+    pub _unknown_3c0: [u8; 8],
+    /// 0x3C8: Horizontal direction sign (+1 or -1, determines facing/travel dir).
+    /// param_1[0xF2] in constructor. Set to -1 for homing/sheep if initial_speed_x < 0.
+    pub direction: i32,
+    /// 0x3CC–0x41B: Unknown trailing state
+    pub _unknown_3cc: [u8; 0x50],
+}
+
+const _: () = assert!(core::mem::size_of::<CTaskMissile>() == 0x41C);
+
+impl CTaskMissile {
+    /// Missile type from `render_data[0x17]` (= weapon_data[0x1A] for single shots).
+    ///
+    /// Governs constructor and movement behaviour (homing, sheep walk,
+    /// cluster splitting, etc.).
+    pub fn missile_type(&self) -> MissileType {
+        match self.render_data[0x17] {
+            2 => MissileType::Standard,
+            3 => MissileType::Homing,
+            4 => MissileType::Sheep,
+            5 => MissileType::Cluster,
+            n => MissileType::Unknown(n),
+        }
+    }
+
+    /// Spawn X as Fixed16.16 (from spawn_params[2]).
+    pub fn spawn_x(&self) -> Fixed {
+        Fixed(self.spawn_params[2] as i32)
+    }
+
+    /// Spawn Y as Fixed16.16 (from spawn_params[3]).
+    pub fn spawn_y(&self) -> Fixed {
+        Fixed(self.spawn_params[3] as i32)
+    }
+
+    /// Aim cursor X at time of fire, Fixed16.16 (from spawn_params[6]).
+    pub fn cursor_x(&self) -> Fixed {
+        Fixed(self.spawn_params[6] as i32)
+    }
+
+    /// Aim cursor Y at time of fire, Fixed16.16 (from spawn_params[7]).
+    pub fn cursor_y(&self) -> Fixed {
+        Fixed(self.spawn_params[7] as i32)
+    }
+}
+
+/// Missile movement/behaviour type, encoded in `render_data[0x17]`.
+///
+/// The constructor switches on this value to set up physics, homing,
+/// direction, and clustering behaviour. Corresponds to weapon_data[0x1A]
+/// for single-shot projectiles.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MissileType {
+    /// Standard trajectory projectile (bazooka, mortar, grenade, etc.). Value = 2.
+    Standard,
+    /// Homing missile — tracks nearest worm. Value = 3.
+    Homing,
+    /// Sheep / animal projectile — walks on terrain. Value = 4.
+    Sheep,
+    /// Cluster projectile — spawns sub-pellets on detonation. Value = 5.
+    Cluster,
+    /// Unknown type code (value 1 never observed; any other unrecognised value).
+    Unknown(u32),
+}

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

@@ -4,17 +4,19 @@ mod filter;
 mod fire;
 mod game_task;
 mod mine_oil_drum;
+mod missile;
 mod overlays;
 mod team;
 mod turn_game;
 mod worm;
 
-pub use base::{CTask, SharedDataIter, SharedDataNode, SharedDataTable};
+pub use base::{CTask, CTaskBfsIter, SharedDataIter, SharedDataNode, SharedDataTable};
 pub use cloud::CTaskCloud;
 pub use filter::CTaskFilter;
 pub use fire::CTaskFire;
 pub use game_task::{CGameTask, SoundEmitter, SoundEmitterVTable};
 pub use mine_oil_drum::{CTaskMine, CTaskOilDrum};
+pub use missile::{CTaskMissile, MissileType};
 pub use overlays::{BungeeTrailTask, WeaponAimTask};
 pub use team::CTaskTeam;
 pub use turn_game::{CTaskTurnGame, TurnGameCtx};

crates/openwa-wormkit/src/lib.rs

@@ -54,6 +54,7 @@ fn clear_log() -> std::io::Result<()> {
 
 fn run() -> Result<(), String> {
     let _ = clear_log();
+    let _ = std::fs::write("OpenWA_validation.log", "");
 
     let delta = openwa_core::rebase::init();
     let _ = log_line(&format!(

crates/openwa-wormkit/src/validation/mod.rs

@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicU32, Ordering};
 
 use openwa_core::rebase::rb;
 use openwa_core::address::va;
-use openwa_core::task::{CTask, CGameTask, CTaskTeam, CTaskTurnGame, TurnGameCtx, SharedDataTable};
+use openwa_core::task::{CTask, CTaskBfsIter, CGameTask, CTaskMissile, MissileType, CTaskTeam, CTaskTurnGame, TurnGameCtx, SharedDataTable};
 use openwa_core::ddgame::DDGame;
 use openwa_core::ddgame_wrapper::DDGameWrapper;
 
@@ -318,6 +318,17 @@ fn validate_struct_offsets(result: &mut ValidationResult) {
     check_offset!(result, TurnGameCtx, _hud_textbox_a, 0xA4);
     check_offset!(result, TurnGameCtx, _hud_textbox_b, 0xA8);
 
+    let _ = log_validation("");
+    let _ = log_validation("  CTaskMissile:");
+    check_offset!(result, CTaskMissile, base,            0x00);
+    check_offset!(result, CTaskMissile, slot_id,         0x12C);
+    check_offset!(result, CTaskMissile, spawn_params,    0x130);
+    check_offset!(result, CTaskMissile, weapon_data,     0x15C);
+    check_offset!(result, CTaskMissile, render_data,     0x2D4);
+    check_offset!(result, CTaskMissile, launch_speed_raw, 0x3A0);
+    check_offset!(result, CTaskMissile, homing_enabled,  0x3A8);
+    check_offset!(result, CTaskMissile, direction,       0x3C8);
+
     let _ = log_validation("  CTaskTurnGame:");
     check_offset!(result, CTaskTurnGame, game_ctx,         0x30);
     check_offset!(result, CTaskTurnGame, worm_active,        0x108);
@@ -1190,6 +1201,127 @@ fn dump_ctaskteam_entities() {
     }
 }
 
+// ---------------------------------------------------------------------------
+// CTaskMissile live dump
+// ---------------------------------------------------------------------------
+//
+// CTaskMissile is NOT registered in the SharedData entity table — it is a
+// transient child of a CTaskFilter node. We walk the full task tree from the
+// root (CTaskTurnGame) up to 4 levels deep, checking every child's vtable.
+// Fire a weapon, then press F8.
+
+/// Hex dump of one CTaskMissile to the validation log.
+/// Each non-zero DWORD is printed as: +0xOFFSET: 0xVALUE
+/// Sections are labelled so the output can be cross-referenced with the struct.
+unsafe fn dump_missile_raw(ptr: u32) {
+    let base = ptr as *const u32;
+    let sections: &[(usize, usize, &str)] = &[
+        (0x000, 0x030, "CTask base"),
+        (0x030, 0x084, "CGameTask _unknown_30"),
+        (0x084, 0x098, "CGameTask pos/speed (0x84–0x97)"),
+        (0x098, 0x0FC, "CGameTask _unknown_98"),
+        (0x0FC, 0x130, "CTaskMissile 0xFC–0x12F"),
+        (0x130, 0x15C, "spawn_params"),
+        (0x15C, 0x2D4, "weapon_data"),
+        (0x2D4, 0x37C, "render_data"),
+        (0x37C, 0x41C, "_unknown_37c / launch_speed / homing / direction"),
+    ];
+    for &(start, end, label) in sections {
+        let _ = log_validation(&format!("  -- {} (0x{:03X}..0x{:03X}) --", label, start, end));
+        let dwords = (end - start) / 4;
+        for i in 0..dwords {
+            let off = start + i * 4;
+            let val = *base.add(off / 4);
+            if val != 0 {
+                let _ = log_validation(&format!("    +0x{:03X}: 0x{:08X}  ({})", off, val, val));
+            }
+        }
+    }
+}
+
+fn dump_missile_tasks() {
+    let _ = log_validation("");
+    let _ = log_validation("--- CTaskMissile Entity Dump ---");
+
+    unsafe {
+        let session_ptr = read_u32(rb(va::G_GAME_SESSION));
+        if session_ptr == 0 { let _ = log_validation("  No game session — skipping."); return; }
+        let wrapper_addr = read_u32(session_ptr + 0xA0);
+        if wrapper_addr == 0 { let _ = log_validation("  No DDGameWrapper."); return; }
+        let ddgame_ptr = read_u32(wrapper_addr + 0x488);
+        if ddgame_ptr == 0 { let _ = log_validation("  No DDGame."); return; }
+
+        // Walk up from CTaskLand to root (CTaskTurnGame) via parent links.
+        let task_land_ptr = read_u32(ddgame_ptr + 0x54C);
+        if task_land_ptr == 0 { let _ = log_validation("  CTaskLand NULL — game not loaded."); return; }
+        let mut root = task_land_ptr;
+        for _ in 0..10 {
+            let parent = read_u32(root + 0x04);
+            if parent == 0 { break; }
+            root = parent;
+        }
+
+        let expected_vt = rb(va::CTASK_MISSILE_VTABLE);
+        let _ = log_validation(&format!("  Root (CTaskTurnGame) @ 0x{:08X}", root));
+        let _ = log_validation(&format!("  Expected CTaskMissile vtable: 0x{:08X}", expected_vt));
+
+        let mut found = 0u32;
+        let mut first_ptr: u32 = 0;
+        let mut scanned = 0usize;
+
+        for task_ptr in CTaskBfsIter::new(root as *const CTask) {
+            let node = task_ptr as u32;
+            scanned += 1;
+
+            let vt = read_u32(node);
+            if vt == expected_vt {
+                found += 1;
+                if first_ptr == 0 { first_ptr = node; }
+
+                let m = &*(node as *const CTaskMissile);
+                let pos_x = m.base.pos_x.to_f32();
+                let pos_y = m.base.pos_y.to_f32();
+                let spd_x = m.base.speed_x.to_f32();
+                let spd_y = m.base.speed_y.to_f32();
+                let _ = log_validation(&format!(
+                    "  missile#{} @ 0x{:08X}  slot={}  type={:?}  homing={}  dir={}",
+                    found, node, m.slot_id, m.missile_type(), m.homing_enabled, m.direction
+                ));
+                let _ = log_validation(&format!(
+                    "    pos=({:.2},{:.2})  speed=({:.3},{:.3})  cursor=({:.1},{:.1})",
+                    pos_x, pos_y, spd_x, spd_y,
+                    m.cursor_x().to_f32(), m.cursor_y().to_f32()
+                ));
+                let _ = log_validation(&format!(
+                    "    spawn_params: owner={} pellet={}  spawn=({:.1},{:.1})",
+                    m.spawn_params[0], m.spawn_params[8],
+                    m.spawn_x().to_f32(), m.spawn_y().to_f32()
+                ));
+                let _ = log_validation(&format!(
+                    "    weapon_data[0..10]: {:?}",
+                    &m.weapon_data[..10]
+                ));
+                let _ = log_validation(&format!(
+                    "    render_data[0x15..0x1A]: {:?}  (timer={})",
+                    &m.render_data[0x15..0x1A],
+                    m.render_data[0x19]
+                ));
+            }
+        }
+
+        let _ = log_validation(&format!("  Total CTaskMissile found: {} (scanned {} nodes)", found, scanned));
+
+        if found == 0 {
+            let _ = log_validation("  No missiles in flight — fire a weapon first, then press F8.");
+            return;
+        }
+
+        // Full raw dump of the first missile to cross-validate struct layout.
+        let _ = log_validation(&format!("\n  === Raw dump: CTaskMissile @ 0x{:08X} ===", first_ptr));
+        dump_missile_raw(first_ptr);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Public entry point — called from wormkit's run()
 // ---------------------------------------------------------------------------
@@ -1262,6 +1394,8 @@ pub fn run() -> Result<(), String> {
             dump_ctaskteam_entities();
             let _ = log_validation("  Running CTask children sub-struct dump (5s mark)...");
             dump_ctask_children();
+            let _ = log_validation("  Running CTaskMissile dump (5s mark)...");
+            dump_missile_tasks();
 
             // Wait briefly for replay to start, then dump game state
             // (fast-forward finishes the replay in ~10-15s total, so dump early)
@@ -1305,7 +1439,9 @@ pub fn run() -> Result<(), String> {
     Ok(())
 }
 
-/// Start the debug hotkey listener thread (F9=team blocks, F10=landscape).
+/// Start the debug hotkey listener thread.
+///
+/// F8 = CTaskMissile dump (fire a weapon first, then press F8 while missile is in flight).
 ///
 /// Always available regardless of `OPENWA_VALIDATE`. Skipped in replay-test
 /// mode since auto-capture handles dumps automatically.
@@ -1316,20 +1452,12 @@ pub fn start_hotkeys() {
 
     std::thread::spawn(|| {
         use windows_sys::Win32::UI::Input::KeyboardAndMouse::GetAsyncKeyState;
-        const VK_F8: i32  = 0x77;
-        const VK_F9: i32  = 0x78;
-        const VK_F10: i32 = 0x79;
-        const VK_F11: i32 = 0x7A;
-        const VK_F12: i32 = 0x7B;
-        let _ = log_validation("  Hotkeys: F8=ctask children, F9=team blocks, F10=landscape, F11=worm tasks, F12=entity census");
+        const VK_F8: i32 = 0x77;
+        let _ = log_validation("  Hotkeys: F8=missile dump (fire weapon, then press F8 while missile is in flight)");
         loop {
             std::thread::sleep(std::time::Duration::from_millis(100));
             unsafe {
-                if GetAsyncKeyState(VK_F8)  & 1 != 0 { dump_ctask_children(); }
-                if GetAsyncKeyState(VK_F9)  & 1 != 0 { dump_team_blocks(); }
-                if GetAsyncKeyState(VK_F10) & 1 != 0 { dump_landscape(); }
-                if GetAsyncKeyState(VK_F11) & 1 != 0 { dump_worm_tasks(); }
-                if GetAsyncKeyState(VK_F12) & 1 != 0 { dump_entity_census(); }
+                if GetAsyncKeyState(VK_F8) & 1 != 0 { dump_missile_tasks(); }
             }
         }
     });