You found the health address.
You changed 83 into 999, saved it in your Cheat Engine table, restarted the game—and suddenly the address no longer worked.
Maybe it showed a completely different number. Maybe changing it did nothing. Maybe the game crashed with the confidence of a program that had been waiting all night to punish you.
What happened? The value moved.
A memory address found through a normal scan is often valid only for the current game session. When the game restarts, the same health, money, or ammunition value may be stored somewhere else.
The solution is usually to stop saving only the current address and start finding a reliable route to it. That is where pointers come in.
If you are completely new to Cheat Engine, start with our guide to what Cheat Engine is and how it works. You may also want to read our Cheat Engine beginner’s guide before continuing.
Why Does the Address Change?
Suppose you scan for your character’s health and find it at: 18F4A2C0
It works perfectly during the current session.
After restarting the game, however, the health value may appear at: 21B7D890
The original address still exists, but it may now contain:
- Another game object
- Nothing useful
- Something important enough to crash the game when replaced with
999
A direct memory address is therefore often more like a hotel room than a permanent home. Your health stayed in Room 412 yesterday. Today, Room 412 contains a conference table.
Changing the conference table’s health does not solve your problem.
Games Use Dynamic Memory
Modern games constantly create and remove objects while they are running.
These objects may include:
- The player
- Enemies
- Temporary effects
- The 4,000 cheese wheels you dropped inside your house
Many of these objects are stored in dynamically allocated memory.
Instead of placing the player at one permanent address, the game asks the operating system for available memory whenever it needs to create the player object.
That available location may be different every time the game starts.
It can also change when you:
- Load another save
- Change levels
- Die and respawn
The game may destroy the old player object and create a new one somewhere else. Your health did not merely move house. The game demolished the neighbourhood and rebuilt it across town.
Static and Dynamic Addresses
Cheat Engine users often describe addresses as either static or dynamic.
Dynamic Address
A dynamic address may point to the correct value during the current session but change after a restart.
Example: 21B7D890
This might be your current health address now, but it is not guaranteed to remain useful later.
Static Address
A static address can be found reliably relative to the game executable or one of its modules.
Cheat Engine may display it like this: Game.exe+0050A120
The actual location of Game.exe may change between launches, but Cheat Engine can find where the module is currently loaded and then apply the offset.
This makes a module-relative address more reliable than a raw address such as: 7FF612345678
However, your health is often not stored directly inside the game executable. Instead, the executable may contain a pointer leading to the player object.
What Is a Pointer?
A pointer is a value that stores another memory address. For example, imagine that this module-relative address exists: Game.exe+0050A120
The value stored there is: 21B7D000
That second address may be the beginning of the player object. Inside the player object, health might be located at offset: +30
The final health address would therefore be:21B7D000 + 30 = 21B7D030
The player object may move after restarting the game. It might appear at:19F3C000during the next session.
However, if Game.exe+0050A120 still points to the new player object, Cheat Engine can follow the pointer and add the same offset again.
Instead of saving the temporary destination, you save the route:
Game.exe+0050A120 → Player Object → Health at +30
The destination moves. The signpost still knows where it went.
What Is an Offset?
An offset is simply a distance from another address.
Suppose the player object begins at: 21B7D000
and health is located at: 21B7D030
The health offset is: 30
Related values are often stored close together inside the same object.
For example:
| Offset | Possible Value |
|---|---|
+30 | Current health |
+34 | Maximum health |
+38 | Stamina |
+3C | Maximum stamina |
+40 | Character level |
The object’s location may change, but its internal layout may remain consistent. This is why finding the beginning of a player object can reveal several nearby statistics. You begin by looking for health.
Five minutes later, you are wandering through the character’s internal anatomy like an accountant performing surgery.
What Is a Pointer Chain?
Some games use more than one pointer level.
The game executable may point to a game manager. The game manager may point to the current world. The world may point to the player. The player object finally contains health.
Conceptually:Game.exe → Game Manager → World → Player → Health
This is called a pointer chain or multilevel pointer. The final health address may change, and several intermediate objects may also move, but the route between them can remain stable.
Think of it as asking for directions:
- Ask the game manager where the world is.
- Ask the world where the player is.
- Walk to offset
+30. - Find health.
- Avoid asking why the game needs this much bureaucracy.
How to Find a Pointer in Cheat Engine
There are two main beginner-friendly approaches:
- Inspect the instruction accessing the value
- Use Cheat Engine’s pointer scanner
The pointer scanner is usually easier to start with.
Basic Pointer-Scanner Method
First, find the value normally. For example, scan until you locate the current health address.
Then:
- Right-click the address.
- Select Pointer scan for this address.
- Choose where to save the scan results.
- Run the scan.
- Restart the game.
- Find the health address again.
- Rescan the saved pointer results using the new address.
- Repeat after several restarts or game-state changes.
The first pointer scan may return a huge number of possible paths. That is normal.
Many values in memory may accidentally form valid-looking routes to the target. The first scan has not found “the pointer.” It has assembled an entire stadium full of suspects.
Why Rescanning Matters
A pointer path that works once may still be temporary. The only way to identify more stable paths is to test them after the game rearranges its memory.
Suppose your first scan finds one million possible pointer paths. After restarting the game and rescanning against the new health address, that may fall to 20,000.
After another restart, perhaps 300 remain. After changing levels, dying, loading another save, and rescanning again, only a handful may survive.
Each rescan asks:
Which previous routes can still find the value now?
A pointer that survives multiple sessions and different game states is much more reliable than one that worked once. One successful launch is luck.
Several successful rescans begin to look like evidence.
Pointer-Scanner Settings Beginners Should Know
The pointer scanner contains many options, but beginners mainly need to understand two.
Maximum Level
This controls how many pointer jumps Cheat Engine may follow. A higher level allows more complicated pointer chains, but also creates far more results.
Do not immediately choose twelve levels because twelve sounds powerful.
That is how a simple experiment becomes an SSD endurance test.
Maximum Offset
This limits the size of each offset in the pointer path. A larger maximum offset searches more broadly but also increases the number of results. The ideal settings depend on the game, so there is no universal perfect number.
Start with reasonable defaults, rescan several times, and only broaden the search when no useful paths survive.
How to Test a Pointer
Once you have a likely pointer result, add it to the Cheat Engine address list. Then verify that it shows the correct value.
After that:
- Restart the game.
- Load the relevant save.
- Confirm that the pointer resolves correctly.
- Change levels or respawn.
- Check it again.
A pointer that only works before the first loading screen is technically a pointer. It is simply a pointer with commitment issues. Also test whether it finds the correct character.
Some games use similar structures for:
- The player
- Enemies
- Companions
- Previous player instances
- Multiplayer entities
A valid path may lead to a health value without leading to your health value. Finding a character structure is one problem. Proving that it belongs to you is where the paperwork begins.
Why a Pointer Shows Question Marks
Sometimes a pointer displays: ??
This means Cheat Engine cannot currently resolve the path.
Common reasons include:
- The game has not loaded the player yet
- You are still on the title screen
- The relevant level is not active
- One part of the chain is currently null
- An offset is wrong
- The pointer only works in a specific game state
- The game has been updated
Do not immediately assume the pointer is broken. A pointer leading to the player cannot work before the player object exists. The player has not been born yet.
Load the save or enter the game world, then check again.
Why Pointers Break After Updates
Even a pointer that works across many restarts may stop working after a game patch.
Updates can change:
- Object layouts
- Pointer paths
- Module offsets
- Field positions
- Game managers
- Loaded libraries
- Executable code
Suppose health was previously stored at: Player Object + 30
After an update, the developer adds another field before health. The new health offset might become: Player Object + 38
Your pointer still reaches the player object, but the final offset now points somewhere else. Maybe stamina. Maybe armour. Maybe a number controlling how dramatically the character’s coat reacts to wind. Pointers improve stability across sessions.
They do not guarantee survival across updates.
Module Plus Offset Is Better Than a Raw Address
Cheat Engine often displays addresses using a module name and offset: Game.exe+345678
This is more useful than saving an absolute address such as: 7FF612345678
The absolute address may change whenever the module loads somewhere else. The module-relative version tells Cheat Engine:
Find where Game.exe is currently loaded, then move 345678 bytes from the beginning.
This allows the address to survive module relocation more reliably. The difference is simple:
- Raw address: a location
- Module plus offset: directions to a location
However, game updates may still change the internal offset. Nothing is permanent. Software merely takes longer to betray you.
What About AOB Scanning and Code Injection?
More advanced tables may use Array of Bytes (AOB) scanning or code injection when pointer paths are unreliable; for a practical explanation, read our guide to Cheat Engine AOB scripting and unlocking hidden game mechanics.
Common Pointer Problems
The Pointer Works Until I Change Levels
The chain may pass through an object that gets destroyed during a level transition.
Create another pointer scan after changing levels and rescan the previous results.
A reliable pointer should survive the situations in which you intend to use it.
I Still Have Thousands of Results
Continue rescanning after:
- Restarting the game
- Reloading a save
- Changing levels
- Dying and respawning
- Returning to the main menu
Each new game state helps eliminate unstable routes.
All Results Disappeared
Your original settings may have been too restrictive, or the target structure may have changed completely.
Other possibilities include:
- You found the wrong address
- The new address is only a display copy
- The pointer chain is deeper than expected
- The game is better handled through code analysis
Try again with broader settings or inspect what accesses the value.
The Pointer Finds the Wrong Character
The pointer may lead to a shared character structure rather than the local player.
You may need a path beginning from a specific player manager or a structure containing a local-player identifier.
This problem becomes more common when players and enemies use the same internal layout.
Direct Address vs Pointer
A direct address is useful for quick experiments.
It answers:
Can this value be changed?
A pointer is useful for reusable tables.
It answers:
Can I find this value again after restarting?
That is the main difference.
You do not need a pointer for every temporary test.
But once you want a table that works tomorrow, direct addresses are usually not enough.
Final Thoughts
Cheat Engine addresses keep changing because modern games create, destroy, and relocate data while they run. The health address you find today may only be the value’s current location.
A pointer provides a route to that location. A module-relative address gives the route a stable starting point. A pointer chain follows the game’s own connections between managers, worlds, players, and statistics until it reaches the value you need.
That is the transition from:
I found my health.
to:
I can find my health again tomorrow.
And that difference is what turns a successful scan into a reusable Cheat Engine table.
The value moved. You simply learned how to ask the game where it went.
