PCSX2 1.0 with Codebreaker Engine

[lee4]

PCSX2 1.0 with Codebreaker Engine (Proof of Concept)

* Easier to use, than pnach patch files.
* Supports Codebreaker 7 codetypes.
* Trace logging and RAM dumping.

cheat file name is [gameid]_[crc32].cht

cheat format "Codebreaker RAW" omniconvert plain text file.

Thanks to hyper2k for this version built.

you will need the lastest version of 7z to unzip

Do NOT ask where to find the BIOS and ISO (google it for yourself)

[47iscool]

Thanks for posting lee4, good thing I already dumped my own BIOS a few months ago.

[lee4]

this build has Trace logging and RAM dumping.

[nolberto82]

So this doesn't support boolean commands? I want to use the AND codetype so it can work regardless of what button you are holding or pressing.

[47iscool]

So this doesn't support boolean commands? I want to use the AND codetype so it can work regardless of what button you are holding or pressing.

Your best option would be to get the cracked 9.2 codebreaker that has no codes in it. It supports all PS2 codetypes IIRC.

The one that says NC is the empty one. Reason I would use the empty one is because if you add you codes into a game that already has codes you would have to encrypt them before input which is annoying IMO.

[lee4]

advance codetypes are unfinished in this pcsx2 build

CBv92_GH_DAY1_ELFLDR is what I use

[lee4]

FAQS

Is it possible to have breakpoints implemented?

I've attempted to do it with their dynarec, but I can't seem to properly get the timing of EE's PC. It's not impossible, but I don't think it's practical. Even if I get the right timing of PC, I don't think I can just raise an interrupt within the emulated EE since all code are pre-buffered before being thrown to x86.

It's easier to implement them on the interpreter mode, but then it'll be very buggy (due to the fact that interpreter mode itself is already buggy).

I notice your builds using a different cheat file system
I like know more about it and why.

If I recall correctly, it was because PCSX2's patch system is half-baked (either wrong or not working at all). I believe their only concern is to fix games to make them playable, they don't care about cheats, thus I re-wrote it a little bit.
As for that ".cht" vs. ".pnach", I made it ".cht" with easier format to add codes.

I like to know does it support codetypes?
if does support codetypes which ones?

The cheat engine modification I made does support common code types (I think it is Codebreaker based). Most of those code types should be working, but not really fully tested.

some questions and answers

[nolberto82]

Okay I'm going to try that codebreaker. I'm don't want to write a custom routine if there is codetype for it already.

[lee4]

if you add you codes into a game that already has codes you would have to encrypt them before input which is annoying IMO.

that is unnecessary to do

encrypting should be avoid at all cost


Master Code Example# 7
Master Code Start with B4336FA9 4DFEFB79 is For Codebreaker v7 to v10
Introducting new official Codebreaker encyption.
By default no longer use encryption and RAW format at the same time without special code.
0CF49BDF A4E29C32 by misfire
Cheatlist
1. Official Encrypted codes.
2. Special Encryption off code.
3. RAW format codes.
Compatible Cheat Device: Codebreaker v7 to v10
Example: B4336FA9 4DFEFB79

source:
http://gamehacking.org/vb/threads/7720-List-of-PS2-Cheat-Devices-can-use-RAW-codes

[lee4]

Okay I'm going to try that codebreaker. I'm don't want to write a custom routine if there is codetype for it already.

Pyriel has list of Codebreaker's codetypes and examples
http://www.herrvillain.com/codebreak...cal:code_types

[47iscool]

From the github ps2rd documentation:

0 - 8-bit constant write
1 - 16-bit constant write
2 - 32-bit constant write
3 - Increment / Decrement
4 - 32-bit constant serial write
5 - Copy bytes
6 - Pointer write
7 - Boolean operation
8 - unused
9 - Hook code
A - unused
B - unused
C - 32-bit do all following codes if equal to
D - Do multi-lines if conditional
E - Do multi-lines if conditional (deprecated)
F - unused


"8-bit constant write"

