CL-LiveDebug v3

[Gtlcpimp]

"addi" and "addiu" deal with a 16 bit value. The largest integer for a 16 bit value is 32767, or 0x7FFF. The lowest is -32768, or 0x8000. The value -1 would be 0xFFFF for the 16 bit value.

[Lazy Bastard]

In addition, ADDIU doesn't support overflow.

[bungholio]

I'm assuming overflow is somethings like FFFFFFFF + 3? What's the advantages of using it or how would I use that effectively as opposed to ADDI other than that speed thing mentioned?

[Lazy Bastard]

You could put the overflow into a register, and use it later (or just flag that overflow has occurred). Here's an example (of the former):

http://msdn.microsoft.com/en-us/library/ms881447.aspx

For a little more detail on overflow in MIPS, do a Google search for ("cs61c - lecture 13" "Overflow in Arithmetic") (without the parentheses). You'll find the lecture in PowerPoint format, but you can use Google search's built-in "View as HTML" feature.

[bungholio]

I went through a few games this morning. The "randomly doesn't work" thing seems to be true. I do keep going through games and for some reason they will randomly start up.

God Of War 1 = Aside from LD's screen being in different places, it's perfect. While at the game start menu, LD was stretched so I only saw the top left corner. While the game was going through the FMV movie stuff before I started the new game, LD's screen fit perfectly. Once it got to gameplay, it stretched so I missed the right 1/3 of the screen. I then immediately entered and exited LD a few times for no good reason and that caused LD to freeze when I selected return to game.
EDIT: Nevermind, the LD screen sizing seems to be random.
MORE EDIT: Not bug free. I guess the majority of the screen text related stuff while playing is missing. The game also stopped again when I exited LD while playing. When I entered and exited LD during a FMV all sound for the movie was gone.

God Of War 2 = I went into LD about the instant the SCEA screen appeared, and got the endless safe guard loop with no escape. The 2nd time I waited for it to get to the start menu and everything seemed fine until it didn't exit LD when I selected return to game. The 3rd time it seems to perfectly be able to go in and out of LD without causing any problems. In-game a bunch of text related stuff is missing, but not as badly as in the first game. The game seems to randomly come back from LD. Weird. It's probably the same way for the first one too.

Guilty Gear XX Accent Core Plus = Aside from the very top of the screen having graphical problems, it seems to be perfect. That effect is there whether you are in LD or not.

Hitman: Blood Money = Pressing L3 + R3 instantly froze the game and butchered its graphics at the start menu and in game.

Metal Arms: Glitch In The System = Perfect, no lag and no stretched LD.

Neopet's The Darkest Faerie = Seems to be perfect other than the stretched LD menu.

Okami = Either it doesn't start, or it has mega lag that fooled me into thinking it wasn't working. Same way for LD3.0.3. too.

Onimusha Blade Warriors = Messed up graphics, giant top left corner of LD, and seems to be lagging a bit. Works though.

Peter Jackson's King Kong = Perfect.

Ratchet: Deadlocked = It seemed to work outside of gameplay with a little lag. The game stopped at a loading screen to the actual gameplay. Tried again, and it made it past. Seemed to work perfect, but Ratchet has no skin.

Ratchet & Clank: Size Matters = I could use LD until I got to the actual game. From there, the buttons stopped responding quickly once I entered LD and I was stuck.

[bungholio]

I'm kind of working on the cheat code stuff for code types. It's definitely not done, but "3" and "4" are done. I'm debating on whether to add a check to the constant write 2 & 4 bytes codes. I should put in an OR command to OR 2 byte write codes addresses to "01FFFFFE" and the 4 byte writes would get "01FFFFFC" to align the addresses.

I know you have a current 512 limit, but I'd like to somehow make it count how many lines a code uses and display a total count of how many lines of code are left. Most code types have different amounts of lines they take up.

This is my current mess:

