Action Replay Codes. An Action Replay is a cheating device cartridge which you can purchase from sites such as ebay (as they are old now and probably only available second hand) which allow you to enter in various codes for a range of different enhancements or cheats in your game. Many Action Replay DS codes can freeze the game, if they are activated at the wrong time. Action Replay DS comes with no tool (or 'trainer') to deactivate or enter new codes after starting the game, although there are built in IF, and IF NOT features when changing the values denoting whether a button is held down or not for two addresses which serve the same purpose in any legitimate Nintendo. The action replay provides a convenient code to do comparisons of 16-bit numbers masked like this. The code is 9XXXXXXX ZZZZYYYY, where XXXXXXX is the address, ZZZZ is the mask we want to use (FCFF in this case), and YYYY is the number we want to compare to. You can also enter codes manually using Action Replay's virtual keyboard. Our code creators are always hard at work on the latest DS titles, so even the very latest games will be trained and tamed within hours of hitting the shelves. Action Replay DSi/3DS is compatible with 3DS, DSi, DSi XL, DS Lite and the original DS game consoles.
Note: this only covers unencrypted AR codes. Also, GameCube cached RAM is from
0x81800000; all addresses within only bother with the bottom 25 bits. In effect, you can view the RAM as extending from
0x1800000 for the purposes of AR codes.
This article is intended as either a replacement or supplement for the Dolphin documentation on ActionReplay codes for the GameCube as I find it a little difficult to understand on a read-through. My intention is to create an assembly language and assembler for such codes once I have finished creating this documentation.
A single ActionReplay code1 is a 64-bit number, with the following layout:
The Data_Size value represents the actual size of the data being acted on (measured in bytes) as so: size = 1 << Data_Size, or equivalently
size = 2^Data_Size where
^ represents exponentation. For all of these codes,
3 is not a valid Data_Size (though it is for Type 0, Subtype 3, where it has a special meaning which isn’t covered here). Further, all addresses must be aligned, that is a multiple of
The Opcodes seem inspired by MIPS, at least indirectly through PowerPC which the GameCube’s Gecko processor is based on. I say this because they’re split into two parts (in the Dolphin documentation, referred to as Type and Subtype): the overall opcode, and the specific function covered by that opcode.
Broadly, the types are as follows:
- 0. Write
- 1. Equality test
- 2. Inequality test
- 3. Signed less than test
- 4. Signed greater than test
- 5. Unsigned less than test
- 6. Unsigned greater than test
- 7. Bitmask test
I’m not covering Subtype 3 here as, to be frank, I don’t really get it. As far as I can tell, it’s used for master codes and not a lot else
The Action Replay code are written in Big-Endian format, and automatically translated to the endianness of the target system. Basically, you can write values as you would on paper (in hexadecimal), rather than having to maybe reverse the bytes.
All write codes have
0: Immediate write/fill
These codes fill an area of memory with a value. To better describe this, we split up the Value into bytes as in the Dolphin documentation:
For a byte, Y4 is written (Y1 Y2 Y3) + 1 times, starting at Address.
For a short, Y3Y4 is written (Y1 Y2) + 1 times, starting at Address.
For a long, Y1Y2Y3Y4 is written 1 time, starting at Address.
1: Indirect write
These codes write to a pointer with some offset, like how arrays work in C. As above, we look at the individual bytes of the Value:
Their behaviours are easiest expressed in C. Note that array indices are done as elements, not bytes.
Addition, as the name implies, adds some value to an address, rather than overwriting it. There is an oddity in that the value to add is always 32-bit, regardless of the data size being used. However, overflow triggers standard wraparound, so the upper bytes are effectively unused for bytes and shorts.
I don’t currently understand Subtype 3, so this section is left blank for now. Try the Dolphin documentation if you need master codes, etc, or to read from uncached memory (0xC… instead of 0x8…)
All the conditional codes work in effectively the same way, so they end up being lumped in together! The basic format is the same: they compare against some given
Value, then do… something depending on the result. We’ll get to what that something is, but for now, here are the conditions you can check, corresponding to values of
|Less than (signed)2||3|
|More than (signed)2||4|
|Less than (unsigned)||5|
|More than (unsigned)||6|
|Mask != 0||7|
Of these, I feel that only Mask needs explaining, or at least a better concise name. Mask means to AND the value at the given address with
Value, effectively masking the bits we don’t care about. For example, we could check if a number is negative by masking it with 0x1000 0000, though perhaps “Less than (signed)” would be more understandable.
Now for the
Opcode_Subtypes, and the actions they cause:
|Skip next line||0|
|Skip next two lines||1|
|Skip rest of code||2|
|Wait until true||3|
Yeah, conditions aren’t the easiest to work with conceptually while designing a code; nesting them or including an “else” is even harder. So lucky you, there’s an “if then else” example later on.
“Type Z” Codes
“Type Z” codes, as they are known in the Dolphin documentation, are special cases that don’t match the pattern of the other codes. The first 4 bytes are always zero.
Action Replay Codes Converter Energy Benefits Free
There are three known execution mode commands:
- End of Execution – return control to the game, then resume executing the code from the beginning. Code
- Unlock – execute codes normally, where it interleaves code execution with the game’s code. Code
- Lock – execute codes atomically, not giving control back to the game at all. Code
Fill with Increment
This is the only known two-line code. Its structure looks somewhat like this:
addressare the same as in the rest of the document
- I’d hope that
value_incrementis an 8-bit signed number. Each step, this is added to the value.
addr_incrementis a 16-bit signed number. Each step, (2^size * addr_increment) is added to the address. In other words,
addr_incrementis measured by size of the value being written rather than bytes.
- Contrary to the Dolphin documentation, the value increment appears to have no effect on the sign of the address increment.
I’m going to give an example here: “if
*0x030bb4 28 then write 1 to
0x030bb8 else write 2 to
I want to work with 4-byte integers, so I need to remember to use
Data_Size 2. I’ve decided to implement it like this:
|If ||Skip Two (0b01)||Equal (0b001)||32-bit (0b10)|
|Write 2 to ||Immediate (0b02)||Write (0b000)||32-bit (0b10)|
|Write 1 to ||Immediate (0b02)||Write (0b000)||32-bit (0b10)|
Snaptube pro apk. End Execution is a Type Z code, which don’t have the standard byte pattern, and so is skipped here. Between
Data_Size, we have the first 7 bits; the last bit of the first byte is the top bit (bit 25) of the address, here 0, giving us the first byte of each line:
Now just append the other 24 bits of the address to get the first word:
Action Replay Codes Converter Energy Benefits 100%
As for the rest, it’s just the value filling the rest of the word:
Et voilà! A simple-ish Action Replay code!
Unit Converter Energy
- Excluding the so-called “Type Z Codes”, where the first 32-bits are all zero. Their structure is covered separately. ↩
- The 1-byte size acts as if it were unsigned. This may be an action replay bug. ↩↩