0-aaaaaaa 000000vv

a = address (25 bits)
v = value (8 bits)

Constantly writes the 8-bit value @v to address @a.
The address can be odd or even.

Example:
002BAA31 00000063
The 8-bit value 0x63 is repeatedly written to memory location 0x002BAA31.

--------------------

"16-bit constant write"

1-aaaaaaa 0000vvvv

a = address (25 bits)
v = value (16 bits)

Constantly writes the 16-bit value @v to address @a.
The address must be aligned to 2.

Example:
107657B2 0000FFFF
The 16-bit value 0xFFFF is repeatedly written to memory location 0x007657B2.

--------------------

"32-bit constant write"

2-aaaaaaa vvvvvvvv

a = address (25 bits)
v = value (32 bits)

Constantly writes the 32-bit value @v to address @a.
The address must be aligned to 4.

Example:
20417A64 42C80000
The 32-bit value 0x42C80000 is repeatedly written to memory location 0x00417A64.

--------------------

"Increment / Decrement"

8-bit increment
3-00000vv 0aaaaaaa

8-bit decrement
3-01000vv 0aaaaaaa

16-bit increment
3-020vvvv 0aaaaaaa

16-bit decrement
3-030vvvv 0aaaaaaa

32-bit increment
3-0400000 0aaaaaaa
vvvvvvvv 00000000

32-bit decrement
3-0500000 0aaaaaaa
vvvvvvvv 00000000

a = address (25 bit)
v = value (8/16/32 bit)

It increments/decrements the current value at address @a by value @v.
Only used with a joker code above it!

Example:
30000005 0012AC29
This will add the 8-bit value 0x05 to the value at address 0x0012AC29.

--------------------

"32-bit constant serial write"

4-aaaaaaa nnnnssss
vvvvvvvv iiiiiiii

a = start address (25 bits)
n = number of times to write (16 bits)
s = size of address step (divided by 4) (16 bits)
v = start value (32 bits)
i = size of value step (32 bits)

Starting with address @a, this code type will write the 32-bit value @v to @n
addresses. In each cycle, the address is incremented by @s * 4 and the value is
incremented by @i.

Example 1:
402E8390 00040001
FFFFFFFF 00000000
- writes 0xFFFFFFFF to 0x002E8390
- writes 0xFFFFFFFF to 0x002E8394
- writes 0xFFFFFFFF to 0x002E8398
- writes 0xFFFFFFFF to 0x002E839C

Example 2:
4099A20C 00060002
00000000 00100000
- writes 0x00000000 to 0x0099A20C
- writes 0x00100000 to 0x0099A214
- writes 0x00200000 to 0x0099A21C
- writes 0x00300000 to 0x0099A224
- writes 0x00400000 to 0x0099A22C
- writes 0x00500000 to 0x0099A234

--------------------

"Copy bytes"

5-sssssss nnnnnnnn
0ddddddd 00000000

s = address to copy from (25 bits)
n = number of bytes to copy (32 bits)
d = address to copy to (25 bits)

Copies a block of @n bytes from source address @s to destination address @d.
This is done repeatedly, so you need a D code in front of it to only copy stuff
once.

Example:
50339328 00000008
0036AED4 00000000
Copy 8 bytes from memory location 0x00339328 to 0x0036AED4.

--------------------

"Pointer write"

8-bit write
6-aaaaaaa 000000vv
00000000 iiiiiiii

16-bit write
6-aaaaaaa 0000vvvv
00010000 iiiiiiii

32-bit write
6-aaaaaaa vvvvvvvv
00020000 iiiiiiii

a = address to load 32-bit base address from (25 bits)
v = value to store at base + offset (8/16/32 bits)
i = 32-bit offset to be added to base

Loads 32-bit base address from address @a, adds offset @i to it, and constantly
writes the value @v to the final address.
Note that execution stops if base is equal to 0.

Example:
6018F6D4 000003E7
00010000 00000156
- loads base address from address 0x0018F6D4, say base is 0x001A0000
- adds offset 0x00000156 to base to make final address 0x001A0156 where 16-bit
value 0x03E7 will be written to