Modified as of 11-13-10
1 /*
2 CodeDesigner v2.0
3 Created by: Gtlcpimp
4 Official CheatersLounge Product Copyright
5 */
6 /*
7 CL-LiveDebug v3 Cheat Engine v0.1a
8 Created by: Gtlcpimp
9 CheatersLounge Copyright
10 */
11
12 address $0007F800
13
14
15 //================================================== ========
16 _CheatEngineMain:
17
18 addiu sp, sp, $FF00
19 sq ra, $0000(sp)
20 sq s0, $0010(sp)
21 sq s1, $0020(sp)
22 sq s2, $0030(sp)
23 sq s3, $0040(sp)
24 sq s4, $0050(sp)
25 sq s5, $0060(sp)
26 sq s6, $0070(sp)
27 sq s7, $0080(sp)
28
29 lui s0, $8004
30 ori s0, s0, $7810
31 lui s1, $8004 //addiu s1, zero, 512
ori s1, s1, $8000
32
33 _CheatEngineMainLoop:
34 beq s0, s1, :CheatEngineExit //beq s1, zero, :_CheatEngineExit
35 nop
36
37 lb v0, $0000(s0)
38 beq v0, zero, :_CheatEngineExit
39 nop
40
41 lb v0, $001C(s0)
42 addiu v1, zero, 1
43 bne v0, v1, 3
44 nop
45 jal :_WriteCode
46 addu a0, s0, zero
47
48
49 addiu s0, s0, $0020
50 addiu s1, s1, -1
51 beq zero, zero, :_CheatEngineMainLoop
52 nop
53
54 _CheatEngineExit:
55 lq ra, $0000(sp)
56 lq s0, $0010(sp)
57 lq s1, $0020(sp)
58 lq s2, $0030(sp)
59 lq s3, $0040(sp)
60 lq s4, $0050(sp)
61 lq s5, $0060(sp)
62 lq s6, $0070(sp)
63 lq s7, $0080(sp)
64 jr ra
65 addiu sp, sp, $0100
66
67 //================================================== ========
68 _WriteCode:
69 addiu sp, sp, $FF00
70 sq ra, $0000(sp)
71 sq s0, $0010(sp)
72 sq s1, $0020(sp)
73 sq s2, $0030(sp)
74 sq s3, $0040(sp)
75 sq s4, $0050(sp)
76 sq s5, $0060(sp)
77 sq s6, $0070(sp)
78 sq s7, $0080(sp)
79
80 addu s0, a0, zero
81
82 lw s1, $0010(s0) // Address
83 lw s2, $0014(s0) // Data ON
84
85 srl a0, s1, 25 // a0 = Main Code Type //// a0 = Command
86 sll v0, a0, 25
87 subu s1, s1, v0
88 srl a0, v0, 28 //srl a0, v0, 24
sll a0, a0, 4
sll a1, v0, 4 // a1 = Extra Code Type Data Bits
srl a1, a1, 28
sll s1, s1, 7
srl s1, s1, 7
89
90 beq a0, zero, :_WC_0_Bits
91 //nop
92
93 addiu v0, zero, $0010
94 beq a0, v0, :_WC_16_Bits
95 //nop
96
97 addiu v0, zero, $0020
98 beq a0, v0, :_WC_32_Bits
99 nop
100
addiu v0, zero, $0030
beq a0, v0, :_WC_48_Bits
nop

addiu v0, zero, $0040
beq a0, v0, :_WC_64_Bits
nop

addiu v0, zero, $0050
beq a0, v0, :_WC_80_Bits
nop

addiu v0, zero, $0060
beq a0, v0, :_WC_96_Bits
nop

addiu v0, zero, $0070
beq a0, v0, :_WC_112_Bits
nop

addiu v0, zero, $00D0
beq a0, v0, :_WC_208_Bits
nop

addiu v0, zero, $00E0
beq a0, v0, :_WC_224_Bits
nop

101 beq zero, zero, :_WC_Exit
102 nop
103
104
105 //-----------------------------------
106 _WC_0_Bits:
107
108 //sb s2, $0000(s1)
109
110 beq zero, zero, :_WC_Exit
111 sb s2, $0000(s1) //nop
112
113 //-----------------------------------
114 _WC_16_Bits:
115
116 //sh s2, $0000(s1)
117
118 beq zero, zero, :_WC_Exit
119 sh s2, $0000(s1) //nop
120 //-----------------------------------
121 _WC_32_Bits:
122
123 //sw s2, $0000(s1)
124
125 beq zero, zero, :_WC_Exit
126 sw s2, $0000(s1) //nop
127
120 //-----------------------------------
121 _WC_48_Bits:
122
bne zero, a1, :_WC_48_Bits_0_Extra_Bits //1-byte subtraction
addiu a2, zero, $0002
bne a2, a1, :_WC_48_Bits_2_Extra_Bits //1-byte addition
addiu a2, zero, $0004
bne a2, a1, :_WC_48_Bits_4_Extra_Bits //2-byte subtraction
addiu a2, zero, $0006
bne a2, a1, :_WC_48_Bits_6_Extra_Bits //2-byte addition
addiu a2, zero, $0008
bne a2, a1, :_WC_48_Bits_8_Extra_Bits //4-byte subtraction
addiu a2, zero, $000A
bne a2, a1, :_WC_48_Bits_A_Extra_Bits //4-byte addition
lwc1 $f0, $0014(s0) // The next types are float calculations.
addiu a2, zero, $000C
bne a2, a1, :_WC_48_Bits_C_Extra_Bits //float addition & subtraction
nop

