Skip to content

Finding values

Most mods start by finding where a number lives, like your health or your gold.

Search scans memory for a value, then narrows it down.

  1. Search for the number you can see, like your gold.
  2. Change it in game. Buy something.
  3. Search again for the new number.
  4. Repeat until a handful are left.

After the first search, you don’t need an exact number. Narrow by Changed, Unchanged, Increased or Decreased instead. Good for things like health bars that don’t show a number.

Pick the results you want and press Ctrl+L to add them to Addresses.

The address list is your notes. Each entry has a description, an address, a type and its live value.

  • F2 or double-click changes the value. Handy for checking you found the right one.
  • Space holds it, so the game can’t change it.
  • Ctrl+N adds an entry by hand, Ctrl+Shift+N adds a group.
  • Give an entry an id and it becomes a name, like player.health, that tweaks and code can use.

Entries can follow pointers. Set an address and a list of offsets, and it reads the pointer at each step, like Cheat Engine.

A group can have an address and offsets too. Leave it blank and it’s just a folder.

Inside a group with an address, an entry whose address starts with + or - is relative to the group. If the group is at the player, +0x10 is 16 bytes into the player, and +4*0x1A is the 26th of its 4 byte values. The whole rest is added to the group, so +0x218*0 is the group itself. Move the player’s pointer and everything in the group follows. Groups inside groups can be relative too.

Ids work the same way. A relative entry with an id is a name like any other, so tweaks and scripts find it without the list.

Pick a type from the project’s schemas instead of 4 Bytes and the entry shows the whole struct. Schemas a plugin or script loads can be picked too, shown with where they’re from, like GameStateManager (kai). The project’s win when two have the same name. Open it with + to see its fields, nested structs, arrays and bitfields, and follow pointers into other structs.

  • F2 changes a field’s value, like any other entry.
  • Space holds a field or an element, even with the struct closed, and follows pointers as they change. Holding the entry itself holds all of it, if it’s 256 bytes or less.
  • Add as entry (Ctrl+L) turns the field you picked into an entry of its own. In a group with an address, it gets a + address.
  • Fields aren’t saved. Change the schema and the list follows.

If the type isn’t in any schema, the entry says so.

Fill in Count to make an entry an array. Each element shows as [0], [1] and so on, and struct elements open into their fields.

  • A number like 10 or 0x10 is a fixed count.
  • Anything else is where to read the count from, as 4 bytes. +0x54 reads it from the group, which is handy when a struct keeps its own count.
  • Add as u16 for another size, like +0x54 as u16. It’s u8, u16, u32, u64, or i8 to i64 for signed ones.

Only the first 1000 elements are shown. A count over a million is taken as a mistake.

The list is saved with the project. Export (Ctrl+E) and Import (Ctrl+I) move it in and out as a .rwa.zon.

A plain 1, 2, 4 or 8 byte entry can be just some of its bits, like a flag. Set Bit and Width in its details. The type shows as 4 Bytes, bits 2..3. Reading, changing and holding it only touch those bits, so the rest stay as the game sets them.

Give an entry a list of labels and it shows them in place of numbers. Type them in its details, one per line, like 0: Off. Only the label hides the number, though values that aren’t in the list still show as numbers. Or put another entry’s id in the box next to it to use its list.

When you change the value you get an arrow with the labels. Typing filters them, and you can still type a number or a label.

Right-click an entry’s details and pick Add hotkey, then press the keys. Each one holds, lets go, sets a value, or adds or takes some away. On a group, holding works on everything in it.

They’re in the game’s keybinds, so they work with the workbench closed or never opened, and they’re named after the entry, like Mira: set 999999. If you rebind one there, your key is kept for this game.

A held entry normally gets put back whenever the game changes it. Let it go up, not down only puts it back when the game lowers it, and a higher value is held from then on. Let it go down, not up is the other way round. This is saved with the entry, holds aren’t.

Names lists every name there is. Your entries with ids, statics from the project’s schemas, what plugins and tweaks add, and signature scans. Each shows its location text, where it is now, its type, and whether it was found. If it wasn’t, it says why in red.

  • Filter by where they’re from, or type to filter by name.
  • Ctrl+L adds one to Addresses as an entry that points at it by name, typed when its type is known.
  • Ctrl+B and Ctrl+D show it in memory or as code.
  • Ctrl+C copies the name, Ctrl+Shift+C the address.
  • Rescan and Rescan all check signatures again. Original code scans the game’s code from before anything hooked it.
  • New scan looks for a pattern of your own. Type it and press Enter.

Found a value? The next question is usually what code changes it.

Select it and press Ctrl+Shift+W. Then do something in game that changes it. Every instruction that wrote it shows up next to the entry, with how often.

Ctrl+Shift+R does the same for reads.

These use the CPU’s debug registers, so only four can run at once. Stop all watches frees them. What they found stays.

From there, Ctrl+D takes you to the code. See Reading code.

View > New memory view, or Ctrl+B on anything, shows raw bytes. Select some and Ctrl+L adds them to the list. You can paste hex straight over them too.

Made with ♥ by Asgard