--------------------

"Boolean operation"

8-bit OR
7-aaaaaaa 000000vv

16-bit OR
7-aaaaaaa 0010vvvv

8-bit AND
7-aaaaaaa 002000vv

16-bit AND
7-aaaaaaa 0030vvvv

8-bit XOR
7-aaaaaaa 004000vv

16-bit XOR
7-aaaaaaa 0050vvvv

a = address (25 bits)
v = value (8/16 bits)

Performs a bitwise logical operation between value @v and the value stored at
address @a.

Example:
7048D402 005014A9
0x14A9 is XORed to the 16-bit value at address 0x0048D402.

--------------------

"Hook code"

9-aaaaaaa vvvvvvvv

a = address (25 bits)
v = value (32 bits)

This code will "hook" the game and is essential for most of the other types to
work. It hard-codes a jal to the cheat engine at address @a if the 32-bit value
at @a is equal to value @v. The address @a needs to be inside a function which
is called many times a second, e.g. scePadRead().
To cheat on multi-ELF games, create a 9 code for each ELF.

Example:
902D51F8 0C0B95F6
Insert hook if 32-bit value at address 0x002D51F8 is equal to 0x0C0B95F6.

--------------------

"32-bit do all following codes if equal to"

C-aaaaaaa vvvvvvvv

a = address (25 bits)
v = value (32 bits)

All following codes will be executed only if 32-bit value at address @a is equal
to value @v. 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:
C0153880 03E00008
If the 32-bit value 0x03E00008 is at address 0x00153880, then activate all
following codes; otherwise, do nothing.

--------------------

"Do multi-lines if conditional"

16-bit test
D-aaaaaaa nnt0vvvv

8-bit test
D-aaaaaaa nnt100vv

a = address (25 bits)
n = number of lines to execute (8 bits)
t = test condition (3 bits)
    0 equal 1 not equal
    2 less than 3 greater than
    4 NAND 5 AND
    6 NOR 7 OR
v = value (8/16 bits)

Compares value at address @a to value @v, and executes next @n code lines only
if the test condition @t is true.
Note: If @n is 0, it is internally set to 1 for compatibility.

Example:
D00802CC 07002882
200802CC 8C860000
200802D0 10C00033
200802D4 00050C02
200802D8 00C13021
200802DC 10000030
200802E0 A4C50000
100800BC 00000083
Activate next 7 lines of code if 16-bit value at address 0x000802CC is equal to
0x2882; otherwise, skip the 7 code lines.

--------------------

"Do multi-lines if conditional (deprecated)"

16-bit test
E-0nnvvvv taaaaaaa

8-bit test
E-1nn00vv taaaaaaa

This type is internally converted to the D type - see above. It has only been
added for compatibility with other systems.

[lee4]

cb & ps2rd codetypes slightly have differences with these codetypes below
D
6
9

[47iscool]

cb & ps2rd codetypes slightly have differences with these codetypes below
D
6
9

Thankfully ps2rd works with pointers created by TempAR.

Also. Something I don't understand about this documentation. Why does it say type E is deprecated?
It works just with me fine on ps2rdgui.

[lee4]

Thankfully ps2rd works with pointers created by TempAR.

PS2rd support single pointer command only
PS2rd doesnt support pointer to pointer command, but CB does

Also. Something I don't understand about this documentation. Why does it say type E is deprecated?
It works just with me fine on ps2rdgui.

misfire is making PS2rd internally convert E to the D codetype and added for compatibility reason.

[Pyriel]

Internally, the CodeBreaker converts all E commands to D and just repacks the bits anyway. There was no reason to retain E except for backwards compatibility. If not for laziness, it would have been phased out as a comparison with CodeBreaker 7.0 and eventually re-purposed.

Edit: So if you're emulating the CodeBreaker's cheat engine, the "E" doesn't actually exist there, the UI having recreated them as D commands when the codes were activated.