125 beq zero, zero, :_WC_Exit
nop
127
120 //-----------------------------------
121 _WC_48_Bits_0_Extra_Bits:
122
//This constantly subtracts 1 byte from the address's current value.
lb a2, $0000(s1)
subu s2, s2, a2
beq zero, zero, :_WC_Exit
sb s2, $0000(s1)

/*Example
3042dac4 00000007
This would constantly subtract "07" from whatever is at address 0042dac4.

31f2b448 00000014
This would constantly subtract "14" from whatever is at address 01f2b448.
*/

120 //-----------------------------------
121 _WC_48_Bits_2_Extra_Bits:
122
//This constantly adds 1 byte to the address's current value.
lb a2, $0000(s1)
addu s2, s2, a2
beq zero, zero, :_WC_Exit
sb s2, $0000(s1)

120 //-----------------------------------
121 _WC_48_Bits_4_Extra_Bits:
122
//This constantly subtracts 2 bytes from the address's current value.
lh a2, $0000(s1)
subu s2, s2, a2
beq zero, zero, :_WC_Exit
sh s2, $0000(s1)

120 //-----------------------------------
121 _WC_48_Bits_6_Extra_Bits:
122
//This constantly adds 2 bytes to the address's current value.

lh a2, $0000(s1)
addu s2, s2, a2
beq zero, zero, :_WC_Exit
sh s2, $0000(s1)

120 //-----------------------------------
121 _WC_48_Bits_8_Extra_Bits:
122
//This constantly subtracts 4 bytes from the address's current value.
lw a2, $0000(s1)
subu s2, s2, a2
beq zero, zero, :_WC_Exit
sw s2, $0000(s1)

120 //-----------------------------------
121 _WC_48_Bits_A_Extra_Bits:
122
//This constantly adds 4 bytes to the address's current value.
lw a2, $0000(s1)
addu s2, s2, a2
beq zero, zero, :_WC_Exit
sw s2, $0000(s1)

120 //-----------------------------------
121 _WC_48_Bits_C_Extra_Bits:
122
//This constantly adds the supplied 4-byte float to the address's current float value.
lwc1 $f1, $0000(s1)
add.s $f0, $f0, $f1
beq zero, zero, :_WC_Exit
swc1 $f0, $0000(s1)

/*Example
3c69abc4 40000000
This would constantly add "2" to the float at address 0069abc4.

3d69abc4 bf800000
This would constantly add "-1" to the float at address 0169abc4. It's the same as subtraction.
*/

120 //-----------------------------------
121 _WC_64_Bits:
122
lw s3, $0018(s0) //Value 1
lw s4, $001c(s0) //Value 2
srl s5, s2, 16 //The ????0000 part. It determines how many addresses to write to.
beql 0, s5, 1
ori s5, 0, $0001 //This way it's always at least 1.
sll s6, s2, 16 //The 0000???? part. It determines how many addresses to skip to get to the next 1.
srl s6, s2, 14 //Multiplied by 4, and ready to go.
beql 0, s6, 1
ori s6, 0, $0001 //This way it's always at least 1.
addiu a3, zero, $0001 //For the counter part
beq 0, a1, :_WC_64_Bits_0_And 2_Extra_Bits //The normal one codebreaker has.
addiu a2, 0, $0002
beq a2, a1, :_WC_64_Bits_0_And 2_Extra_Bits //The normal one, except the increment is a decrement.
addiu a2, 0, $0004
beq a2, a1, :_WC_64_Bits_4_Extra_Bits //The normal one, except this increases/decreases floats.
addiu a2, 0, $0006
beq a2, a1, :_WC_64_Bits_6_Extra_Bits //This is used for constant ORs & ANDs.
addiu a2, 0, $0008
beq a2, a1, :_WC_64_Bits_8_Extra_Bits //This is used for XOR
nop

