An autorun segment that puts the open Cheat Table's address list into one window. The record tree is on the left, an inspector with five pages is on the right, a results strip for problems and matches is along the bottom, and everything works on the whole selection at once with an undo history this window keeps for itself. Cheat Engine has no structural undo, no bulk edit, no way to see every hotkey in a table and no way to ask what is broken. That is the gap this fills.
It has no dependency on the Manifold Framework. Three couplings exist and all three are optional.
It logs through Manifold Logger on a channel named Address List when that is
installed, and falls back to a timestamped print when it is not. It reads
forms.ActiveDesignTheme when a Cheat Table has a live Manifold.Forms, so the window follows the
table's theme, and falls back to the bundled Bearded-Arc palette when there is none. And
Manifold CE Utility carries the menu entry that opens it, because this
segment registers no menu of its own.
Nothing here writes to a Cheat Table's files. Every edit goes into the live records, exactly as an edit made in Cheat Engine's own list would, and saving the table stays Cheat Engine's job.
1. Installation#
Place Manifold-AddressList.lua and the Manifold-AddressList-Modules folder next to each
other in Cheat Engine's autorun folder, typically:
C:\Program Files\Cheat Engine 7.5\autorun
Portable builds keep that folder somewhere else. The Lua console tells you where:
return getAutorunPath()
The layout is the entry file, the twenty-four modules and the icon folder:
autorun/
Manifold-AddressList.lua
Manifold-AddressList-Modules/
Manifold-AddressList-CE.lua
Manifold-AddressList-DropDown.lua
Manifold-AddressList-Export.lua
Manifold-AddressList-Grid.lua
Manifold-AddressList-Host.lua
Manifold-AddressList-Hotkeys.lua
Manifold-AddressList-Icons.lua
Manifold-AddressList-Inspector.lua
Manifold-AddressList-Journal.lua
Manifold-AddressList-Lint.lua
Manifold-AddressList-Log.lua
Manifold-AddressList-Pointer.lua
Manifold-AddressList-Properties.lua
Manifold-AddressList-Records.lua
Manifold-AddressList-Results.lua
Manifold-AddressList-Script.lua
Manifold-AddressList-Search.lua
Manifold-AddressList-Settings.lua
Manifold-AddressList-Surface.lua
Manifold-AddressList-Theme.lua
Manifold-AddressList-Tree.lua
Manifold-AddressList-Types.lua
Manifold-AddressList-Version.lua
Manifold-AddressList-Window.lua
Manifold-Icons/
Manifold-*.png
The script runs on the next Cheat Engine start and publishes the host twice under the same object,
as ManifoldAddressList for everyday use and as ManifoldAddressListHost for the entry file's own
takedown of a previous generation. The facade name is registered with registerLuaFunctionHighlight
when that function exists.
Nothing touches Cheat Engine while the host is being built, so autorun with no Cheat Table loaded and no process attached is safe. The startup line is a block naming the version, the record count Cheat Engine reports, the icon state and the settings that matter.
Copying only the entry file and forgetting the folder is the one mistake this can catch. The require is wrapped, so it prints one line naming the folder and the directory it looked in instead of a require traceback on every Cheat Engine start.
Re-running it at runtime#
Executing the entry file again from the Lua Engine rebuilds everything from fresh module code.
Cheat Engine's require is standard Lua require, so package.loaded survives a re-execution. The
order matters and is fixed. The previous host's Uninstall runs first, which closes its window
without asking a page whether it minds, stops both timers and destroys the surfaces, the tree, the
inspector and the form. Then the previous generation's icons are destroyed explicitly, because the
Icons module keeps its image list in a module local upvalue and dropping the module would orphan a
live TImageList with nineteen PNGs in it. Only then are the twenty-four module names dropped from
package.loaded, and the startup line reads re-executed instead of ready.
The undo history does not survive that. It belongs to the generation that made it, and a transaction written by code that no longer exists is not something to replay.
2. Opening the window#
With the CE Utility installed, Manifold -> Open Address List.
Otherwise, from the Lua console or a table's Lua script:
ManifoldAddressList:Open()
ManifoldAddressList:Toggle()
ManifoldAddressList:Close()
Open builds the window the first time and brings it forward afterwards. Either way it reads the
whole address list before the window is shown, because a tree drawn from half-loaded nodes shows
blank descriptions for a quarter of a second and looks broken. A first load slower than 150 ms
says Reading 4120 records... on the status line while it happens.
The restyle runs once after the first show rather than before it. Cheat Engine overwrites some
control colours when the window handle is created, which for a hidden form is at show(), so
colours applied earlier would be thrown away.
Close asks the active inspector page whether it is holding an unsaved edit. A page that is offers Save, Discard and Cancel, and Cancel gives the window back. Only the active page can be holding one, because switching pages already goes through the same gate.
3. The window#
┌ Manifold — Address List · 1.0.0 ───────────────────────────────────────────────────────┐
│ [Refresh][Live] │ [Undo][Redo] │ [Find][Problems] │ [Export] [filter........] [Menu] │
├──────────────────────────────────┬───────────────────────────────────────────────────────┤
│ Records 4120 │ Inspector Properties │
│ │ [Properties][Pointer][Script][Drop-down][Hotkeys] │
│ [x] Player │ │
│ [ ] Health 4B 14A2B0 │ Identity │
│ [x] Ammo hk2 4B 14A2B4 │ Description Health │
│ [ ] Weapons GRP │ Colour Default │
│ [x] Infinite ammo AA │ Location │
│ │ Address game.exe+1A2B34 │
├──────────────────────────────────┴───────────────────────────────────────────────────────┤
│ Results 12 │
│ ERR Player > Ammo The script has no [DISABLE] section, so activating it cannot ... │
├──────────────────────────────────────────────────────────────────────────────────────────┤
│ 4120 records · 3 selected 21 groups | 44 scripts | 12 active | 12 problems │
└──────────────────────────────────────────────────────────────────────────────────────────┘
Every list in this window is painted on a canvas rather than delegated to a control. Section 11 says why, in one sentence: Cheat Engine's Lua binding registers no custom draw event for a tree view, publishes no hit test and offers no scroll box, so there is no control that can show a record the way this window shows one. The canvas engine is a port of the Logger's log view, and one Frame service owns every canvas in the window, ticking at 15 ms and painting only the ones that marked themselves dirty. A tick is skipped entirely while the form is hidden or while something modal is pumping messages.
The layout is built in the one order the LCL allows. alTop and alLeft put the last created control outermost, alBottom and alRight put the first one outermost, so the build order is the status bar, the results card, the results splitter, the find bar, the toolbar, the tree splitter, the tree card and finally the inspector card. Getting that wrong does not look wrong in the source at all, which is why the test suite asserts every edge.
The record tree#
One row per record, in Cheat Engine's own depth-first pre-order. A row carries, left to right, a coloured edge when the problem check found something on that record, the indentation and the expand arrow, the activation box, the description in the record's own colour, any badges, the type tag, the address and the value.
- The activation box toggles the whole selection. A group header toggles like any other record, which is what Cheat Engine does with it.
- The record's colour is honoured, and pushed away from the row background until it is legible
when a table picked a colour that reads against Cheat Engine's own list and not against this
one. A record with no colour of its own draws in the theme's text colour. That is decided
against
clWindowTextand the two values Cheat Engine stores for it, never against black. - Badges sit at the end of the description rather than in a column of their own, because a
record with a hotkey is the exception and a column would cost every row its width.
hk2is two hotkeys,ddis a drop-down list,lnkis a drop-down list linked to another record. - The type tag is
1B,2B,4B,8B,F,D,STR,WSTR,AOB,BIN,AA,CUSorGRP, with aPin front on a record that has offsets, so a pointer to eight bytes isP8B. A type this segment does not know draws?rather than nothing, because a table written by a plugin can hold one. - The columns shrink before they disappear. The description keeps the room whatever else has to go, because a record you cannot read the name of is useless.
- The filter highlights what it matched, in place, inside the description.
Identity is the record id throughout. The selection, the collapsed set, the focus and the scroll position are all kept by id, so a refresh that moved every record leaves you looking at the same records you were looking at.
The filter box takes a small language. Every token is an and. A bare word is a case insensitive plain substring of the description and the address string, never a Lua pattern, because a description full of brackets and percent signs is completely ordinary. Double quotes keep spaces together, and a token that starts with a quote is text even when it carries a colon.
| Predicate | Matches |
|---|---|
type:4 bytes |
The type. Also type:4b, type:dword, type:vtDword, type:aa, type:script |
type:group |
A group header. Also type:grp |
type:pointer |
A record with offsets. Also type:ptr |
is:active / is:inactive |
Whether the record is on |
is:group |
A group header |
is:pointer |
A record with offsets |
is:script |
An Auto Assembler record |
is:dontsave |
The do not save flag |
is:linked |
A drop-down list taken from another record |
is:problem |
The problem check found something. Runs the check once when it has not run yet |
has:hotkey |
One or more hotkeys. has:hotkeys is the same |
has:dropdown |
A drop-down list of its own |
has:children |
A record with records under it |
has:color |
A colour of its own. has:colour is the same |
has:offsets |
The same set as is:pointer |
id:42 |
One record, by id |
A record is visible when it matches, or when something under it does, so the ancestors of every match come back with it. Those ancestors are shown open without touching what you collapsed by hand, and clearing the filter puts your own collapsed set back exactly as it was.
The inspector#
Five tabs over the same selection: Properties, Pointer, Script, Drop-down and Hotkeys. Ctrl+1 to Ctrl+5 reach them, and Ctrl+E and Ctrl+P are shortcuts to Script and Pointer. A tab whose page cannot do anything with the current selection stays clickable and the page behind it draws an empty state that says why, because a tab that greys itself out teaches nothing.
The card's header counter is the active page's title, and while the mouse sits over a grid row with a hint it shows the hint instead. There is exactly one writer for that label, which is what keeps it from flickering between a record name and a sentence.
The Properties page is the record schema in a grid, grouped into Identity, Location, Type,
State, Group and Advanced. It reads what the whole selection agrees on and shows <mixed> where
it does not, and it emits one transaction for the whole selection, so fourteen records change
under one undo entry. Rows carry the editor their property needs: text, a number with bounds, a
drop-down of the eleven editor types, a check box drawn by hand, a colour swatch that opens Cheat
Engine's picker, and read-only rows that show something worth seeing and refuse to be typed into.
Two rows behave unusually and say so in their hint.
- Address is read only on a pointer record. Writing
Addresson a record with offsets clears every offset, so the base of a pointer belongs to the Pointer page and the hint points there. One fact, one writer. - Readable only means anything once the value was read. Cheat Engine sets
IsReadableinside its own value getter and nowhere else, so the row reads the value of every subject record before it shows anything. Without that, a perfectly healthy record reports itself unreadable.
Live sync rebuilds these rows four times a second, so the rebuild is skipped outright while an editor is open on a row and a refresh never discards what you typed. A commit happens on Enter, on Tab, on a click on another row and on an explicit save, and never from a refresh. Losing focus commits an ordinary row and cancels a dangerous one.
The results strip#
One strip at the bottom, three things in it, one at a time. The problem check writes its findings there, Find all writes its hits there, and the Menu's Changes this session writes the transactions this window made there. They share a strip because you only ever look at one of them, and three cards would eat the bottom of the window for good. The strip and its splitter are hidden together until something fills them, so the tree and the inspector get the whole height until then.
A row is a record and not a line of text. A click selects that record in the tree. A double click takes the inspector to the page that can do something about it, which for a script hit is the Script page at the line the hit was on. Right-click copies one message or all of them, or clears the strip.
The status line#
The left half is what you have: the record count, how many are selected and how many the filter matched. The number of selected records is always the number the next action will touch, because the selection is intersected with the visible set whenever the filter changes.
The right half is what the table is: groups, scripts, pointers, active records, problems, and the sync cost in milliseconds once it goes above twenty, so a table large enough to feel slow says so rather than just being slow.
A message flashes over the left half for two and a half seconds after anything happens, then the counts come back. The counts are always true, and a message is only worth reading right after the thing it is about.
4. Editing#
4.1 The commit funnel#
One place in the whole segment writes to a memory record. No page, no menu, no service and no public method writes one directly. A page builds a transaction and hands it up, the window resolves every record by id, applies the changes through one table of appliers, collects what failed and writes down only what landed.
window:Commit({
Label = "Rename 14 records",
Changes = {
{ Kind = "property", ID = 12, Key = "Description", Old = "hp", New = "health" },
...
}
})
Six kinds of change exist, and undo goes through the same six appliers the edit used, so an undo is exactly as guarded as the edit that made it.
| Kind | Writes |
|---|---|
property |
One schema property on one record |
pointer |
The base and the whole offset chain, as one change |
script |
An Auto Assembler record's script |
dropdown |
The list text, the three flags and the link |
hotkey |
One of a hotkey's value, description, action and only while down |
order |
The children of one group, in this order |
Three things fall out of that shape.
A failed change is not a failed transaction. Every change is tried, the ones that landed go into the history and the ones that did not come back as a list of records and reasons, which is logged as one warning block naming each of them. A history that claimed an edit which never happened would be worse than no history at all.
Cheat Engine's own side effects are recorded too. An applier may answer a note carrying extra changes, which the funnel writes into the same transaction. Turning a string record's unicode flag on turns its code page flag off, so both go in and one undo puts both back.
A bulk rename rebuilds the description cache once. Drop-down links, (description) value
math and getMemoryRecordByDescription all resolve through that cache, so it is rebuilt after the
whole transaction rather than after each record, which is the difference between a rename of four
hundred records being instant and being slow.
Every commit ends with a repaint of Cheat Engine's own list, a re-read of the records it touched and one Info line saying what happened.
4.2 Undo and redo#
Ctrl+Z and Ctrl+Y, or the toolbar, or ManifoldAddressList:Undo(). The journal keeps two hundred
transactions. Undo walks a transaction's changes in reverse, because two changes to one field in
one transaction have to unwind in the order they were made. Redo walks them forwards. A push after
an undo cuts the redo tail off, which is what every editor does.
The journal lives on the host rather than in the window, so closing the window and opening it again keeps the history. Re-executing the entry file does not.
A different Cheat Table resets everything. Ids start again from one in every Cheat Table, so
an undo held across a table change would write into records that have nothing to do with the ones
it was made against. Every snapshot carries a stamp computed from its root ids and the record
count. A snapshot that shares no record with the one before it drops the journal, the problems,
the results strip, the selection and the collapsed set, flashes A different Cheat Table is loaded. The undo history was dropped. and logs one line. Every transaction also carries the stamp
of the table it was made against, so even a stale one that somehow survived is skipped rather than
applied.
A transaction whose changes were all skipped still moves the cursor. It happened, the records it named are gone or refused it, and pretending it never happened would leave the history describing a state that never existed.
The Menu's Changes this session lists the history newest first, with the time, the label, how many changes it carried and whether it is currently undone.
4.3 What is not undoable#
Five things leave through a different path, the window's guarded act, which never reaches the journal. Each one says so before it runs.
Activation. Setting Active on an Auto Assembler record executes its [ENABLE] or
[DISABLE] section there and then, with no dialog of Cheat Engine's own. What a script did to the
process is not something a history can write back. This is also the only place in the segment that
writes Active at all, which is why the question lives in one place rather than in the three
callers that would each have asked it their own way. One script asks when
ConfirmScriptActivation is on, more than one always asks, and a refusal to show the dialog is a
no rather than a yes.
With Async on, the write returns before the script has finished and Cheat Engine reports nothing
when it is done. The ids that were still running are kept and re-read on every sync tick, and when
AsyncProcessing clears the window reads LastAAExecutionFailed and says what happened, per
record, once. A script still running after thirty seconds is let go with a warning, because
something in it is waiting on the game.
A value write. That writes process memory. The old bytes are gone, and the record's own
OnValueChanged may have run.
A new record or a new group. Undoing one would mean deleting a record, and this window never
deletes one. Both ask first, and the confirmation says Cheat Engine deletes records, this window does not. This is also the one edit that marks the Cheat Table as edited, because
createMemoryRecord sets that flag itself.
Removing a hotkey. destroy() unregisters it and removes it from its record. There is nothing
left to put back.
Testing a hotkey. The action runs for real, which for a toggle hotkey means the record is activated or deactivated.
4.4 Records are never deleted#
Deleting stays in Cheat Engine. mr.delete() frees the record immediately, skips Cheat Engine's
own being-edited checks, and leaves raw pointers behind in an open Auto Assembler editor and in
the inline value editor. There is no safe way to do it from Lua and no way at all to undo it.
Select the record in Cheat Engine's own list and press Delete there.
4.5 Reordering happens inside a group#
Cheat Engine's binding has exactly one move. Writing Parent or calling appendToEntry makes the
record the last child of the target. Nothing moves a record to the root, and nothing puts one
before a sibling. Everything this window offers is built from that one move.
- Move up and Move down re-append every child of the group in the order you asked for. The children were already in the group, so the parent reading right afterwards proves nothing, and the whole child order is read back instead.
- Sort children by description is the same change with a different order.
- Move into group appends the records in pre-order, so they arrive in the order they had. Records that came out of a group can be undone, by re-appending each old parent's children in the order they had, target group first. Records that came from the root cannot be put back by Cheat Engine at all, so that case asks first and is not undoable.
A record at the root has no parent to re-append into, so the root cannot be reordered. Move up,
Move down and Sort say Cheat Engine offers no way to reorder records at the root. rather than
doing nothing.
A move into the record itself, or into one of its own descendants, moves nothing and raises
nothing, because the LCL guards it with HasAsParent and Cheat Engine swallows what comes back.
Every such move is refused in Lua before the call goes out, and every move that does go out is
verified by reading the parent back.
4.6 An edit here does not mark the table as edited#
Cheat Engine's editedsincelastsave is a plain field in the main form's public section. It is not
published, not a component and not referenced anywhere in the Lua binding, so nothing this window
does can set it. Cheat Engine will not ask you to save on the way out, and the title bar will
not say the table changed. Save the table yourself after editing.
The exception is createMemoryRecord, which sets the flag itself, so New record and New group do
mark the table. That is Cheat Engine's doing and not something this window arranged.
4.7 Live sync#
Cheat Engine has no event for a record that changed, so the window polls. A poll that read everything every time would cost more than the window is worth on a table of four thousand records, so three schedules run underneath one timer, and each measures itself.
- The structure walk reads an id and a child count per record and nothing else. It runs when Cheat Engine's own count changed, and otherwise every fourth tick while it stays under four milliseconds and every twentieth once it costs more.
- The detail sweep reads the twenty fields the window draws, in a contiguous window that moves
through the snapshot. It is contiguous and not a round robin because
getMemoryRecordis only cheap when the index asked for sits next to the last one, and jumping about costs a tree walk per record. The budget halves when a tick spends more than eight milliseconds in it and grows again below four, and the sweep stops altogether once every node has been re-read since the last structure change, so an idle window costs nothing. - Values come from process memory and can fire a record's own value handler, so they are read every other tick and only for the rows actually on screen.
The Live button and the Menu turn the poll off, which leaves the window showing what the last F5 read. F5 always reads everything.
Follow Cheat Engine selection and Mirror selection to Cheat Engine are both off by default and
both are one-way switches you can have at the same time. Mirror writes only when this window's
focus moved since the last write, and Follow ignores a Cheat Engine selection that equals the one
Mirror just wrote, so the two cannot take turns selecting each other. Mirror only sends the focus,
because Cheat Engine holds exactly one selected record.
5. Finding and replacing#
Ctrl+H, or the Find button. The bar carries what to look for, what to replace it with, which fields to read, the scope, and case and whole word switches.
| Field | Read from |
|---|---|
| Descriptions | The description of every record |
| Scripts | The Auto Assembler script, on records that have one |
| Drop-down lists | The list text, on records whose list is their own |
| Scope | Means |
|---|---|
| All | Every record in the table |
| Visible | The rows the filter is currently showing |
| Selection | The selected records |
Find all lists every match in the results strip, one row per match, with the record's path and an excerpt of the line it sits on. A click selects the record, a double click opens the page that edits the field and, for a script, puts the editor on the line.
Replace all is one transaction. Four hundred renames are one undo entry. The replacement runs
in one pass over the spans that were found before anything changed, because a loop that searched
again after each replacement would find the needle inside its own replacement and never finish,
which is what turns replacing a with aa into a hang.
Two kinds of record are skipped rather than written, and both are reported:
- An active Auto Assembler script. Rewriting the text of a running script leaves the process
holding changes that no
[DISABLE]section matches. - A linked drop-down list. The list you see belongs to another record, so replacing in this record's own text would change nothing anybody can see.
Every search is a plain find and never a Lua pattern, in both directions. A description with a percent sign or a bracket in it is ordinary text to a person and stays ordinary text here.
6. Problems#
F7, or the Problems button, or ManifoldAddressList:Lint(). One pass over the whole table. The
findings land in the results strip, mark the tree with a coloured edge per record, and count on
the status line. is:problem in the filter narrows the tree to them, and runs the check once when
it has not run yet.
| Code | Severity | Reported when |
|---|---|---|
EMPTY_SCRIPT |
Error | An Auto Assembler record's script is empty or only whitespace |
MISSING_ENABLE |
Error | A script has a [DISABLE] section and no [ENABLE] one, so activating it does nothing |
MISSING_DISABLE |
Error | A script has an [ENABLE] section and no [DISABLE] one, so activating it cannot be undone |
LAST_RUN_FAILED |
Error | LastAAExecutionFailed is set on the record |
DEAD_DROPDOWN_LINK |
Error | The list is linked to a description that no record in the table has |
ASSEMBLE_FAILED |
Error | A section does not assemble. Off by default |
DUPLICATE_DESCRIPTION |
Warning | Two or more records share a description, and a link or a lookup finds only one of them |
HOTKEY_CONFLICT |
Warning | One key combination is registered twice, and only one of them will ever fire |
UNREADABLE |
Warning | The value could not be read. Off by default |
EMPTY_DESCRIPTION |
Info | The record has no description |
ACTIVE_UNDER_INACTIVE |
Info | An active record sits under an inactive group whose options hide its children |
A script with neither section is not reported. That is a one shot somebody runs by hand, not a half written pair.
Three of the checks are facts about the table rather than about one record, so the whole table is read even when the check is limited to a few records. A shared description is still found when only one of the two records is in the set, and a hotkey conflict with something elsewhere in the table is exactly the one nobody finds by looking.
Two checks cost real time and are off until the Menu turns them on.
- Read values while checking reads the value of every record that is not a group or a script,
which touches the target process and can stall on a paged out address. It is also the only way
the unreadable check means anything, because
IsReadableis stale until the value was read. - Assemble scripts while checking runs Cheat Engine's
autoAssembleCheckover both sections of every script. That executes every custom Auto Assembler command handler the Cheat Table registered, while this window is only asking a question. That is the whole reason it is opt in.
LastAAExecutionFailedReason is usually the literal word Unknown, which says nothing, so the
message drops it when that is all Cheat Engine has.
7. The pages#
Pointer#
The chain of one record, level by level, in the order it is walked. Row one is the first dereference. Cheat Engine stores it the other way round, with offset zero applied last and the highest offset applied to the base first, which is why its own pointer dialog draws the first dereference at the bottom. The two orders meet in exactly two places in this segment, and the rest of it never has to know.
Every row carries the offset text, the pointer value read at that level and the address that level
resolves to. A read that fails shows ??, and so does every level under it, because there is no
address left to read from. The last row is what Cheat Engine calls CurrentAddress.
Add level, Remove level, Up and Down edit the chain. Paste path reads a chain off the clipboard in the arrow, bracket or comma form. Adding the first level is what turns a plain record into a pointer, and removing the last one makes it a plain address again.
Apply writes the base and the whole chain as one change, not one per level. A half written chain points at nothing and there would be no way back from it.
The offsets are counted in Lua before anything is read. Offset[i] and OffsetText[i] have no
bounds check behind them and an index Cheat Engine does not have dereferences nil inside Pascal,
which is an access violation and not a Lua error, so no pcall would save the process. This page
walks the buffer it owns and never asks Cheat Engine for a level that is not there.
Script#
One Auto Assembler record's script, with Save, Revert, Check and Go to line. Ctrl+S saves and Ctrl+G jumps to a line.
The editor comes from the theme, which hands back a control and two closures, and the page reads
and writes through those two and never through the control. On a Cheat Engine with createSynEdit
that is a highlighted editor with a gutter. Without it the same call returns a themed memo. The
text lives behind a different property on each, so a page reaching for Lines.Text itself would
work on one build and quietly do nothing on the other. Save, Revert, Check and Go to line work
either way, and the memo only loses the colours and the line numbers.
Check never runs the script. autoAssembleCheck assembles both sections without writing to
the process, so it is safe to press at any time, and it is the only way to find out whether a
script would work before turning it on. Failures go to the results strip with the line Cheat
Engine named, so a click lands on that line.
Saving an active script asks first. A script that is on right now was enabled by the text that
is about to be replaced, and its [DISABLE] section is the only thing that can undo what that
text did. Replacing both halves under a running script leaves the process holding changes nothing
can take back.
A record that is not an Auto Assembler record reads no script at all and a write to it is dropped, so the page says to change the type on the Properties page first rather than letting you type into something that will not be saved.
Drop-down#
The list a record offers instead of a bare number. One line is one entry: a value, a colon, then the description shown in its place. Cheat Engine splits at the first colon, and a line without one becomes an entry whose description is empty, which reads in the address list as a value that lost its name. Nothing in Cheat Engine warns about it, so this page parses the text the same way, previews what came out, and flags every line with no colon in it.
Four flags sit around the list. Three of them, Read only, Description only and Show as list item, have getters that follow the link, so while a record is linked they hand back the linked record's values and not this record's own. Writing one back would copy another record's setting into this one. So while a record is linked the list text and those three checks are read only, the page names the record the values come from, and the only things it will write are the link itself and the description it points at. Unticking Linked is the way back, which is why that one check stays live.
The linked record is named by its description and not by an id, because that is what Cheat
Engine stores. Renaming the source record breaks the link in silence, which is what
DEAD_DROPDOWN_LINK exists to catch. Go to linked record selects the source, or says the link
names nothing rather than moving the selection somewhere wrong.
Apply carries only the fields you actually changed, so a bulk apply over records whose flags differ leaves the flags nobody touched alone.
Hotkeys#
An overview, not an editor. It lists every hotkey of the selection, or every hotkey in the table with the All records toggle, in columns Keys, Action, Value, Record and Description, and flags in the warning colour every combination that is on more than one hotkey. The conflict scan always reads the whole table even when the list shows a selection.
Four fields can be edited and all four go through the commit funnel, so they undo like any other edit: the value, the description, the action and only while the keys are held down. Test runs the action for real after a confirmation. Remove destroys the hotkey, which neither Cheat Engine nor this window can undo, and says so first.
It does not create hotkeys and it does not change key combinations. Two Cheat Engine facts decide that.
Capturing a combination means listening for key presses while the table's own hotkeys are
registered, so the combination somebody tries to record fires the very hotkeys they are looking
at. And a hotkey's Keys setter fills one slot at a time and stops at the first empty one, so a
shorter combination leaves the trailing keys of the old one behind, while the thread that
registered the hotkey keeps the copy it registered with and never hears about the change at all.
Changing keys therefore means destroying the hotkey and creating a new one, which loses the id
every undo entry is keyed by.
The page says it on the page, in one muted line, because the first thing anybody looks for here is a New button:
Add or change key combinations in Cheat Engine. This page shows every hotkey in the table and
finds conflicts.
8. Settings#
Manifold-AddressList-Settings.lua holds the defaults.
| Setting | Default | Effect |
|---|---|---|
| Window.Width | 1180 | The window opens this wide. Minimum 760 |
| Window.Height | 740 | And this tall. Minimum 480 |
| TreeWidth | 540 | How much of the width the record tree takes, 320 to 1400 |
| ResultsHeight | 180 | The results strip, 90 to 600 |
| FontSize | 10 | Consolas 10 is the family size. Everything the canvases draw is measured off it, 7 to 16 |
| LiveSync | true | Keep reading the address list while the window is open |
| SyncInterval | 250 | How often that poll runs, 100 to 2000 ms |
| ShowValues | true | The value column, and the value reads that fill it |
| ShowAddresses | true | The address column |
| FollowCESelection | false | Take Cheat Engine's own selection |
| MirrorSelectionToCE | false | Push this window's focus into Cheat Engine's selection |
| ConfirmScriptActivation | true | Ask before activating a single Auto Assembler record. More than one always asks |
| InspectorPage | "Properties" | Which tab a fresh window opens on |
| Lint.ReadValues | false | Read every value while checking the table |
| Lint.Assemble | false | Assemble every script while checking the table |
| Search.MatchCase | false | Match upper and lower case exactly |
| Search.WholeWord | false | Only matches that stand on their own |
| Search.Description | true | Search descriptions |
| Search.Script | true | Search Auto Assembler scripts |
| Search.DropDown | false | Search drop-down lists |
| Search.Scope | "All" | All, Visible or Selection |
| Export.IncludeScripts | true | Scripts reach JSON and the outline |
| Export.IncludeValues | false | A value is read from a running process at the moment of the export |
| Export.IncludeChildren | true | An exported group carries what is under it |
Overrides go where the host is built in the entry file. Nested tables merge, so one search flag can be changed without restating the others:
local host = Host:New({
Settings = { FontSize = 11, LiveSync = false, Search = { MatchCase = true } }
})
Every number the window can drag or step is held inside its bounds here and nowhere else. A splitter dragged to nothing and a font size stepped past what a canvas can measure both come back through the same setter, so clamping at the edge of the window would leave the registry holding the bad value.
8.1 Persistence#
Twenty-four settings are written through getSettings("Manifold Address List") whenever a setter
changes them and read back on the next start, which is every row in the table above. The window
size, the tree width and the results height are written when the window closes, so the shape it is
left in is the shape it opens in.
A dotted key reaches into a nested table and is stored under that name, dot included, so the
registry holds one flat entry named Search.MatchCase. Values go in as strings, with a boolean
written as 1 or 0, and are decoded against the type of the default, so a hand edited or
damaged registry value falls back to the default rather than turning a number into a string.
Cheat Engine answers an empty string, never nil, for a value that was never written, which is read
as absent, so a fresh install keeps every default. That is also why an empty string cannot be
stored as itself: a setting somebody deliberately emptied goes in as the marker <empty> and
comes back out as an empty string.
Passing Persist = false to the host keeps everything for the session only.
9. The public object#
ManifoldAddressList is the host. Everything the window does is a method on it, so a Cheat Table's own Lua script or the Lua console can do the same work with nothing on screen.
ManifoldAddressList:Open() -- shows the window, building it the first time
ManifoldAddressList:Close() -- a page holding an edit can refuse
ManifoldAddressList:Toggle()
ManifoldAddressList:IsOpen()
ManifoldAddressList:Select({ 12, 13, 14 }) -- point the window at records
ManifoldAddressList:Selected() -- the ids the next action would touch
ManifoldAddressList:Snapshot() -- the whole table as plain Lua tables
ManifoldAddressList:Lint() -- the problems, and the counts beside them
ManifoldAddressList:Lint({ Assemble = true }) -- with the expensive checks on
ManifoldAddressList:Find("health") -- every match, nothing written
ManifoldAddressList:Replace({ Needle = "hp", Replacement = "health" })
ManifoldAddressList:Export("C:\\table.json") -- json, csv, md or txt, picked by the ending
ManifoldAddressList:Undo()
ManifoldAddressList:Redo()
ManifoldAddressList:Status() -- a table
ManifoldAddressList:About() -- logs the block and makes sure it is visible
ManifoldAddressList:Diagnostics() -- the deeper block, including what this build has
ManifoldAddressList:Uninstall() -- closes the window and frees everything
ManifoldAddressList:Shutdown() -- Uninstall, plus releasing both globals
The headless calls read the address list again before they run, so a script that just added records does not work from a tree that predates them. They write through the same funnel and into the same journal the on-screen window uses, which is what keeps one commit path and one undo history whether or not a form exists. A replace run from the console can be undone with Ctrl+Z after you open the window.
Selected answers this window's selection when it is open, and Cheat Engine's own selected
records when it is not, so a script can pass them straight into Export.
Find returns one entry per match, with the record id, the field, the line, the column, the
length and an excerpt. Replace returns how many fields were written and the ones that were
refused with a sentence saying why. Lint returns the problems in pre-order and a table of
Checked, Errors, Warnings, Infos and Took.
Status reports the version, whether the window is open, the record count, the selection size,
the problem count, the undo depth, whether the icon set loaded, whether the Logger was found and
the settings that matter. StatusRows is the same thing shaped for a log block, which is what the
startup line prints:
Manifold Address List 1.0.0 ready
Authors : Leunsel, LeFiXER
Window : not open
Records : 4120
Undo history : 0 entries
Icons : loaded
Logger : Manifold Logger
Live sync : on, every 250 ms
Columns : values, addresses
Settings : persisted in the registry
ManifoldAddressList:Open() opens the window.
ManifoldAddressList:Lint() checks the table and reports what is wrong.
ManifoldAddressList:Status() returns this as a table.
That is the fallback rendering. With Manifold Logger installed the block is drawn by the Logger instead, and the same rows arrive in its console.
Uninstall is what the entry file calls on a previous generation. This segment registers no menu,
so there is nothing to remove: it closes the window without asking a page whether it minds, stops
both timers, destroys the surfaces, the tree, the inspector and the form, and destroys the icon
set. Shutdown is that plus releasing both published globals, compared by identity so a newer
generation that already took them over keeps them.
No facade call raises. The CE Utility reaches Open through a pcall and a Cheat Table script
reaches the rest with no guard at all, so every one of them catches its own defect and logs it.
10. Internal structure#
Twenty-four modules and one entry file. The order below is also the order they are built in, and a module may only depend on one above it.
Foundation
| Module | Owns |
|---|---|
| -Version | The version number. Nothing else in the tree carries one |
| -Log | The Manifold Logger channel named Address List, the print fallback, and Block |
| -Settings | Defaults, the entry file's overrides, the bounds, the dotted keys and the registry store |
| -CE | Every Cheat Engine global this segment touches, each one guarded and looked up at call time |
| -Icons | The 16x16 set, one image list per Cheat Engine session, and the glyphs composited for the canvas |
| -Theme | The Cheat Table's live palette, every themed control, the window, the cards, the modal helpers and the code view |
Data
| Module | Owns |
|---|---|
| -Types | The mapping between a record's integer type and its enum name, the tags, the labels and what a person may type |
| -Records | The snapshot, the structure walk, the budgeted detail passes, the query language, flattening to rows and the three structure moves |
| -Properties | The property schema, the bulk read, the bulk write, and the readers and writers for the pointer chain, the script, the drop-down list and the hotkeys |
Services
| Module | Owns |
|---|---|
| -Journal | Undo and redo. It never touches Cheat Engine, it is handed one Apply function |
| -Lint | The eleven checks, their severities and their codes |
| -Search | Find and replace. The two functions that matter are pure |
| -Export | Collect, Build in four formats, and Write |
Canvas
| Module | Owns |
|---|---|
| -Surface | The shared canvas engine: the probe, the off-screen bitmap, scrolling, the drawn scrollbar, the wheel, text measuring and truncation, the check box, the arrow, the Frame service and the column driven ListPainter |
| -Tree | The record tree, its rows, its selection model, its mouse and its keyboard |
| -Results | The results strip, and what each of its three kinds says when it is empty |
| -Grid | The property grid, and editing in place under a refresh that runs four times a second |
Pages
| Module | Owns |
|---|---|
| -Inspector | The tab strip, one panel per page, the page change gate, the header counter, and the Properties page itself |
| -Pointer | The pointer chain, in the order it is walked |
| -Script | The Auto Assembler editor, Check and Go to line |
| -DropDown | The list, its four flags and the link |
| -Hotkeys | The overview, the conflicts, the four editable fields, Test and Remove |
Shell
| Module | Owns |
|---|---|
| -Window | The form, the two timers, the layout, the menus, the keyboard, the commit funnel, the appliers, the acts, the status line and every hook the tree, the results strip and the inspector reach the outside through |
| -Host | Building everything in order, the journal, the facade methods, Status, About, Diagnostics, Uninstall and Shutdown |
Globals are never captured at load time. A test can therefore stub the whole API, and an older Cheat Engine degrades to a logged reason rather than an error raised while autorun is still loading. Nothing in the wrappers turns a failure into a fake success: a missing confirmation dialog blocks the action, it never reads as consent.
Memory record wrappers are never kept. Cheat Engine builds a fresh wrapper on every access and never invalidates the old ones, so a wrapper held past a delete is a use after free, and two wrappers of one record are not the same Lua value. Ids are the only identity there is, and every id is resolved again at the moment it is used.
10.1 The tests#
Manifold-AddressList-Tests/Run.lua runs the whole segment headlessly on any Lua 5.3:
lua Run.lua <projectDir> <scratchDir> <filter>
Eight files run in dependency order: the stub itself, the foundation, the theme, the data modules,
the services, the canvas, the pages and the window. Each starts from a fresh stub with the segment
modules dropped from package.loaded, so nothing one file did can reach the next. There are 3051
checks.
CEStub.lua is the Cheat Engine they run against, and it is written to be wrong in exactly the
ways the real one is. appendToEntry into a record's own branch is a silent no-op rather than an
error. Reading an event of an unregistered type raises while writing one does nothing. Options
drops the whole assignment on one unknown flag. getSettings answers an empty string for a key
nobody wrote. createMemoryRecord gives a vtDword record described "Plugin Address". An
OnClose that returns nothing means the form stays open. getMemoryRecord refuses a negative
index. Setting a tree's Selected in code fires OnSelectionChanged, a check box's Checked
fires OnChange and OnClick, and a combo box's ItemIndex fires nothing. Stub.OnScreen
models the LCL alignment rule, and one test guards the rule itself so nobody "fixes" it the wrong
way round. A module that regresses to any of those fails in the test run instead of quietly
producing a window that does not work on a real Cheat Engine.
11. Cheat Engine behaviours that contradict celua.txt#
Everything below was read out of the Cheat Engine 7.5 and Lazarus 2.2 sources, or measured. Each one differs from what the documentation says, or is not in the documentation at all, and each one decided something about how this segment is built.
A tree view has no custom draw from Lua. TTVCustomDrawItemEvent and its advanced form are
not in LuaCaller's registered type list, in 7.5 or in master. Assigning OnCustomDrawItem on a
tree is swallowed without a word and reading it back raises. GetNodeAt is public rather than
published, so there is no hit test either, and no drag event is assignable. A list view does have
all six custom draw events, which several readings of the documentation get backwards, but a list
view is not a tree. That is why the record tree in this window is painted on a canvas: there is no
control in the binding that can show a record with its own colour, a check box, badges and a
problem marker.
Reading an On* of an unregistered type raises. Writing one is a silent no-op, because
lua_setProperty wraps its body in try ... except end. The getter has no such guard. Cheat
Engine's own address list owns OnSelectionChanged, OnAdvancedCustomDrawItem, the drag handlers
and several more, so this segment never reads or writes an event on any Cheat Engine object at
all. The CE wrapper refuses any member matching On followed by a capital, which is also why a
hotkey's OnlyWhileDown is still readable.
getAddressList().refresh() does not repaint the record tree. TControl.Refresh is not
virtual and TAddresslist.refresh is a static method, so the call reaches the panel and never the
tree window inside it. getAddressList().List.repaint() is what shows a change. Every commit here
ends with that call, on the tree found by component name.
A Lua edit never marks the Cheat Table as edited, and nothing can. editedsincelastsave is a
plain field in the main form's public section, not published, not a component and not referenced
in the Lua handler. The one exception is createMemoryRecord, because addaddress sets the flag
itself. Everything else this window writes leaves Cheat Engine believing the table is unchanged.
Parent = x and appendToEntry(x) fail silently. A target that is the record itself or one
of its own descendants moves nothing and raises nothing, because the LCL's MoveTo guards with
HasAsParent. Both are also the only move there is, and both append as the last child.
Parent = nil dereferences a nil pointer inside appendToEntry, and the access violation happens
inside lua_setProperty, which swallows it. So nothing is ever moved without reading the parent
back afterwards, and a reorder inside one group is verified by reading the whole child order back,
because the parent never changes there.
pcall does not catch an access violation inside a binding. Offset[i] and OffsetText[i]
outside the offset count, getMemoryRecord with a negative index and appendToEntry(nil) all
dereference nil inside Pascal with no handler, and that takes the process down rather than
returning an error to Lua. Every one of those is bounds-checked or nil-checked in Lua before
the call.
mr.Address = s clears the pointer offsets. Editing a pointer means writing the address, then
the offset count, then each offset text, then reinterpret(), in that order. That is why the
Properties grid's Address row is read only on a record with offsets and sends you to the Pointer
page.
Offset[0] is applied last. Cheat Engine walks for i := offsetCount-1 downto 0, so the
highest offset is applied to the base first, which is why its own pointer dialog draws the first
dereference at the bottom of the list. This window shows the chain in the order it is walked and
turns it round again on the way out.
Type takes an integer and range checks nothing. A string or nil written to it becomes
vtByte without a word. VarType reads the enum name back and accepts either form. Setting 7
stores vtString with the unicode flag on, and setting 12 stores a pointer sized integer with
show as hex, so neither value is ever read back from a record. The editor type list here holds
eleven entries, those two are deliberately not among them, and every write takes its integer from
that list.
One unknown element makes a whole Options write fail silently. FPC's StringToSet raises
EPropertyError on a name it does not know, and lua_setProperty swallows it, so the whole
assignment is dropped. moHideChildren and moAlwaysHideChildren also exclude each other only
against the set the record already has, so writing both at once to a record holding neither
stores both. Every option write therefore rewrites the whole set string, reads it back, and
derives what changed from what came back rather than from what was asked for.
Setting Active is ignored in three cases. When the value is already that, while
AsyncProcessing is true, and when the script failed to assemble, which leaves it false. It is
also assigned only after the script has run, so Active is read back after every write. And
deactivating a group with moDeactivateChildrenAsWell pumps messages, so timers and handlers can
re-enter in the middle of it. That is why the window's busy flag is a counter and not a flag, and
why both timers stand down while it is above zero.
LastAAExecutionFailedReason is usually the literal word Unknown. Reporting it as given
would put a message on screen that says nothing, so it is dropped when that is all there is.
IsReadable is stale until the value was read once. Cheat Engine sets it inside GetValue
and nowhere else, so a record whose value was never read reports itself unreadable. The Properties
row reads the value first, and the hint says so.
getMemoryRecord(i) is only cheap next to the last index asked for. The LCL caches exactly
one node, so a round robin over a large table costs a tree walk per record. The detail sweep here
moves through a contiguous window for that reason alone.
getSelectedRecords() answers nothing at zero and a sparse table otherwise, so it is read
with pairs and never with ipairs. And setSelectedRecord given a record that is gone clears
the whole selection instead of raising, so an id is resolved before it is handed over.
Changing a hotkey's Keys leaves trailing keys behind. The setter fills one slot at a time
and stops at the first zero, so a shorter combination keeps the tail of the old one. It also does
not re-register, so the thread keeps the combination it was created with. Changing keys means
destroy and create, which loses the id. That is why the Hotkeys page does not do it.
createMemoryRecord() gives a vtDword record described "Plugin Address", appended at the
end of the root. Not vtByte, which two independent stubs of this API got wrong.
A Lua OnClose that returns nothing means caNone. The form stays open, and a window nobody
can close is the result. This window's OnClose always returns caFree or caNone deliberately,
and the theme's Esc handling is left off so the window can decide for itself what Escape means.
alTop and alLeft put the last created control outermost. alBottom and alRight put the first
one outermost. The LCL's InsertBefore says so in its own comment, contrary to the VCL. Reading
a layout wrongly here produces a window that looks almost right, so the test suite asserts every
edge.
canvas.textRect is not a clipping call. Its first argument is a rect table and it renders
through Cheat Engine's formatted text renderer, which would read a record description as markup.
Nothing in this segment calls it. Text is measured with getTextWidth, truncated in Lua and drawn
with textOut. fillRect takes four integers in 7.5 and no rect table.
A graphic control never takes focus and never receives the mouse wheel. A paint box and an
image are both graphic controls, so the wheel handlers go on the surface and on its windowed
parent, and the keyboard is routed by the window through KeyPreview and a note of which pane the
last mouse down landed on. The wheel event carries no delta at all, only a position, so the
direction is which of the two handlers ran. A mouse button arrives as an integer and never as a
name, so the right button is 1.
Writing a property in code fires events, unevenly. edit.Text = s fires OnChange,
checkbox.Checked = v fires OnChange and OnClick, and combo.ItemIndex = i fires
nothing. Handlers are assigned after initial values, or guarded with a loading flag.
getSettings answers an empty string and never nil for a key that was never written, so a
fresh install keeps its defaults and a deliberately empty value needs a marker of its own.
Writing a read-only member does two different things, both bad. An explicitly registered one,
such as Selected or CurrentAddress, replaces the getter on that wrapper. A published read-only
property, such as Index or Count, is swallowed and changes nothing. A misspelt property name
lands raw in that one wrapper's metatable and appears to work. Nothing here writes one, and
anything that matters is read back.
After bulk description changes, call rebuildDescriptionCache(). Drop-down links,
(description) value math and getMemoryRecordByDescription all resolve through it, and without
the rebuild they resolve to the wrong record.