PSP Code Types

weltall
PSP Code types

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.
Constant Write Commands
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
Increment/Decrement Commands
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
Test Commands
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
Boolean Commands
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
Pointer Commands
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)
Miscellaneous Commands
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
Credits

Credit to
weltall
https://hellion00.thegfcc.com
Codemasters-Projects (CMP)
Xploder Freaxs (XFX)