(Artemis) Code Types

[Gtlcpimp]

Ah.

Specifically, I'm concerned with single and controlled increment/decrement (I'm not even sure how we could achieve a single increment/decrement, but it would be a great feature...but controlled increment/decrement should definitely be implemented).

If you mean by using the controller to increment / decrement, then controlling is rather simple. You need a Boolean check to see if you are holding down the button on the controller or not. If it reads True, it will not increment/decrement, if it reads False, it will increment/decrement then set the Boolean value to True. When you let go of the button, it returns it to false. In my programming I also set the variable name as "hold" to see if I am holding the button or not. For a cheat code, write a small routine for the extra checks.

[Lazy Bastard]

Ah, yes. I somehow didn't even consider that, and I've used it in PS2 GUI development, heh (Parasyte pointed it out to me, in fact).

[kh2k4]

Are you sure Codebreaker's vcycle command isn't just a one timed delayed activator the same Action Replay's C type?


C1000000 YYYY - Delays codes from being on by YYYY time when the game starts. 4000-5000 should give 20-30 seconds.

I often wondered why you can't just hook the sceGsSyncV instead of scePadRead and scesifsendcmd it's called before them.

[bungholio]

Would there be a way to modify the serial repeater 4 code type?
Need a way to specify whether to modify 1, 2, or 4 bytes, and then to modify if it is constant write, constant OR, constant AND, or constant XOR. I've never actually seen an XOR code type used, otherwise I have this in mind:

4(???a)aaaaaa
The address is still 25 bits, those ?'s are bits to change that. The problem is there isn't room for the 1 byte constant AND, and no XORs if anyone wants those.

40000000 to 41ffffff are 4 byte constant writes.
42000000 to 43ffffff are 4 byte constant ORs.
44000000 to 45ffffff are 4 byte constant ANDs.

46000000 to 47ffffff are 2 byte constant writes.
48000000 to 49ffffff are 2 byte constant ORs.
4a000000 to 4bffffff are 2 byte constant ANDs.

4c000000 to 4dffffff are 1 byte constant writes.
4e000000 to 4fffffff are 1 byte constant ORs.

Don't use this. It would be nice to have this sort of control with that code type. RPGs could really use this with many characters with many ORs to turn on statuses and ANDs to remove some. Mayn things have 99 whatever or 999 whatever too.

[misfire]

@kh2k4: Yes, I'm sure because I reverse-engineered most of CodeBreaker's interesting code, and the C type is also used for the same purpose by Xploder V4.

@bungholio: This is possible. We could use one of the @n digits to indicate the operation without affecting compatibility. I guess nobody actually sets @n to high value. So the 4 code becomes something like this:

4-aaaaaaa xnnnssss
vvvvvvvv iiiiiiii

Values for x:
0 - 32-bit write
1 - 32-bit OR
2 - 32-bit AND
3 - 32-bit XOR
4 - 16-bit write
5 - 16-bit OR
6 - 16-bit AND
7 - 16-bit XOR
8 - 8-bit write
9 - 8-bit OR
a - 8-bit AND
b - 8-bit XOR

What do you say?

[Gtlcpimp]

I have revised the public v1.1 cheat device to ensure all of you that it is not detected. Here is a list of the revisions:

- Increased security to prevent detection
- Updated code commands to support 7 digit code addresses
__ 0 - 8 Bit Constant Write
__ 1 - 16 Bit Constant Write
__ 2 - 32 Bit Constant Write
__ 3 - Increment / Decrement
__ 4 - 32-bit Multiple Address Write
__ 5 - Copy Bytes
__ 6 - Pointer Write
__ C - Code Stopper
__ D - Boolean: Half (Aka: Joker)

-== Code Command Information ==-

-- Constant Writes --

Code Setup: CAAAAAAA DDDDDDDD
C - Command
A - Address
D - Data

Description:
If not jokered, these codes are constantly writing the given data to the specified address.

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

-- Increment / Decrement --

8 Bit Increment
300000nn aaaaaaaa

8 Bit Decrement
301000nn aaaaaaaa

16 Bit Increment
3020nnnn aaaaaaaa

16 Bit Decrement
3030nnnn aaaaaaaa

32 Bit Increment
30400000 aaaaaaaa
nnnnnnnn 00000000

32 Bit Decrement
30500000 aaaaaaaa
nnnnnnnn 00000000

a = Address
n = Amount To Increase / Decrease

Description:
Increments or decrements the value contained at the address by the amount of data given every time this code is applied by the cheat engine.

-------------------------------------
-- 32 Bit Multiple Address Write --

4aaaaaaa wwwwssss
dddddddd nnnnnnnn

