-
Notifications
You must be signed in to change notification settings - Fork 6
Snapshot
⚗ Experimental tab (off by default).
The Snapshot tab captures every numeric UPROPERTY of every (scoped) object into a persisted, on-disk snapshot. You can then diff two snapshots to see what changed, or group-match several values across one snapshot — the classic "which object holds all of these numbers?" hunt, but over a captured corpus instead of live memory. Snapshots also feed the SPC Query and Class Pivot tabs.
Because a snapshot is a full numeric dump, it can be large on a big game — the capture controls below exist to keep that in check.
The Capture snapshot panel (collapsible) holds one row of settings:
| Control | What it does |
|---|---|
| Scope | Which numeric field widths to include. |
| Type | Family narrowing on top of Scope: All numeric, Integers only (Int8/16/32/64 ±, drops floats), or Floats only (Float/Double, drops integers). Lossy by design — re-capture to bring the other family back. Floats ≈ HP/MP/coords; integers ≈ counts/flags/IDs. |
| Game objects only | Skip non-game (engine/transient) objects. |
| Auto detect Engine/System noise |
On by default. Skips pure engine/system classes (UI widgets, textures, sounds, particles/Niagara, anim instances, /Script engine packages) at the source, so capture is faster and the DB smaller. A gameplay guardrail force-keeps any Actor / Pawn / Character / ActorComponent / Controller / PlayerState class — so a player Pawn's X/Y/Z and HP/MP (in components or GAS AttributeSets) are never dropped. Source-level skipping is irreversible (re-capture with it off to bring a class back). Distinct from the post-capture Noise picker. |
| Native-C (raw) |
Opt-in, off by default. Also captures each object's unmanaged holes (non-UPROPERTY raw bytes) as synthetic <raw@0xNN> fields, interpreted via the Guess-What heuristic and normalized to a numeric type. Lets SPC Query / Class Pivot track native values (HP/MP) that reflection can't see. Slower and larger; raw fields join across snapshots by offset. |
| Per-game quota | When a capture exceeds the quota, the oldest snapshots of this game are dropped automatically (after the capture finishes). |
| Max size |
Opt-in in-capture ceiling. When the live DB crosses this, the capture stops early and keeps the partial snapshot (the first-N objects scanned). Unlike the quota — which only evicts whole older snapshots after a capture — this bounds a single oversized capture. Use it (with Estimate size) on large games. Off disables it. |
| Label | Optional name (defaults to a timestamp). |
Two buttons finish the job:
-
Estimate size — a pre-flight check: it walks a small sample of objects with the current options, models the on-disk cost, and extrapolates to the full object count without writing the DB. Gives a
~X GBgo/no-go before you commit to a multi-GB capture. - Capture Snapshot — run the capture. Cancel appears while a capture (or estimate) is running.
The Saved snapshots list shows every capture for this game, with columns Label · Captured (UTC) · Objects · Fields · Est. Size · Scope · UE. A Used: bar shows how much of the quota is consumed. Actions:
- Refresh — reload the list.
- Delete Selected / Delete All — remove snapshots (Delete All truncates + VACUUMs the DB to reclaim disk; irreversible).
-
Open DB folder — reveal this game's
snapshots.<pe_hash>.dbin the file browser.
A Mode toggle switches the lower half between Diff and Group (Multiple Values).
Pick an Old and a New snapshot and Run Diff to list every field whose value changed. The diff is always deep — it includes nested array / struct-array element changes (e.g. SupportActionGauge[3], shown as Array[N]); no Deep toggle is needed here.
Diff joins fields by object identity within a session (the same game launch), so Old and New should be from the same play session.
Narrow the results with the Class / Field / Object / Change (direction) filters, a Filter all box (matches any column), and an Old / New numeric range (Apply range / Reset). Result columns: Δ · Class · Object · Field · Old · New. Each row offers Live (open in Live Walker), 🌍 (Locate in GWorld), ⚙ (Locate in GameEngine), and Addr (copy). Locate works on an in-session diff only.
Find objects that hold all of 2–4 values at distinct numeric offsets across one snapshot — the snapshot equivalent of Value Search's Group Scan.
- Pick the Snapshot to search, then Find (Clear resets).
- + value / − value — add or remove value rows (2 to 4). Each row has a width scope, a predicate, and a value (plus an upper bound to for a Between predicate).
- Compare with (Mode B) — pick an older snapshot to compare against. This enables the relative predicates Changed / Unchanged / Increased / Decreased — e.g. find an object whose Current HP decreased while Max HP stayed unchanged. Leave it empty for absolute single-snapshot matching. (✕ clears it.)
-
Deep (nested containers) — also match values inside nested containers / struct-array elements (e.g.
SaveSlotList[1]…Tunes[2]), folded into the owning object's block. Off = direct fields only (faster, less noise). - Rounding — how a fractional float/double target is reduced before matching.
Results are master-detail: one row per matched object (Class · Object · Matched values); expand a row for the per-slot detail. The object row offers Live (open in Live Walker); Addr · 🌍 · ⚙ sit on the expanded per-slot detail rows.
Groups often need Unchanged. The classic "current HP went down, max HP didn't" pattern only isolates the right object when one slot is Decreased and another is Unchanged — so pick a Compare with snapshot and use the relative predicates.
Below the Diff results is a Noise picker (the same shape as the SPC Query tab), shown in Diff mode only (it's hidden while Group mode is active): it filters the finished snapshot after capture (in contrast to Auto detect Engine/System noise, which skips at the source). Apply pushes the selected classes to the denylist.
- SPC Query — query values across N snapshots (the multi-snapshot successor to Diff).
- Class Pivot — pivot a class's fields across snapshots to find its stat layout.
- Value Search — the live-memory equivalent of Group mode.
- Detect Stats — uses a snapshot's "value went down" signal to score stat candidates.
- Live Walker — where Live / 🌍 / ⚙ land.