feat: add live object tracker with field-level pointer identification

Live object tracker in registry.rs enables detect_pointer() to resolve
heap pointers into "DDGame.rng_state" style names:

- register_live_object() / unregister_live_object() for tracking
- identify_live_pointer() checks if a pointer falls inside any tracked
object and resolves the field name via StructFields
- detect_pointer() now checks live objects before vtable fallback

DDGameWrapper, DDGame, and GameSession are registered during
construct_ddgame_wrapper() in the wormkit DLL.

Also fixes proc macro to submit StructRegistration via inventory,
enabling struct_fields_for("DDGame") global lookups.

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

crates/openwa-core/src/mem.rs

@@ -185,7 +185,32 @@ pub unsafe fn detect_pointer(value: u32, delta: u32) -> Option<KnownPointer> {
         }
     }
 
-    // 2. If heap pointer, check if first DWORD is a known vtable
+    // 2. Check if pointer falls inside a tracked live object
+    if let Some(m) = registry::identify_live_pointer(value) {
+        let name = match m.field {
+            Some(field) if m.offset == field.offset => {
+                format!("{}.{}", m.object.class_name, field.name)
+            }
+            Some(field) => {
+                let inner_off = m.offset - field.offset;
+                format!("{}.{}+0x{:X}", m.object.class_name, field.name, inner_off)
+            }
+            None => format!("{}+0x{:X}", m.object.class_name, m.offset),
+        };
+        return Some(KnownPointer {
+            raw_value: value,
+            ghidra_value: ghidra_val,
+            segment: PointerKind::Object,
+            name: Some(name),
+            class_name: Some(m.object.class_name),
+            detail: Some(format!(
+                "base=0x{:08X} offset=0x{:X}",
+                m.object.ptr, m.offset
+            )),
+        });
+    }
+
+    // 3. If heap pointer, check if first DWORD is a known vtable
     if can_read(value, 4) {
         let first = *(value as *const u32);
         let ghidra_first = first.wrapping_sub(delta);
@@ -201,7 +226,7 @@ pub unsafe fn detect_pointer(value: u32, delta: u32) -> Option<KnownPointer> {
         }
     }
 
-    // 3. Fall back to segment-based classification
+    // 4. Fall back to segment-based classification
     classify_pointer(value, delta).map(|info| KnownPointer {
         raw_value: info.raw_value,
         ghidra_value: info.ghidra_value,

crates/openwa-core/src/registry.rs

@@ -277,6 +277,91 @@ pub fn all_struct_fields() -> impl Iterator<Item = &'static StructFields> {
     struct_map().values().copied()
 }
 
+// =========================================================================
+// Live object tracker
+// =========================================================================
+
+/// A tracked live heap object.
+#[derive(Debug, Clone)]
+pub struct LiveObject {
+    /// Runtime base address.
+    pub ptr: u32,
+    /// Object size in bytes (0 if unknown).
+    pub size: u32,
+    /// Class/struct name (e.g., "DDGame").
+    pub class_name: &'static str,
+    /// Field registry for this struct (if available).
+    pub fields: Option<&'static StructFields>,
+}
+
+use std::sync::Mutex;
+
+static LIVE_OBJECTS: Mutex<Vec<LiveObject>> = Mutex::new(Vec::new());
+
+/// Register a live heap object for pointer identification.
+///
+/// Call this from constructor hooks when a game object is allocated.
+pub fn register_live_object(obj: LiveObject) {
+    if let Ok(mut v) = LIVE_OBJECTS.lock() {
+        // Replace if same pointer already tracked (re-allocation)
+        if let Some(existing) = v.iter_mut().find(|o| o.ptr == obj.ptr) {
+            *existing = obj;
+        } else {
+            v.push(obj);
+        }
+    }
+}
+
+/// Unregister a live heap object (e.g., on destruction).
+pub fn unregister_live_object(ptr: u32) {
+    if let Ok(mut v) = LIVE_OBJECTS.lock() {
+        v.retain(|o| o.ptr != ptr);
+    }
+}
+
+/// Result of identifying a pointer as being inside a tracked live object.
+#[derive(Debug)]
+pub struct LiveObjectMatch {
+    pub object: LiveObject,
+    /// Byte offset of the pointer within the object.
+    pub offset: u32,
+    /// Field at this offset (if known).
+    pub field: Option<&'static FieldEntry>,
+}
+
+/// Check if a runtime pointer falls inside any tracked live object.
+///
+/// Returns the matching object and the field at the pointer's offset.
+pub fn identify_live_pointer(runtime_ptr: u32) -> Option<LiveObjectMatch> {
+    let v = LIVE_OBJECTS.lock().ok()?;
+    for obj in v.iter() {
+        let end = if obj.size > 0 {
+            obj.ptr + obj.size
+        } else {
+            // Unknown size — use a generous 256KB bound
+            obj.ptr + 0x40000
+        };
+        if runtime_ptr >= obj.ptr && runtime_ptr < end {
+            let offset = runtime_ptr - obj.ptr;
+            let field = obj.fields.and_then(|f| {
+                f.field_at(offset)
+                    .or_else(|| f.field_containing(offset).map(|(fe, _)| fe))
+            });
+            return Some(LiveObjectMatch {
+                object: obj.clone(),
+                offset,
+                field,
+            });
+        }
+    }
+    None
+}
+
+/// Return a snapshot of all currently tracked live objects.
+pub fn live_objects() -> Vec<LiveObject> {
+    LIVE_OBJECTS.lock().map(|v| v.clone()).unwrap_or_default()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/openwa-wormkit/src/replacements/game_session.rs

@@ -97,6 +97,17 @@ pub(crate) unsafe fn construct_ddgame_wrapper(
     let timer_obj = (*session).timer_obj;
     let net_game = (*session).net_game;
 
+    // Register GameSession as a live object.
+    {
+        use openwa_core::registry::{self, LiveObject};
+        registry::register_live_object(LiveObject {
+            ptr: session as u32,
+            size: 0x120,
+            class_name: "GameSession",
+            fields: registry::struct_fields_for("GameSession"),
+        });
+    }
+
     let _ = log_line(&format!(
         "[GameSession] display=0x{:08X}, net_game=0x{:08X}, timer=0x{:08X}, game_info(EDI)=0x{:08X}",
         display as u32, net_game as u32, timer_obj as u32, game_info as u32,
@@ -147,6 +158,23 @@ pub(crate) unsafe fn construct_ddgame_wrapper(
         this as u32, (*this).ddgame as u32,
     ));
 
+    // Register live objects for pointer identification in debug tools.
+    use openwa_core::registry::{self, LiveObject};
+    registry::register_live_object(LiveObject {
+        ptr: this as u32,
+        size: core::mem::size_of::<DDGameWrapper>() as u32,
+        class_name: "DDGameWrapper",
+        fields: registry::struct_fields_for("DDGameWrapper"),
+    });
+    if !(*this).ddgame.is_null() {
+        registry::register_live_object(LiveObject {
+            ptr: (*this).ddgame as u32,
+            size: 0x98D8, // DDGame size
+            class_name: "DDGame",
+            fields: registry::struct_fields_for("DDGame"),
+        });
+    }
+
     this
 }