These code types are supported by the main cheat engine (the one mainly used for PSP games, although there is a version of it for pops games).
These code types were developed starting from the ps2 reference from codemasters Project (and this page is based on that page) and then evolved with some new code types requested by code makers.
Here you will find a list of them including a short description.
| Code type | Format | Description |
|---|---|---|
| 8-bit Constant Write | 0x0aaaaaaa 0x000000dd | This command will constantly write the value specified by dd to the address specified by aaaaaaa |
| 16-bit Constant Write | 0x1aaaaaaa 0x0000dddd | This command will constantly write the value specified by dddd to the address specified by aaaaaaa |
| 32-bit Constant Write | 0x2aaaaaaa 0xdddddddd | This command will constantly write the value specified by dddddddd to the address specified by aaaaaaa |
| Code type | Format | Description |
|---|---|---|
| 8-bit Increment | 0x301000nn 0xaaaaaaaa | This command adds the value specified by nn to the value stored at the address aaaaaaaa |
| 8-bit Decrement | 0x302000nn 0xaaaaaaaa | This command subtracts the value specified by nn to the value stored at the address aaaaaaaa |
| 16-bit Increment | 0x3030nnnn 0xaaaaaaaa | This command adds the value specified by nnnn to the value stored at the address aaaaaaaa |
| 16-bit Decrement | 0x3040nnnn 0xaaaaaaaa | This command subtracts the value specified by nnnn to the value stored at the address aaaaaaaa |
| 32-bit Increment | 0×30500000 0xaaaaaaaa 0xnnnnnnnn 0×00000000 | This command adds the value specified by nnnnnnnn to the value stored at the address aaaaaaaa |
| 32-bit Decrement | 0×30600000 0xaaaaaaaa 0xnnnnnnnn 0×00000000 | This command subtracts the value specified by nnnnnnnn to the value stored at the address aaaaaaaa |
| Code type | Format | Description |
|---|---|---|
| 16-bit Equal | 0xDaaaaaaa 0x0000dddd | Only when the value at the address specified by aaaaaaa is equal to the value specified by dddd will the next line of code be executed |
| 16-bit Not Equal | 0xDaaaaaaa 0x0010dddd | Only when the value at the address specified by aaaaaaa is not equal to the value specified by dddd will the next line of code be executed |
| 16-bit Less Than | 0xDaaaaaaa 0x0020dddd | Only when the value at the address specified by aaaaaaa is less than the value specified by dddd will the next line of code be executed |
| 16-bit Greater Than | 0xDaaaaaaa 0x0030dddd | Only when the value at the address specified by aaaaaaa is greater than the value specified by dddd will the next line of code be executed |
| 8-bit Equal | 0xDaaaaaaa 0x200000dd | Only when the value at the address specified by aaaaaaa is equal to the value specified by dd will the next line of code be executed |
| 8-bit Not Equal | 0xDaaaaaaa 0x201000dd | Only when the value at the address specified by aaaaaaa is not equal to the value specified by dd will the next line of code be executed |
| 8-bit Less Than | 0xDaaaaaaa 0x202000dd | Only when the value at the address specified by aaaaaaa is less than the value specified by dd will the next line of code be executed |
| 8-bit Greater Than | 0xDaaaaaaa 0x203000dd | Only when the value at the address specified by aaaaaaa is greater than the value specified by dd will the next line of code be executed |
| 16-bit Equal: Multiple Skip | 0xEnnndddd 0x0aaaaaaa | Only when the value at the address specified by aaaaaaa is equal to the value specified by dddd will the next nnn lines of code be executed. Otherwise, they will be skipped |
| 16-bit Not Equal: Multiple Skip | 0xEnnndddd 0x1aaaaaaa | Only when the value at the address specified by aaaaaaa is not equal to the value specified by dddd will the next nnn lines of code be executed. Otherwise, they will be skipped |
| 16-bit Less Than: Multiple Skip | 0xEnnndddd 0x2aaaaaaa | Only when the value at the address specified by aaaaaaa is less than the value specified by dddd will the next nnn lines of code be executed. Otherwise, they will be skipped |
| 16-bit Greater Than: Multiple Skip | 0xEnnndddd 0x3aaaaaaa | Only when the value at the address specified by aaaaaaa is greater than the value specified by dddd will the next nnn lines of code be executed. Otherwise, they will be skipped |
| 8-bit Equal: Multiple Skip | 0xE1nndddd 0x0aaaaaaa | Only when the value at the address specified by aaaaaaa is equal to the value specified by dddd will the next nn lines of code be executed. Otherwise, they will be skipped |
| 8-bit Not Equal: Multiple Skip | 0xE1nndddd 0x1aaaaaaa | Only when the value at the address specified by aaaaaaa is not equal to the value specified by dddd will the next nn lines of code be executed. Otherwise, they will be skipped |
| 8-bit Less Than: Multiple Skip | 0xE1nndddd 0x2aaaaaaa | Only when the value at the address specified by aaaaaaa is less than the value specified by dddd will the next nn lines of code be executed. Otherwise, they will be skipped |
| 8-bit Greater Than: Multiple Skip | 0xE1nndddd 0x3aaaaaaa | Only when the value at the address specified by aaaaaaa is greater than the value specified by dddd will the next nn lines of code be executed. Otherwise, they will be skipped |
| Adress Equal | 0xDaaaaaaa 0x4bbbbbbb 0xnnnnnnnn 0x0000000Y | Only when the value at the address specified by aaaaaaa is equal to the value at the adress specified by bbbbbbb will the next nnnnnnnn line of code be executed. The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit |
| Adress Not Equal | 0xDaaaaaaa 0x5bbbbbbb 0xnnnnnnnn 0x0000000Y | Only when the value at the address specified by aaaaaaa is not equal to the value at the adress specified by bbbbbbb will the next nnnnnnnn line of code be executed. The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit |
| Adress Less Than | 0xDaaaaaaa 0x5bbbbbbb 0xnnnnnnnn 0x0000000Y | Only when the value at the address specified by aaaaaaa is less than the value at the adress specified by bbbbbbb will the next nnnnnnnn line of code be executed. The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit |
| Adress Greather Than | 0xDaaaaaaa 0x5bbbbbbb 0xnnnnnnnn 0x0000000Y | Only when the value at the address specified by aaaaaaa is Greather than the value at the adress specified by bbbbbbb will the next nnnnnnnn line of code be executed. The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit |
| Code type | Format | Description |
|---|---|---|
| 8-bit OR | 0x7aaaaaaa 0x000000vv | aaaaaaa = address (25 bit) |
| 8-bit AND | 0x7aaaaaaa 0x000200vv | vv = value (8/16 bit) |
| 8-bit XOR | 0x7aaaaaaa 0x000400vv | Performs a bitwise logical operation between given value, vv, and the value stored at |
| 16-bit OR | 0x7aaaaaaa 0x0001vvvv | given address, aaaaaaa. Example: |
| 16-bit AND | 0x7aaaaaaa 0x0003vvvv | 0x7048D402 0x005014A9 |
| 16-bit XOR | 0x7aaaaaaa 0x0005vvvv | 0x14A9 is XORed to the 16-bit value at address (user ram)+0x0048D402 |
| Code type | Format | Description |
|---|---|---|
| 8-bit write | 0x6aaaaaaa 0x000000vv 0x0000nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vv = value to store at base + offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to add to base (n = 1) |
| 16-bit write | 0x6aaaaaaa 0x0000vvvv 0x0001nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vvvv = value to store at base + offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to add to base (n = 1) |
| 32-bit write | 0x6aaaaaaa 0xvvvvvvvv 0x0002nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vvvvvvvv = value to store at base + offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to add to base (n = 1) |
| 8-bit inverse write | 0x6aaaaaaa 0x000000vv 0x0003nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vv = value to store at base - offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to subtract to base (n = 1) |
| 16-bit inverse write | 0x6aaaaaaa 0x0000vvvv 0x0004nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vvvv = value to store at base - offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to subtract to base (n = 1) |
| 32-bit inverse write | 0x6aaaaaaa 0xvvvvvvvv 0x0005nnnn 0xiiiiiiii | aaaaaaa = address to load 32-bit base from (25 bit) vvvvvvvv = value to store at base - offset (8/16/32 bit) qqq = offset to add to load the base(*4) nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes) iiiiiiii = 32-bit offset to subtract to base (n = 1) |
| Extra pointer line (n > 1) type null | 0×00000000 0×00000000 | This will do absolutely nothing but it's required for n > 1. You may need to use this if you want to use the qqq in normal pointer codes |
| Extra pointer line (n > 1) type pointer walk | 0xSppppppp 0xSppppppp | This will make you able to go trough various level of pointers S indicates the type of offset to find the next pointer(0×2 +p 0×3 -p) while p indicates the offset to find the next pointer. |
| Extra pointer line (n > 1) type multi adress write | 0x9sssssss 0xwwwwwwww | sssssss = offset to add to base(*bytes of the code type, see above) wwwwwwww = value to sum to starting value (vvvvvvvv) each time it's pointed |
| Extra pointer line (n = 2) type copy byte | 0x1sssssss 0×00000000 | This extra pointer line will change sligtly the working of the pointer codes as specified above. vvvvvvvv = bytes to be copied aaaaaaa = address to load 32-bit base from (25 bit) (source) iiiiiiii = 32-bit offset to add to base qqq = offset to add to aaaaaaa to load the base(*4) (destination) sssssss = 32-bit offset to add to base (destination) |
| Code type | Format | Description |
|---|---|---|
| Jocker Code | 0xD00000dd 0x1nnnnnnn | This command will check the psp controller for the combination specified by nnnnnnn. If equal it will execute the next dd+1 code lines else it will skip them. It can check for combinations of up to 3 buttons and it can be used even with kernel mode only buttons (like note, screen, etc) Combination are sums of the values found here: Button Codes NOTE: remapsp remaps are ignored by this function. |
| Inverse Jocker Code | 0xD00000dd 0x3nnnnnnn | This command will check the psp controller for the combination specified by nnnnnnn. If not equal it will execute the next dd+1 code lines else it will skip them. It can check for combinations of up to 3 buttons and it can be used even with kernel mode only buttons (like note, screen, etc) Combination are sums of the values found here: Button Codes NOTE: remapsp remaps are ignored by this function. |
| Copy Bytes | 0x5aaaaaaa 0xnnnnnnnn 0xbbbbbbbb 0×00000000 | This command will copy part of the memory from one area to another aaaaaaa = Address to copy from bbbbbbbb = Address to copy to nnnnnnnn = Number of bytes to copy |
| 32-bit Multi-Address Write/Value increase | 0x4aaaaaaa 0xxxxxyyyy 0xdddddddd 0xIIIIIIII | Starting with the address specified by aaaaaaa, this code will write to xxxx addresses. The next address is determined by incrementing the current address by (yyyy * 4). The value specified by dddddddd is written to each calculated address. If IIIIIIII is different from zero the value defined by dddddddd is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code” |
| 16-bit Multi-Address Write/Value increase | 0x8aaaaaaa 0xxxxxyyyy 0x1000dddd 0xIIIIIIII | Starting with the address specified by aaaaaaa, this code will write to xxxx addresses. The next address is determined by incrementing the current address by (yyyy * 2). The value specified by dddd is written to each calculated address. If IIIIIIII is different from zero the value defined by dddd is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code” |
| 8-bit Multi-Address Write/Value increase | 0x8aaaaaaa 0xxxxxyyyy 0x000000dd 0xIIIIIIII | Starting with the address specified by aaaaaaa, this code will write to xxxx addresses. The next address is determined by incrementing the current address by (yyyy * 1). The value specified by dd is written to each calculated address. If IIIIIIII is different from zero the value defined by dd is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code” |
| Code Stopper | 0xCaaaaaaa 0xvvvvvvvv | aaaaaaa = address (25 bit) vvvvvvvv = value (32 bit) All following codes will be executed only, if 32-bit value at given address, aaaaaaa, is equal to given value, vvvvvvvv. Otherwise, they will be skipped. Can be used to exit the code sequence at any point. To act on all codes (like traditional “Auto Activation”), put it at the top of the code list! Example: 0xC0153880 0x03E00008 If the 32-bit value 0x03E00008 is at the address (user ram)+0×00153880, then activate all following codes. Otherwise, do nothing. NOTE: this affects all the cheats entered after the one with this code as it stops the execution of the cheat engine till the next loop |
| Time Command | 0xB0000000 0xnnnnnnnn | nnnnnnnn = delay value (32 bit) Delay putting on all following codes for v cycles; effect varies between games and loaded prxs. To act on all codes, put it at the top of the code list! 0xB0000000 0×10000000 Loop is executed 0×10000000 times. NOTE: this will stop other cheats after it in the cheat list |
Credit to
weltall
http://hellion00.thegfcc.com
Codemasters-Projects (CMP)
Xploder Freaxs (XFX)