120 //-----------------------------------
121 _WC_64_Bits_0_And_2_Extra_Bits:
122
sw s3, $0000(s1)
bne a2, a1, :_WC_64_Bits_2_Extra_Bits_Loop
addu a2, zero, s1

120 //-----------------------------------
121 _WC_64_Bits_0_Extra_Bits_Loop:
122
beq a3, s5, :_WC_Exit
addiu a3, a3, $0001
addu a2, a2, s6
addu s3, s3, s4
beq zero, zero, :_WC_64_Bits_0_Extra_Bits_Loop
sw s3, $0000(a2)

120 //-----------------------------------
121 _WC_64_Bits_2_Extra_Bits_Loop:
122
beq a3, s5, :_WC_Exit
addiu a3, a3, $0001
addu a2, a2, s6
subu s3, s3, s4
beq zero, zero, :_WC_64_Bits_2_Extra_Bits_Loop
sw s3, $0000(a2)

120 //-----------------------------------
121 _WC_64_Bits_4_Extra_Bits:

addu a2, zero, s1
sw s3, $0000(a2)
lwc1 $f0, $0018(s0)
lwc1 $f1, $001c(s0)

120 //-----------------------------------
121 _WC_64_Bits_4_Extra_Bits_Loop:

beq a3, s5, :_WC_Exit
addiu a3, a3, $0001
addu a2, a2, s6
add.s $f0, $f0, $f1
beq zero, zero, :_WC_64_Bits_4_Extra_Bits_Loop
swc1 $f0, $0000(a2)

/*Example
447bb494 00030003
c0800000 3f800000

This is what happens:
c0800000 is the float for -4. 3f800000 is the float for 1.
007bb494 c0800000 (-4)
007bb4a0 c0400000 (-4 + 1 = -3)
007bb4ac c0000000 (-3 + 1 = -2)

456b9140 00030004
42c80000 c1000000

This is what happens:
42c80000 is float for 100. c1000000 is float for -8.
016b9140 42c80000 (100)
016b9150 42B80000 (100 + -8 = 92)
016b9160 42A80000 (92 + -8 = 84)
*/

120 //-----------------------------------
121 _WC_64_Bits_6_Extra_Bits:

122 lui s2, $FFFF
ori s2, s2, $FFFF
xor s4, s4, s2
addu a2, zero, s1

120 //-----------------------------------
121 _WC_64_Bits_6_Extra_Bits_Loop:
122
beq a3, s5, :_WC_Exit
addiu a3, a3, $0001
lw s2, $0000(s1)
or s2, s2, s3
and s2, s2, s4
sw s2, $0000(s1)
beq zero, zero, :_WC_64_Bits_6_Extra_Bits_Loop
addu a2, a2, s6

/*Example
447bb494 00030003
F0100078 010FFF09

It ORs "F0100078" with the current value at that address.
It ANDs "010FFF09" with the current value at that address.

Assume we have these values at those addresses:
007bb494 00000000
007bb4a0 FFFFFFFF
007bb4ac 09147fcd

This is what happens:
007bb494 F0100078
007bb4a0 FEF000F6
007bb4ac F81000FF

I have the AND part already XOR'd by FFFFFFFF, so you'll never need to type all F's to not AND things. Just type in the bits you don't want on to turn them off.
This is great to always turn some things on and always force some things off while not affecting bits you don't care about.
*/

120 //-----------------------------------
121 _WC_64_Bits_8_Extra_Bits:
122
beq a3, s5, :_WC_Exit
addiu a3, a3, $0001
lw s2, $0000(s1)
xor s2, s2, s3
sw s2, $0000(s1)
beq zero, zero, :_WC_64_Bits_8_Extra_Bits
addu a2, a2, s6

/*Example
447bb494 00030003
F0100078 010FFF09

It XORs "F0100078" with the current value at that address.
It doesn't use 010FFF09 for anything. Feel free to change it if you need to.

Assume we have these values at those addresses:
007bb494 00000000
007bb4a0 FFFFFFFF
007bb4ac 09147fcd

This is what happens:
007bb494 F0100078
007bb4a0 FEF000F6
007bb4ac F81000FF

After that, this:
007bb494 00000000
007bb4a0 FFFFFFFF
007bb4ac 09147fcd

XOR toggles things on and off constantly without controlling it. I'm not sure why anybody would ever really need this.
*/

