-
Notifications
You must be signed in to change notification settings - Fork 6
Options and CE Export Options
UE5CEDumper has two separate groups of settings that shape what it reads and how it writes Cheat Engine data. They live in two different menus and are easy to confuse, so this page documents each one item by item.
| Menu | Where | What it controls |
|---|---|---|
| ⚙ Options (top toolbar) | The top window toolbar, next to the Address: selector — visible from every tab | Global read/display/export shape limits (array/preview caps, drill depth, CE string length, locate depth). Set once per session. |
| Options (Live Walker) | Inside the Live Walker tab's toolbar, appears once a walk has data | Per-export CE memory-record shaping for Copy CE XML and Copy CE Field (description format, chain folding, struct flattening, dedup, etc.) — this is the panel commonly called the CE Export Options. |
Both menus persist across restarts (stored in %LOCALAPPDATA%\UE5CEDumper\ui-options.json), with two exceptions noted below (AOB and Guess? are per-session).
Click ⚙ Options on the top toolbar to open the flyout. These are tuned once per export session, not flipped frequently, which is why they are collapsed behind one button. Each slider's live value is shown next to its label.
Immediately left of the ⚙ Options button is the Address: dropdown — it isn't part of the flyout but governs how every address is displayed and copied. It offers three formats:
-
Hex (no prefix) — the raw runtime address, e.g.
7FF71B7A1820. -
Hex (0x prefix) — the same address with a leading
0x, e.g.0x7FF71B7A1820. -
Module+Offset —
"module.exe"+RVA(the offset from the module base, no0xprefix), which stays valid across game restarts (the module base moves, the offset doesn't).
Checkbox. When on, pointer-chain group nodes in CE XML export are marked so Cheat Engine collapses (hides) their children by default, keeping the pasted address tree tidy. It only affects the exported XML — it does not change how you drill inside Live Walker itself.
Slider, 2^N (range 2 – 16384, default 128 = 2^7). The maximum number of elements read inline when previewing a TArray / container. Larger arrays are still listed, but only this many elements are pulled into memory at once. A ⚠ High memory usage — may cause crash warning appears at high values — raise it only when you truly need to see deep into a huge array.
Slider, 2^N (range 64 – 8192, default 512 = 2^9). The maximum number of entries emitted into a Cheat Engine DropDownList (the enum/value picker CE shows on a record). Caps how large an enumerated dropdown a single exported record may carry.
Slider, 2^N (range 16 – 4096, default 256 = 2^8). The display length, in characters, of a CE String field produced by Copy CE XML / Copy CE Field. A generous value never truncates a shorter live string (Cheat Engine stops at the null terminator) — it simply reserves room for strings that grow longer between saves.
Slider, 2^N (0 = Off, otherwise 2 – 4096). Copy CE Field only. When set, the selected top-level TArray is padded to this many element rows — null pointers and indices beyond the array's live Num are fabricated from a resolved element's field layout, so the CE table already has slots for items a later save or game version will hold. Notes:
- Only the selected array is padded, never nested arrays inside its elements.
-
TArrayonly —TMap/TSetare sparse and are never fabricated. - Rows past the current
Numread past-the-end memory (harmless) until the game grows the array. - Values above 256 are "use at your own risk" — they can produce very large tables that slow Cheat Engine or hit the export entry cap.
Slider (range 0 – 6, default 2). How many of a struct's sub-fields are shown inline in the Value column of the field grid. 0 disables the preview. Purely a display convenience — it does not change what gets exported.
Slider (range 0 – 8, default 0). Pointer drill-down depth for CSX export and Copy CE XML / Copy CE Field: at each level, every object-pointer field fans out into its own sub-tree.
- 0 = flat (no drilling).
- 1 – 4 = normal.
-
5 – 6 = deep — output size grows exponentially per level (depth 6 on a
UWorldcan produce multi-MB CE XML). The slider value turns amber/red at high depth to flag the size impact.
Slider (range 1 – 32, default 7), with a Deep (nested containers) checkbox below it. Controls the Locate in GWorld / Locate in GameEngine forward search (see the Live Walker page):
- Depth — the maximum number of pointer hops the breadth-first search follows downward from GWorld. Larger finds deeper targets but is slower.
-
Deep (nested containers) — off by default. When on, the search also follows object pointers stored inside one level of struct-array / struct-set / struct-map elements (e.g. an actor referenced only from
Inventory[3].ItemActor), so otherwise-unreachable objects can still be located. Heavier, because it reads each struct-array's elements at every visited node.
These stay editable even while disconnected, so you can dial them in before running a locate.
Slider, 2^N (range 16 – 4096, default 256). The per-container element probe cap for the Instances tab's Lookup deep scan — the recursive descent that finds a value buried in nested containers (e.g. SaveSlotList[1]…Tunes[N]). It only runs when the fast shallow lookup finds nothing. Higher reaches values at higher element indices but is slower.
Inside the Live Walker tab, once a walk has loaded data, an Options dropdown appears in the panel toolbar (its tooltip calls it the Copy CE XML / Copy CE Field options). Everything here changes how the fields you export become Cheat Engine memory records — it does not change what you see while browsing.
Unless noted, each item applies to Copy CE XML and Copy CE Field.
Appends each node's field offset (hex) to its CE Description — e.g. AbilitySystemComponent (7E0). Helps you orient in the CE address tree. Off = name only.
Appends each node's class / struct / element type to its CE Description — e.g. AbilitySystemComponent (LSAbilitySystemComponent) or [0] (ShieldAttributeSet). The folded (Collapse chain) spine never adds a type. Off = name only.
(A separator divides the two Description options above from the structural options below.)
Use the AOB-scanned GWorld symbol to anchor the export's root address instead of a hardcoded absolute value, so the export survives game restarts. Only selectable when the walk root is GWorld and an AOB symbol is available — otherwise the item is grayed out. (Session-only — not persisted across restarts.)
Fold the multi-level GWorld → … → target pointer hops into a single CE multi-level-pointer entry (base + one merged spine node + the target field with its drill-down). Produces flatter, more readable CE structures. Copy CE XML / Copy CE Field only.
For a GAS GameplayAttributeData struct (HealthPoint, Mana, …), which normally exports as a parent node with BaseValue / CurrentValue children: promote those children to sibling leaves named e.g. HealthPoint ▸ BaseValue at the combined offset — fewer nodes, easier to read and edit in CE. Scoped to GameplayAttributeData structs only; other structs keep their nested group. The ▸ segments honour Append +Offset; the struct type (Append +Type) is shown once at the end.
A superset of Flatten GAS attributes. Flattens any terminal struct whose whole contents are primitive inline values (int / float / bool / enum) — e.g. a Vector (X/Y/Z), a Rotator, or a plain {Min, Max} pair — into Struct ▸ Field sibling leaves at the combined offset. A struct that contains a pointer/object, a string (FString / FName / FText), or a container keeps its nested group (pointer-backed values are never flattened).
A superset of Flatten primitive-leaf structs. In addition to primitive scalars, it also accepts FName and FString (FString / FUtf8String / FAnsiString) fields as leaves — so a save-data record like {Score, Time, Rank, MsID (FName), PilotName (FString)} has every field promoted to a Struct ▸ Field sibling leaf, including records stored inside a TMap / TArray (the per-element groups collapse to flat rows). An FName renders as its 4-byte index; an FString renders as a CE String (one Data-pointer deref). A struct that still contains a pointer/object, an FText, a container, or an unresolved nested struct keeps its nested group.
Opens the Record Colors editor. When a TMap / TArray of records is flattened (by the options above), each element's rows are tinted by index parity so the records stay visually separable in CE once the per-element folder is gone. Even-indexed (struct[0], [2], …) and odd-indexed (struct[1], [3], …) rows get different text colors — pick from a neutral preset palette or a hex value, or Reset to use CE's theme. Default: Even = azure, Odd = unset. Persisted.
Collapse a drilled pointer one level when its target holds a single watchable value. If an Object/Weak/etc. pointer resolves to an object whose only field is a scalar, an FName, or an FString, it is emitted as one Pointer ▸ Field record at the pointer offset with a dereference chain — instead of a folder containing a lone child (the "pointer to a string" case). A pointer whose target has two or more fields keeps its group (its object identity is worth a boundary).
Default ON. Expand each drilled object once: a shared object reached from several fields (or via a back-reference) is fully expanded the first time and shown as a flat (shared) pointer afterwards. This prevents the huge / out-of-memory export that happens when the drill-down reaches a densely-connected object (e.g. the World). Off = expand every reference fully — which can be very large at high Drill Depth.
Default ON. When drilling into pointer/struct children, skip fields whose object class is a system/engine asset (Widget, SoundBase, Texture, Material, ParticleSystem, Niagara, AnimInstance) so the CE export stays focused on gameplay data. The fields you explicitly selected are always kept — only resolved children are filtered. Gameplay classes (Actor / Pawn / Character / components / Controller / PlayerState / GameInstance) are never skipped, and container (array/map/set) elements are not filtered. An "N system fields hidden" note appears when anything was dropped.
Fill the gaps between known UPROPERTY fields with guessed data types (pointer, float, int, etc.) — useful for surfacing native (non-reflected) C++ members that have no reflection metadata, but noisy. Off by default; the panel may auto-tick it in some contexts. (Session-only — not persisted across restarts.)
| Setting | Copy CE XML | Copy CE Field | CSX export | CE AA script |
|---|---|---|---|---|
| Collapse Pointer Nodes | ✅ | — | — | — |
| Array Limit / Preview | display + inline reads | display + inline reads | — | — |
| String Len | ✅ | ✅ | — | — |
| Fabricate | — | ✅ | — | — |
| Drill Depth | ✅ | ✅ | ✅ | — |
| Append +Offset / +Type | ✅ | ✅ | — | — |
| Collapse chain | ✅ | ✅ | — | — |
| Flatten GAS / primitive-leaf / leaf records | ✅ | ✅ | — | — |
| Collapse single-leaf pointers | ✅ | ✅ | — | — |
| Dedup shared objects | ✅ | ✅ | — | — |
| Skip system components | ✅ | ✅ | — | — |
| AOB | ✅ | ✅ | — | anchors root |
- Live Walker — where Copy CE XML / Copy CE Field and the CE Export Options live.
- Instances — the Lookup deep scan governed by Deep container scan cap.
- Value Search — its Deep option is the analogue of Locate in GWorld → Deep.