a = Starting Address
w = Number Of Lines To Write
s = Number Of Lines To Skip
d = Data To Write
n = Ammount To Increase Given Data By

Description:
Writes the given data to the address specified. It also writes the same data to as many lines specified. The data can be increased for each line, and the number of lines to write can be spaced out rather than being consecutive.

-------------------------------------
-- Copy Bytes --

5fffffff nnnnnnnn
tttttttt 00000000

f = Address To Copy From
t = Address To Copy To
n = Number Of Bytes To Copy

Description:
Copies the given number of bytes from the first address, and writes those bytes to the second address.

-------------------------------------
-- Pointer Write --

8 Bit Pointer Write
6aaaaaaa dddddddd
0000nnnn iiiiiiii

16 Bit Pointer Write
6aaaaaaa dddddddd
0001nnnn iiiiiiii

32 Bit Pointer Write
6aaaaaaa dddddddd
0002nnnn iiiiiiii

a = Pointer Address
d = Data To Write
i = Number of bytes from final address to write data
n = Number of Pointers

Description:
Reads the address from the given address, and writes the given data to that address. If more than one pointer are needed, then it will keep reading the address contained at the current address it has loaded for as many pointers specified (n) and write the data to the final address.

-------------------------------------
-- Code Stopper --

Caaaaaaaa dddddddd

a = Address to Read
d = Data to Compare To

Description:
If the value contained at the address is equal to the data given in the code, all the codes below this line will be applied like normal. If the value is not equal to the data given in the code, then the cheat engine will exit at this line (it will not apply the codes below this point).

===========================


This is just a revision, and the program is still in its BETA state.

Further Updates:

- More binary code list files can be stored on the memory card
- Code manager will be updated to produce the full CheatersLounge folder for indexing support
- Binary code lists are listed through an index file for fast listings of multiple code lists on the PS2
- On-Screen code list selection for selecting a certain code list rather than being forced to load a specific code list




Instructions:

1) Build the binary code lists with the code manager program (you all should know how to use that by now).
2) Open the index builder program, it is named "Cheaters Lounge Index Builder v1.0.exe"
3) Either drag the binary code lists to the list box, or click "Add" to add them (You can only add 1 at a time).
4) Title each Code List to whatever name you like.
5) Ensure that all the binary code lists you added are inside the folder named "CheatersLounge".
6) When finished building the index list, click "Save Index" (be sure you save it inside the folder named "CheatersLounge").
7) Follow the commonly known steps to copy the full folder named "CheatersLounge" to your PlayStation 2's memory card.
8) Load the cheat device on your PlayStation 2, it is named "CL-CheatsEngine_PUBLIC_v1.2.elf" (This can be loaded off of a USB Flash Drive, and does not need to be placed on the memory card).
9) Select the list you wish from the on-screen title list, press X to load the list, and then press Square to launch the game when you are ready.

If you want to edit an existing index file, you can simply open the index by clicking the "Open Index" button and selecting the "listindex.ini" file you want to edit.

You may download it here: http://cheaterslounge.org/downloads/...UBLIC_v1.2.rar

~ Gtlcpimp

Link: http://forums.cheaterslounge.org/vie...hp?f=79&t=1094

Just something I already have completed and working... The commands were based off of what I saw on Code Masters Project...

[misfire]

Yes, and CMP got most of the information from me...

[misfire]

Implemented code type 3 (increment/decrement) and added it to the list.

[misfire]

With type 6 ("pointer write"), has anybody ever seen such a code where @n - the number of times to point - is greater than 1?

6-aaaaaaa vvvvvvvv
0002nnnn iiiiiiii

If not, we could leave it out and only support @n = 1.

[Viper187]

One of the things that always bothered me about the PS2 jokers on CB, etc was that the value being checked had to be 16-bit. That's fine for pad reads, but pad reads aren't the only reason to use a joker. Lookig at yours, I don't see a way to make a distinction between 8 and 16 bit if you only want 8 bits tested either.

What about a slide code? I was introduced to those on GBA. I think they're pretty nice for ASM hacks. You specify the address and number of bytes to write, then follow it with every byte to be written. The difference between this and a serial repeater is that you specify EVERY byte to be written, not just increment. Like...

?aaaaaaa 0000zzzz
XXXXXXXX XXXXXXXX
XXXXXXXX XXXXXXXX
XXXXXXXX XXXXXXXX

a = start address
z = # of bytes
X = bytes to write

?01C0120 00000018
3C020204 2402ABCD
50410001 AC020000
03E00008 AC410478

would write:
001C0120 3C020204
001C0124 2402ABCD
001C0128 50410001
001C012C AC020000
001C0130 03E00008
001C0134 AC410478