128
129 _WC_Exit:
130 lq ra, $0000(sp)
131 lq s0, $0010(sp)
132 lq s1, $0020(sp)
133 lq s2, $0030(sp)
134 lq s3, $0040(sp)
135 lq s4, $0050(sp)
136 lq s5, $0060(sp)
137 lq s6, $0070(sp)
138 lq s7, $0080(sp)
139 jr ra
140 addiu sp, sp, $0100

[Gtlcpimp]

I'm kind of working on the cheat code stuff for code types. It's definitely not done, but "3" and "4" are done. I'm debating on whether to add a check to the constant write 2 & 4 bytes codes. I should put in an OR command to OR 2 byte write codes addresses to "01FFFFFE" and the 4 byte writes would get "01FFFFFC" to align the addresses.

I know you have a current 512 limit, but I'd like to somehow make it count how many lines a code uses and display a total count of how many lines of code are left. Most code types have different amounts of lines they take up.

You would have to add the command types to the cheat engine (easy task), modify the pre-loaded patch loader, and modify the codes menu display function on the debugger engine. Sorry I haven't been working on LDv3 lately, been "pimpin' out" my trucks audio set up so-to-speak... hehe...

[bungholio]

I've finished the "5" copy code type now.

120 //-----------------------------------
121 _WC_80_Bits:
122
lw s3, $0018(s0) //Where the data will be copied to.
lw s4, $001c(s0) //Extra value.
lb s5, $0000(s1) //Value being copied.
ori s6, zero, $0001 //My counter for s2.
beq a1, zero, :_WC_80_Bits_0_And_2_Extra_Bits //Normal, except the extra value is an increment.
ori a2, $0002
beq a1, a2, :_WC_80_Bits_0_And_2_Extra_Bits //Normal, except the extra value is a decrement.
ori a2, $0004
beq a1, a2, :_WC_80_Bits_4_Extra_Bits //Normal, except the extra value is a float increment.
ori a2, $0006
beq a1, a2, :_WC_80_Bits_6_Extra_Bits //Normal OR, extra value isn't used.
ori a2, $0008
beq a1, a2, :_WC_80_Bits_8_Extra_Bits //Normal AND, extra value isn't used.
nop
beq zero, zero, :_WC_Exit
nop

120 //-----------------------------------
121 _WC_80_Bits_0_And_2_Extra_Bits:
122
addu s5, s5, s4
bne a0, zero, :
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_0_Extra_Bits:
122
beq s2, s6, :_WC_Exit
addiu s6, s6, $0001
addiu s1, s1, $0001
addiu s3, s3, $0001
lb s5, $0000(s1)
addu s5, s5, s4
beq zero, zero, :_WC_80_Bits_0_Extra_Bits
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_2_Extra_Bits:
122
beq s2, s6, :_WC_Exit
addiu s6, s6, $0001
addiu s1, s1, $0001
addiu s3, s3, $0001
lb s5, $0000(s1)
subu s5, s5, s4
beq zero, zero, :_WC_80_Bits_2_Extra_Bits
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_4_Extra_Bits:
122
lwc1 $f0, $0000(s1)
lwc1 $f1, $001c(s0)
add.s $f0, $f0, $f1
swc1 $f0, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_4_Extra_Bits_Loop:
122
beq s2, s6, :_WC_Exit
addiu s6, s6, $0001
addiu s1, s1, $0004
addiu s3, s3, $0004
lwc1 $f0, $0000(s1)
add.s $f0, $f0, $f1
beq zero, zero, :_WC_80_Bits_4_Extra_Bits_Loop
swc1 $f0, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_6_Extra_Bits:
122
lb s7, $0000(s3)
or s5, s5, s7
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_6_Extra_Bits_Loop:
122
beq s2, s6, :_WC_Exit
addiu s6, s6, $0001
addiu s1, s1, $0001
addiu s3, s3, $0001
lb s5, $0000(s1)
lb s7, $0000(s3)
or s5, s5, s7
beq zero, zero, :_WC_80_Bits_6_Extra_Bits_Loop
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_8_Extra_Bits:
122

lb s5, $0000(s3)
lui at, $FFFF
ori at, at, $FFFF
xor s5, s5, at
and s5, s5, s7
sb s5, $0000(s3)

120 //-----------------------------------
121 _WC_80_Bits_8_Extra_Bits_Loop:
122
beq s2, s6, :_WC_Exit
addiu s6, s6, $0001
addiu s1, s1, $0001
addiu s3, s3, $0001
lb s7, $0000(s3)
xor s5, s5, at
and s5, s5, s4
beq zero, zero, :_WC_80_Bits_8_Extra_Bits_Loop
sb s5, $0000(s3)

I should also explain what I've done up to this point.
For "3".
"30" is a normal constant 1-byte subtraction code.
"32" is a normal constant 1-byte addition code.
"34" is a normal constant 2-byte subtraction code.
"36" is a normal constant 2-byte addition code.
"38" is a normal constant 4-byte subtraction code.
"3A" is a normal constant 4-byte addition code.
"3C" is a constant 4-byte float addition code.

For "4".
"40" is a normal multi-line 4-byte constant write code with an increment. It's identical to codebreaker's.
"42" is the same thing, but you have a decrement instead of an increment.
"44" is the same thing, but the increment is now a float increment. Floats can be negative, so it's also a decrement for floats.
"46" is interesting. Value 1 is OR'd with the current result. Value 2 (normally the increment) is the inverted form of AND. Just type which bits you don't want on, so you don't always need to fill in all F's to not AND something. This is like a controllable and useful version of XOR. You can turn some bits on all the time, force some to always stay off, and not affect ones you don't care about.
"48" is probably useless. Value 2 isn't used. It just XORs the results, so you have no control of it constantly toggling things on and off.

For "5".
"50" is just like it normally is for codebreaker, except the 4th line is an increment. I can't quite think of a use for the increment, but you could use it to always keep something a certain amount higher than another thing. Example: Mortal Kombat games. No matter what player 2's health is, you want player 1's health exactly +50 higher at all times. You get:
51f93b1c 00000004
007844cc 00000032
"52" same, but the increment is a decrement. You could use it backwards, instead making sure player 2's health is always 25 below your current health.
53f93b1c 00000004
007844cc 00000019
"54" same, but the increment is for floats. This is handled slightly differently to avoid an address alignment error. Other codes treat the 2nd line's value like the amount of bytes it wants to copy to. This one treats each 1 byte as 4 bytes instead. It's basically the same way the counter is with the normal "40" code.
"56" takes the value at the source address and ORs it with the value located at the destination.
"58" takes the value at the source address and ANDs it with the value located at the destination.

[Gtlcpimp]

You know.. You don't really need all those code types... It's just a debugger, used for finding codes .

If you really desire a lot of code type supporting you should really use a cheat device instead, just saying.

The cheat engine I wrote v1.3c (written in CodeDesignerv2) supports the following:

__ 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
__ 7 - 32 Bit Boolean
__ 8 - Find and Replace
__ 9 - Execute Data
__ A - (not implemented, supposed to be DNAS patch configuration)
__ B - (not implemented)
__ C - (not implemented)
__ D - Boolean: Half (Aka: Joker)
__ E - Line Specific Boolean: Half (Aka: Line Specific Joker)
__ F - Extended Command Structure
__ F0 - IOP 8 Bit Constant Write
__ F1 - IOP 16 Bit Constant Write
__ F2 - IOP 32 Bit Constant Write
__ F3 - (not implemented)
__ F4 - (not implemented)
__ F5 - (not implemented)
__ F6 - (not implemented)
__ F7 - (not implemented)
__ F8 - (not implemented)
__ F9 - (not implemented)
__ FA - (not implemented)
__ FB - (not implemented)
__ FC - (not implemented)
__ FD - (not implemented)
__ FE - (not implemented)
__ FF - (not implemented)

[Lazy Bastard]

A combined approach is optimal, in my opinion, assuming all functionality will 'fit' into the area(s) of memory you want to place it in.

It's always great to be able to test codes while hacking other codes, or even use codes to unlock functionality that will make other codes easier to hack...not to mention having both hackers and code users utilizing the same system means better testing and a better understanding of each others' efforts.

[bungholio]

I'm kind of close to done with what I wanted to mess with. Just "6", "7", and combine "D" & "E" so they are mostly equal. I'm trying to figure out a way to put the "6" code type in front of any code and that would provide the addresses for any other codetype.

I just like having the options for code types. They are things that I was hoping were made, but weren't ever.

[Lazy Bastard]

It's also worth looking at http://gshi.org/vb/threads/3155-Proj...Specifications

There are some really good ideas there, though many of them were never implemented (I should say, they're not yet implemented).

[bungholio]

__ 8 - Find and Replace
__ 9 - Execute Data

What are these? I often wrote little memory scanners for games to find and replace certain arrays of bytes, or find and replace things that are dynamically happening around me. Is it similar?

[Gtlcpimp]

It's also worth looking at http://gshi.org/vb/threads/3155-Proj...Specifications

There are some really good ideas there, though many of them were never implemented (I should say, they're not yet implemented).

Was skimming through the post, noticed you had a lot of ideas on different code types. My cheat engine v1.3c is very customizable, and supports a lot and can handle a lot. I could finish some of the code types in it, and set a third structure to support what you were saying, only it wouldn't be "00 address data" it would be the same "address data" type set up. Only would consume a few extra lines like large commands (such as copy bytes - 2 lines, 32 bit inc/dec - 2 lines, etc.). The way 1.3c engine is designed, is to allow full code potential. Take a large chunk of data for example. Embed it inside the code list itself to use it for large data patching, function to execute (to keep from having to keep track of user space memory when storing functions), anything you'd want it for. Also in the original designs, it is to allow code type customization. So you can use a code to declare a code type, and use that same prefix code type with arguments and the suffix of your custom defined code type to run a code type you want to define. However the 1.3c engine isn't fully completed (obviously). Part of it's original design is to have a really large code list without lagging your game at all, and this works perfectly if you use the Boolean commands properly. The engine operates what I refer to as "chunk and point". A block of code is chunked out to it's own little chunk. All Boolean handled code blocks are chunked out (except the inline Boolean 0xE). So when manipulating the Boolean commands properly, you can have (example) 5,000 lines word of a code list (assuming you use a Boolean command to 'joker' everything) jokered down to 50 jokers, and instead of the conventional cheat engine where it would flow through 5,000 lines the engine will only flow through 50 lines. If you don't 'joker' anything at all of course expect the same lag as the conventional cheat engine, however when being smart you can have a really large code list set up without lagging the game.

What are these? I often wrote little memory scanners for games to find and replace certain arrays of bytes, or find and replace things that are dynamically happening around me. Is it similar?

0x8 Command "Find and Replace" does exactly what it's called, finds a value and replaces the value. You give it an 8, 16, or 32 bit value, a start position and a memory size to scan, and it will scan the specified memory block and replace anything it finds with the value you tell it to replace with. The search size is basically how many times it increments the address rather than an actual memory size. Another words, if you are doing an 8 bit search and you set your size to 4, it will only scan 4 bytes (obvious). If you do 16 bit search same size, it will scan 4 halves (8 bytes), 32 bit search same size it will scan 4 words (16 bytes).

-------------------------------------
-- Find and Replace --

8 Bit Search
8aaaaaaa 000000ff
000000rr 0000iiii

16 Bit Search
8aaaaaaa 0000ffff
0000rrrr 0010iiii

32 Bit Search
8aaaaaaa ffffffff
rrrrrrrr 0020iiii

a = Address to start
f = Data to find
r = Data to replace with
i = Search count

Description:
Searches for the first data, and replaces any matches with the second data. The search count is to limit how much it will search.

The 0x9 command "Execute Data" basically removes all need for a hook for a function you write. It calls a function that Jumps and Links to the address you give it, and provides the 32 bit argument you specify in the "data" side of the code in register 'a0'.

[bungholio]

Went through 35 more games.

007 Nightfire = Trapped in the safeguard loop both times I tried.

Burnout 4: Revenge = Game wouldn't start after 3 tries. With LD3.0.3, it was mostly perfect until I got trapped in the safeguard loop while racing.

Destroy All Humans! = Tried twice, the game won't start. With LD3.0.3, it's identical to the second game. It still technically works.

Deus Ex: The Conspiracy = Game wouldn't start after 3 tries. LD3.0.3 lots of missing text, and lots of messed up graphics. Otherwise, it works.

Devil May Cry 3: Special Edition = Game wouldn't start, tried 2 times. LD3.0.3 managed to get to the first intro screen before the game stopped, LD worked, and it's menu was the giant top left corner.

Family Guy = Perfect.

Final Fantasy 7: Dirge Of Cerberus = Lots of garbled text, but it seemed to be working otherwise.

Katamari Damacy = Seemed perfect, but L3 + R3 didn't enter LD.

The Matrix: Path Of Neo = My copy is too scratched to even play, but it was working up to a few loading screens before the game could no longer load anything.

Max Payne = All intro movies are lagging. Entering LD at the main menu messed up the background's graphics. Game graphics are garbeled. Game stopped taking button input in LD while I was watching one of the comic strip style movies.

Max Payne 2: The Fall Of Max Payne = Game stops loading before main menu. There's a chance that could be mega lag too.

Maximo Vs. Army Of Zin = LD menu very stretched, you just see the top left corner. Exiting LD messed with some graphics. Some garbled start menu graphics. Didn't seem to be any lag, so the game seems to work.

Men In Black 2: Alien Escape = When I select "Launch Game Disk", LD freezes. Did that 3 times. Seemed to partially work with LD3.0.3, because I got past a few loading screens before the game seemed to just freeze while loading. LD's screen was mega big with a stretched chunk of the top left corner.

Mercenaries = Couldn't get past the game's Lucas Arts logo. Entered LD, but it froze when I exited it.

Motocross Mania 3 = Graphics garbled and game instantly froze from it at the main menu.

Neopet's The Darkest Faerie = Seems to be perfect other than the stretched LD menu.

Onimusha Blade Warriors = Messed up graphics, giant top left corner of LD, and seems to be lagging a bit. Works though.

Onimusha 2: Samurai's Destiny = Game froze just as that little story intro went by on a new game.

Peter Jackson's King Kong = Perfect.

Powerdrome = Game wouldn't start after 3 tries. With LD3.0.3, it was perfect.

Prince Of Persia: The Snds Of Time = It was perfect until it got to the Prince Of Persia Copyright screen. I went into LD, it was perfect, but the game froze after I left. Same with LD3.0.3.

Ratchet & Clank = Entering LD anywhere other than gameplay garbles graphics. It seemed to be working, but there's a crumb of lag and the game froze about 10 seconds into it for no apparent reason.

Ratchet & Clank 2: Going Commando = Game wouldn't start, I tried twice. It's the same as #3 if I use LD3.0.3.

Ratchet & Clank 3: Up Your Arsenal = Movies lag, causing sound sync problems. I got to the main game and it froze the instant I tried to enter LD.

Red Faction 1 = After 3 tries, the game won't start. With LD3.0.3, it works perfectly.

Scooby-Doo! Night Of 100 Frights = Lagging a bit on all of the intro video stuff (THQ, Renderware, WB logo, that sort of stuff). Game stopped loading on a new game so I couldn't get to actual gameplay the first time. That might have been due to me entering the debugger during the loading screen. There appears to be no lag affecting gameplay or gameplay movies. It also randomly doesn't go into LD and loops the safeguard a few times, but it works. Aside from that small crumb of lag that doesn't matter, it's perfect. Not even a stretched LD screen.

Silent Hill 4: The Room = The game never goes past the loading saved data screen. It did that twice. Same with LD3.0.3. It seems the game didn't find the joker. I could skip through intro stuff faster by pressing X, but I couldn't activate LD.

Silent Hill Origins = This is almost perfect. No lag, LD3.0.4 works perfectly. Then I went to activate a cutscene. The game didn't freeze, it just didn't do it. My character is trapped in animation where he would have normally activated a cutscene, but the other stuff is still going on.

Sly 3: Honor Among Thieves = When I returned to the game from the start menu, the graphics instantly got chopped up and placed in wrong sections of the screen, and the game froze. Gameplay seemed to work, even though a bunch of level graphics disappeared. LD was the giant top left corner of the screen.

Splinter Cell: Pandora Tomorrow = Game wouldn't start. With LD3.0.3, it's messed up in the esame exact way as both Destroy All Humans games. The controls stopped responding when I entered LD during gameplay. Tried again with LD3.0.4, and now it works. It's the same as LD3.0.3 though.

Star Wars Battlefront 2 GH = It seemed to be perfect, then the game froze during gameplay. That could just be a game bug though considering how buggy the game already is for me.

Timesplitters: Future Perfect = Game wouldn't start, I tried 3 times. It worked perfectly with LD3.0.3, until LD stopped taking controller input or something, and the game was basically frozen.

Under The Skin = Aside from the stretched LD screen, it's perfect.

Viewtiful Joe = Game wouldn't start. With LD3.0.3, it seemed perfect until I realized L3 + R3 didn't enter LD.

We Love Katamari = L3 + R3 doesn't work.