Announcement

Collapse
No announcement yet.

CL Cheat Engine v1.3r03b Release

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • CL Cheat Engine v1.3r03b Release

    This is the Code Designer v2 source for my Cheat Engine v1.3r03b (for PS2 obviously). I stopped updating it (along with many projects) so hopefully someone who is interested can learn from it or add to it to make it better.

    Code:
    /*
      ==========================================================
     CheatersLounge CheatsEngine v1.3r03b Cheat Engine v2.1
     CodeDesigner v2.0 Source Copyright ©
     Created by Gtlcpimp
    
      ==========================================================
    */
    address $80078910
    //address $0107F010
    
    _init:
    addiu sp, sp, $FFF0
    sq ra, $0000(sp)
    jalr k0
    nop
    //call _debugGenerate
    call _start
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0010
    
    //==========================================================
    _start:
    addiu sp, sp, $FE00
    sq at, $0000(sp)
    sq v0, $0010(sp)
    sq v1, $0020(sp)
    sq a0, $0030(sp)
    sq a1, $0040(sp)
    sq a2, $0050(sp)
    sq a3, $0060(sp)
    sq t0, $0070(sp)
    sq t1, $0080(sp)
    sq t2, $0090(sp)
    sq t3, $00a0(sp)
    sq t4, $00b0(sp)
    sq t5, $00c0(sp)
    sq t6, $00d0(sp)
    sq t7, $00e0(sp)
    sq s0, $00f0(sp)
    sq s1, $0100(sp)
    sq s2, $0110(sp)
    sq s3, $0120(sp)
    sq s4, $0130(sp)
    sq s5, $0140(sp)
    sq s6, $0150(sp)
    sq s7, $0160(sp)
    sq t8, $0170(sp)
    sq t9, $0180(sp)
    sq k0, $0190(sp)
    sq k1, $01a0(sp)
    sq fp, $01b0(sp)
    sq gp, $01c0(sp)
    sq ra, $01d0(sp)
    
    lui v0, $8008
    lb v1, $8900(v0)
    bne v1, zero, 7
    nop
    addiu v1, zero, 1
    sb v1, $8900(v0)
    
    call _main
    
    lui v0, $8008
    sb zero, $8900(v0)
    
    
    lq at, $0000(sp)
    lq v0, $0010(sp)
    lq v1, $0020(sp)
    lq a0, $0030(sp)
    lq a1, $0040(sp)
    lq a2, $0050(sp)
    lq a3, $0060(sp)
    lq t0, $0070(sp)
    lq t1, $0080(sp)
    lq t2, $0090(sp)
    lq t3, $00a0(sp)
    lq t4, $00b0(sp)
    lq t5, $00c0(sp)
    lq t6, $00d0(sp)
    lq t7, $00e0(sp)
    lq s0, $00f0(sp)
    lq s1, $0100(sp)
    lq s2, $0110(sp)
    lq s3, $0120(sp)
    lq s4, $0130(sp)
    lq s5, $0140(sp)
    lq s6, $0150(sp)
    lq s7, $0160(sp)
    lq t8, $0170(sp)
    lq t9, $0180(sp)
    lq k0, $0190(sp)
    lq k1, $01a0(sp)
    lq fp, $01b0(sp)
    lq gp, $01c0(sp)
    lq ra, $01d0(sp)
    jr ra
    addiu sp, sp, $0200
    
    
    //==========================================================
    _main:
    
    addiu sp, sp, $FFF0
    sq ra, $0000(sp)
    
    //lui s0, $0108
    lui s0, $8008
    addiu s0, s0, $8250
    
    _mainLoop:
    
    
    lw a0, $0000(s0)
    bne a0, zero, 3
    nop
    goto _mainQuit
    
    
    /*
    Chunk Style
    
    00000000
    
    TTWWAAAA
    
    T: Type
       00 Normal Code
       01 Embeded Data -------------> Not Implemented Yet
       02 Embeded Routine ----------> Not Implemented Yet
    W: Write
       00 Normal Code Write
       01 Embeded Data Write -------> Not Implemented Yet
       02 Embeded Routine No Write -> Not Implemented Yet
    A: Address on stack
    
    */
    
    
    lh a0, $0000(s0)
    addiu a0, a0, -1
    
    sll a0, a0, 2
    
    //lui v0, $0103
    lui v0, $8003
    addu a0, v0, a0
    
    call _processChunk
    
    addiu s0, s0, 4
    goto _mainLoop
    nop
    
    _mainQuit:
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0010
    
    
    //==========================================================
    _processChunk:
    
    addiu sp, sp, $FFE0
    sq ra, $0000(sp)
    sq s0, $0010(sp)
    
    addu s0, a0, zero
    
    _processChunkLoop:
    
    lw v0, $0000(s0)
    bne v0, zero, 3
    nop
    goto _processChunkQuit
    
    daddu a2, s0, zero
    srl a0, v0, 28
    srl a1, v0, 24
    call _writeCode
    
    
    addiu a0, zero, -1
    bne a0, v0, 3
    nop
    goto _processChunkQuit
    
    addu s0, s0, v0
    goto _processChunkLoop
    
    
    
    _processChunkQuit:
    lq s0, $0010(sp)
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0020
    
    
    //==========================================================
    _handleBoolean:
    
    // a0 = List Pointer
    
    addiu sp, sp, $FFF0
    sq ra, $0000(sp)
    
    lw v1, $0000(a0)
    
    srl a1, v1, 28
    
    addiu v1, zero, $0007
    bne a1, v1, 3
    nop
    goto _hb_7
    
    addiu v1, zero, $000D
    bne a1, v1, 3
    nop
    goto _hb_D
    
    addiu v1, zero, $000E
    bne a1, v1, 3
    nop
    goto _hb_E
    
    lb v1, $0003(a0)
    addiu v1, zero, $00FD
    bne v0, v1, 3
    nop
    goto _hb_FD
    
    
    addiu v0, zero, -1
    goto _handleBooleanQuit
    
    // ---------------------------
    _hb_7:
    
    lw v0, $0000(a0)
    sll v1, v1, 28
    subu v0, v0, v1
    
    lw a1, $0000(v0)
    lw v1, $0004(a0)
    bne a1, v1, 4
    nop
    addiu v0, zero, 8
    goto _handleBooleanQuit
    
    addiu v0, zero, -1
    goto _handleBooleanQuit
    
    // ---------------------------
    _hb_D:
    
    lw v0, $0000(a0)
    sll v1, a1, 28
    subu v0, v0, v1
    lh a1, $0000(v0)
    
    lb v1, $0006(a0)
    beq v1, zero, 10
    nop
    lh v1, $0004(a0)
    beq a1, v1, 4
    nop
    addiu v0, zero, 8
    goto _handleBooleanQuit
    addiu v0, zero, -1
    goto _handleBooleanQuit
    
    lh v1, $0004(a0)
    bne a1, v1, 4
    nop
    addiu v0, zero, 8
    goto _handleBooleanQuit
    addiu v0, zero, -1
    goto _handleBooleanQuit
    
    // ---------------------------
    _hb_E:
    
    lw v0, $0000(a0)
    lh t0, $0004(a0)
    sll v1, a1, 28
    subu v0, v0, v1
    lh t2, $0006(a0)
    srl t1, t2, 4
    sll t1, t1, 4
    subu t2, t2, t1
    srl t1, t1, 8
    sll t1, t1, 3
    addiu t1, t1, 8
    
    lh t3, $0000(v0)
    
    beq t2, zero, 4
    nop
    addiu t4, zero, 1
    beq t2, t4, 9
    nop
    
    bne t3, t0, 4
    nop
    addiu v0, zero, 8
    goto _handleBooleanQuit
    addu v0, t1, zero
    goto _handleBooleanQuit
    
    beq t3, t0, 4
    nop
    addiu v0, zero, 8
    goto _handleBooleanQuit
    addu v0, t1, zero
    goto _handleBooleanQuit
    
    // ---------------------------
    _hb_FD:
    
    
    
    addiu v0, zero, -1
    goto _handleBooleanQuit
    
    
    _handleBooleanQuit:
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0010
    
    
    
    
    //==========================================================
    _writeCode:
    
    
    addiu sp, sp, $FFF0
    sq ra, $0000(sp)
    
    
    // a0 = 8 Bit command (0xD)
    // a1 = 16 Bit command (0xFD)
    // a2 = List Pointer
    // v0 = Size return
    
    addu v0, zero, zero
    
    
    // ---------------------------
    addiu v1, zero, $0000
    bne v1, a0, 3
    nop
    goto _cw_8
    
    // ---------------------------
    addiu v1, zero, $0001
    bne v1, a0, 3
    nop
    goto _cw_16
    
    // ---------------------------
    addiu v1, zero, $0002
    bne v1, a0, 3
    nop
    goto _cw_32
    
    // ---------------------------
    addiu v1, zero, $0003
    bne v1, a0, 3
    nop
    goto _cw_inc_dec
    
    // ---------------------------
    addiu v1, zero, $0004
    bne v1, a0, 3
    nop
    goto _cw_maw_32
    
    // ---------------------------
    addiu v1, zero, $0005
    bne v1, a0, 3
    nop
    goto _cw_copy
    
    // ---------------------------
    addiu v1, zero, $0006
    bne v1, a0, 3
    nop
    goto _cw_pointer
    
    // ---------------------------
    addiu v1, zero, $0007
    bne v1, a0, 6
    nop
    addu a0, a2, zero
    call _handleBoolean
    goto _cw_exit
    
    // ---------------------------
    addiu v1, zero, $0008
    bne v1, a0, 3
    nop
    goto _cw_replace
    
    // ---------------------------
    addiu v1, zero, $0009
    bne v1, a0, 14
    nop
    lw a1, $0000(a2)
    srl a0, a1, 28
    sll a0, a0, 28
    subu a1, a1, a0
    lw v1, $0000(a1)
    lw a0, $0004(a2)
    beq v1, zero, 3
    nop
    call _execRoutine
    addiu v0, zero, 8
    goto _cw_exit
    
    // ---------------------------
    addiu v1, zero, $000A
    bne v1, a0, 3
    nop
    goto _cw_A
    
    // ---------------------------
    addiu v1, zero, $000B
    bne v1, a0, 3
    nop
    goto _cw_delay
    
    // ---------------------------
    addiu v1, zero, $000C
    bne v1, a0, 3
    nop
    goto _cw_stopper
    
    // ---------------------------
    addiu v1, zero, $000D
    bne v1, a0, 6
    nop
    daddu a0, a2, zero
    call _handleBoolean
    goto _cw_exit
    
    // ---------------------------
    addiu v1, zero, $000E
    bne v1, a0, 6
    nop
    daddu a0, a2, zero
    call _handleBoolean
    goto _cw_exit
    
    // ---------------------------
    addiu v1, zero, $000F
    bne v1, a0, 3
    nop
    goto _cw_extended
    
    
    addiu v0, zero, -1
    goto _cw_exit
    
    _cw_extended:
    
    // ---------------------------
    addiu v1, zero, $00F0
    bne v1, a1, 3
    nop
    goto _cw_iop_8
    
    // ---------------------------
    addiu v1, zero, $00F1
    bne v1, a1, 3
    nop
    goto _cw_iop_16
    
    // ---------------------------
    addiu v1, zero, $00F2
    bne v1, a1, 3
    nop
    goto _cw_iop_32
    
    
    addiu v0, zero, -1
    goto _cw_exit
    
    // ---------------------------
    _cw_8:
    lw t0, $0000(a2)
    lb t1, $0004(a2)
    lui v0, $2000
    addu t0, t0, v0
    sb t1, $0000(t0)
    addiu v0, zero, 8
    goto _cw_exit
    
    // ---------------------------
    _cw_16:
    sll t2, a0, 28
    lw t0, $0000(a2)
    subu t0, t0, t2
    lh t1, $0004(a2)
    lui v0, $2000
    addu t0, t0, v0
    sh t1, $0000(t0)
    addiu v0, zero, 8
    goto _cw_exit
    
    // ---------------------------
    _cw_32:
    sll t2, a0, 28
    lw t0, $0000(a2)
    subu t0, t0, t2
    lw t1, $0004(a2)
    lui v0, $2000
    addu t0, t0, v0
    sw t1, $0000(t0)
    addiu v0, zero, 8
    goto _cw_exit
    
    // ---------------------------
    _cw_inc_dec:
    
    lw t0, $0004(a2)
    lb t1, $0002(a2)
    
    bne t1, zero, 3
    nop
    goto _cw_inc_dec_0
    
    addiu v1, zero, $0010
    bne t1, v1, 3
    nop
    goto _cw_inc_dec_1
    
    addiu v1, zero, $0020
    bne t1, v1, 3
    nop
    goto _cw_inc_dec_2
    
    addiu v1, zero, $0030
    bne t1, v1, 3
    nop
    goto _cw_inc_dec_3
    
    addiu v1, zero, $0040
    bne t1, v1, 3
    nop
    goto _cw_inc_dec_4
    
    addiu v1, zero, $0050
    bne t1, v1, 3
    nop
    goto _cw_inc_dec_5
    
    addiu v0, zero, -1
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_0:
    
    lb t1, $0000(t0)
    lb t2, $0000(a2)
    addu t1, t1, t2
    sb t1, $0000(t0)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_1:
    
    lb t1, $0000(t0)
    lb t2, $0000(a2)
    subu t1, t1, t2
    sb t1, $0000(t0)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_2:
    
    lh t1, $0000(t0)
    lh t2, $0000(a2)
    addu t1, t1, t2
    sh t1, $0000(t0)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_3:
    
    lh t1, $0000(t0)
    lh t2, $0000(a2)
    subu t1, t1, t2
    sh t1, $0000(t0)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_4:
    
    lw t1, $0000(t0)
    lw t2, $0008(a2)
    addu t1, t1, t2
    sw t1, $0000(t0)
    
    addiu v0, zero, 16
    goto _cw_exit
    
    // -------------------
    _cw_inc_dec_5:
    
    lw t1, $0000(t0)
    lw t2, $0008(a2)
    subu t1, t1, t2
    sw t1, $0000(t0)
    
    addiu v0, zero, 16
    goto _cw_exit
    
    // ---------------------------
    _cw_maw_32:
    
    lw t0, $0000(a2)
    sll t2, a0, 28
    subu t0, t0, t2
    lh t1, $0004(a2)
    lh t2, $0006(a2)
    lw t3, $0008(a2)
    lw t4, $000C(a2)
    
    sll t1, t1, 2
    
    _cw_maw_32_loop:
    
    bne t2, zero, 3
    nop
    goto _cw_maw_32_exit
    
    sw t3, $0000(t0)
    
    addu t3, t3, t4
    addiu t0, t0, 4
    addu t0, t0, t1
    addiu t2, t2, -1
    goto _cw_maw_32_loop
    
    _cw_maw_32_exit:
    addiu v0, zero, 16
    goto _cw_exit
    
    // ---------------------------
    _cw_copy:
    
    lw t0, $0000(a2)
    sll t1, a0, 28
    subu t0, t0, t1
    lw t1, $0008(a2)
    lw t2, $0004(a2)
    
    _cw_copy_loop:
    bne t2, zero, 3
    nop
    goto _cw_copy_exit
    
    
    lb t3, $0000(t0)
    sb t3, $0000(t1)
    
    addiu t0, t0, 1
    addiu t1, t1, 1
    addiu t2, t2, -1
    goto _cw_copy_loop
    
    _cw_copy_exit:
    addiu v0, zero, 16
    goto _cw_exit
    
    // ---------------------------
    _cw_pointer:
    addu v0, zero, zero
    addu v1, a2, zero
    addu t8, zero, zero
    
    lw t0, $0000(a2)
    sll t1, a0, 28
    subu t0, t0, t1
    lw t1, $0004(a2)
    
    lw t0, $0000(t0)
    
    addiu v0, v0, 8
    addiu v1, v1, 8
    
    _cw_pointer_loop:
    
    addiu t5, zero, -1
    bne t1, t5, 3
    nop
    goto _cw_pointer_exit
    
    lb t3, $0003(v1)
    
    addiu t4, zero, $0006
    bne t3, t4, 3
    nop
    goto _cw_pointer_point
    
    addiu t4, zero, $0001
    bne t3, t4, 3
    nop
    goto _cw_pointer_write_0
    
    addiu t4, zero, $0002
    bne t3, t4, 3
    nop
    goto _cw_pointer_write_1
    
    addiu t4, zero, $0003
    bne t3, t4, 3
    nop
    goto _cw_pointer_write_2
    
    addiu v0, zero, -1
    goto _cw_pointer_exit
    
    // -------------------
    _cw_pointer_point:
    
    lh t4, $0000(v1)
    sll t4, t4, 2
    addu t0, t0, t4
    lw t0, $0000(t0)
    
    goto _cw_pointer_skip
    
    // -------------------
    _cw_pointer_write_0:
    
    lh t4, $0000(v1)
    addu t0, t0, t4
    lb t2, $0004(v1)
    sb t2, $0000(t0)
    
    goto _cw_pointer_skip
    
    // -------------------
    _cw_pointer_write_1:
    
    lh t4, $0000(v1)
    sll t4, t4, 1
    addu t0, t0, t4
    lh t2, $0004(v1)
    sh t2, $0000(t0)
    
    
    goto _cw_pointer_skip
    
    // -------------------
    _cw_pointer_write_2:
    
    lh t4, $0000(v1)
    sll t4, t4, 2
    addu t0, t0, t4
    lw t2, $0004(v1)
    sw t2, $0000(t0)
    
    goto _cw_pointer_skip
    
    
    _cw_pointer_skip:
    
    addiu t5, zero, 1
    subu t8, t5, t8
    
    addiu v0, v0, 4
    addiu v1, v1, 4
    addiu t1, t1, -1
    goto _cw_pointer_loop
    
    
    _cw_pointer_exit:
    bne t8, zero, 2
    nop
    addiu v0, v0, 4
    addiu v0, v0, 4
    goto _cw_exit
    
    // ---------------------------
    _cw_replace:
    
    lw t0, $0000(a2)
    sll t1, a0, 28
    subu t0, t0, t1
    lh t3, $000C(a2)
    lb t4, $000E(a2)
    
    bne t4, zero, 3
    nop
    goto _cw_replace_0
    
    addiu t1, zero, $0010
    bne t4, t1, 3
    nop
    goto _cw_replace_1
    
    addiu t1, zero, $0020
    bne t4, t1, 3
    nop
    goto _cw_replace_2
    
    addiu v0, zero, -1
    goto _cw_exit
    
    // -------------------
    _cw_replace_0:
    lb t1, $0004(a2)
    lb t2, $0008(a2)
    
    _cw_replace_0_loop:
    
    bne t3, zero, 3
    nop
    goto _cw_replace_exit
    
    lb v1, $0000(t0)
    bne t1, v1, 2
    nop
    sb t2, $0000(t0)
    
    addiu t0, t0, 1
    addiu t3, t3, -1
    goto _cw_replace_0_loop
    
    // -------------------
    _cw_replace_1:
    lh t1, $0004(a2)
    lh t2, $0008(a2)
    sll t3, t3, 1
    
    _cw_replace_1_loop:
    
    bne t3, zero, 3
    nop
    goto _cw_replace_exit
    
    lh v1, $0000(t0)
    bne t1, v1, 2
    nop
    sh t2, $0000(t0)
    
    addiu t0, t0, 2
    addiu t3, t3, -2
    goto _cw_replace_1_loop
    
    // -------------------
    _cw_replace_2:
    lw t1, $0004(a2)
    lw t2, $0008(a2)
    sll t3, t3, 2
    
    _cw_replace_2_loop:
    
    bne t3, zero, 3
    nop
    goto _cw_replace_exit
    
    lw v1, $0000(t0)
    bne t1, v1, 2
    nop
    sw t2, $0000(t0)
    
    addiu t0, t0, 4
    addiu t3, t3, -4
    goto _cw_replace_2_loop
    
    _cw_replace_exit:
    addiu v0, zero, 16
    goto _cw_exit
    
    // ---------------------------
    /* Used to be DNAS Patch
       command, but was removed
       since manual IOP writes
       were easier to use.
    */
    _cw_A:
    
    
    _cw_A_exit:
    
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0010
    
    
    // ---------------------------
    _cw_delay:
    addu v0, zero, zero
    goto _cw_exit
    
    // ---------------------------
    _cw_stopper:
    
    
    addu v0, zero, zero
    goto _cw_exit
    
    // ---------------------------
    _cw_iop_8:
    
    lw t0, $0000(a2)
    sll t1, a1, 24
    subu t0, t0, t1
    lui t1, $BC00
    addu t1, t1, t0
    
    lb t2, $0004(a2)
    sb t2, $0000(t1)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    
    // ---------------------------
    _cw_iop_16:
    
    lw t0, $0000(a2)
    sll t1, a1, 24
    subu t0, t0, t1
    lui t1, $BC00
    addu t1, t1, t0
    
    lh t2, $0004(a2)
    sh t2, $0000(t1)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    
    // ---------------------------
    _cw_iop_32:
    
    lw t0, $0000(a2)
    sll t1, a1, 24
    subu t0, t0, t1
    lui t1, $BC00
    addu t1, t1, t0
    
    lw t2, $0004(a2)
    sw t2, $0000(t1)
    
    addiu v0, zero, 8
    goto _cw_exit
    
    
    _cw_exit:
    lq ra, $0000(sp)
    jr ra
    addiu sp, sp, $0010
    
    //==========================================================
    _execRoutine:
    
    addiu sp, sp, $FE00
    sq at, $0000(sp)
    sq v0, $0010(sp)
    sq v1, $0020(sp)
    sq a0, $0030(sp)
    sq a1, $0040(sp)
    sq a2, $0050(sp)
    sq a3, $0060(sp)
    sq t0, $0070(sp)
    sq t1, $0080(sp)
    sq t2, $0090(sp)
    sq t3, $00a0(sp)
    sq t4, $00b0(sp)
    sq t5, $00c0(sp)
    sq t6, $00d0(sp)
    sq t7, $00e0(sp)
    sq s0, $00f0(sp)
    sq s1, $0100(sp)
    sq s2, $0110(sp)
    sq s3, $0120(sp)
    sq s4, $0130(sp)
    sq s5, $0140(sp)
    sq s6, $0150(sp)
    sq s7, $0160(sp)
    sq t8, $0170(sp)
    sq t9, $0180(sp)
    sq k0, $0190(sp)
    sq k1, $01a0(sp)
    sq fp, $01b0(sp)
    sq gp, $01c0(sp)
    sq ra, $01d0(sp)
    
    jalr a1
    nop
    
    lq at, $0000(sp)
    lq v0, $0010(sp)
    lq v1, $0020(sp)
    lq a0, $0030(sp)
    lq a1, $0040(sp)
    lq a2, $0050(sp)
    lq a3, $0060(sp)
    lq t0, $0070(sp)
    lq t1, $0080(sp)
    lq t2, $0090(sp)
    lq t3, $00a0(sp)
    lq t4, $00b0(sp)
    lq t5, $00c0(sp)
    lq t6, $00d0(sp)
    lq t7, $00e0(sp)
    lq s0, $00f0(sp)
    lq s1, $0100(sp)
    lq s2, $0110(sp)
    lq s3, $0120(sp)
    lq s4, $0130(sp)
    lq s5, $0140(sp)
    lq s6, $0150(sp)
    lq s7, $0160(sp)
    lq t8, $0170(sp)
    lq t9, $0180(sp)
    lq k0, $0190(sp)
    lq k1, $01a0(sp)
    lq fp, $01b0(sp)
    lq gp, $01c0(sp)
    lq ra, $01d0(sp)
    jr ra
    addiu sp, sp, $0200
    
    
    //==========================================================
    _debugGenerate:
    
    
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop
    nop

  • #2
    Thanks for sharing it
    I may be lazy, but I can...zzzZZZzzzZZZzzzZZZ...

    Comment


    • #3
      That's what I'm here for, help people learn (IF they are interested). The engine operates chunks, each Boolean command branches off into it's own chunk. So if you have 500 lines of codes, and you split the codes up into 20 jokers, the engine will only read 20 lines until the joker Boolean check marks true. The main purpose behind this is to preserve CPU power. Keep it from doing more than it needs to be doing, to maximize potential and allow the use of large cheat lists without lagging the game up. It works wonders with cheat lists that I managed to push up to 100 kb

      The notes over embed data / routines are "to be implemented" features. The original idea was to not worry about finding a memory address to place a function that doesn't need a game specific hook. For example, you make a routine and just want A hook (not a specific one just want a random hook), you don't have to consume more space just to write the routine onto memory and you won't have to find a hook. The '9' command is the ExecData command, if the Embed Routine feature was implemented there would be a '9' command split, '90' -> exec data '91' -> exec embeded routine (with the routine ID as the argument for the command). The embeded routine contains no address, and all internal jal's, j's get patched to operate entirely in the kernel space it is located, etc. Embed Data is for just storing RAW data without having to find a place of memory to put it. Saves space by cutting the size of the codes in half, and saves frustration over finding memory blocks to place crap.

      Comment


      • #4
        Completely ingenious how you built chunks so users could load a massive amount of codes (100 KB) without issue.

        Comment


        • #5
          If you want to check it out I have the 1.3r03b engine implemented into the application I wrote called RemotePS2 (which is part of CheatCentral, an unfinished project that is supposed to be a cheat device station for the PS2). RemotePS2 allows PC to PS2 connectivity. The main idea behind it is to be able to fully remotely manage the cheat codes on your PS2, however the remote features are unfinished and disabled. Currently it allows you to send a code list over the local area network to the PS2, and launch the game and/or back up via swap disc method. It also allows remotely sending .ELF file's and executing them over the network, along with dumping BIOS over the network. The unfinished portion would be the management of the cheat files on the memory card. The OVERALL purpose, is for the v1.3 cheat device to be the PS2 side application for managing cheat codes, and RemotePS2 being the PC (windows supported only application) remote management. It also includes an HTTP cheat server, so if you don't have windows or can't get the PC application to work on your computer you can load up the HTTP server application on the PS2 to operate the management through the web browser of your choosing. The HTTP server only supports sending codes / launching a game disc (no backup loading feature is set on it yet). The HTTP server operates v1.2 engine, the v1.3 device operates the v1.2 engine, and RemotePS2 operates the v1.3r03b engine (shown in the top post of this thread). Worth looking at if you're bored enough, just more of my projects I started but never finished due to lack of time / interest...
          Last edited by Gtlcpimp; 06-21-2011, 07:57:52 PM.

          Comment


          • #6
            Sounds interesting enough, also how does the BIOS dumping feature exactly work? For example, does it dump straight onto my computer or do I need to extract it from a USB, can it work live, how well does it work on a wide variety of games you have tested it on(like others dumping tools they work on some games but don't work on others and everything in between), and could you use it to get the memory dump of the game?

            Comment


            • #7
              The BIOS dumps straight to your PC over the local area network. The only problem it gives is the speed... The best I have managed to get the PS2 to do so far is upload at about 20 kb/s and download at about 324 kb/s. So you can upload .ELF files almost instantly to the console, but downloading the BIOS dump actually takes a while... However under the CheatCentral main menu, you can dump the BIOS directly to your USB flash drive, and then copy it over to your PC off of the USB stick. It does not dump memory from games, that is a different story on its own.

              For dumping game memory, you could try Jimmy's IG-Mass-Dumper tool. It doesn't work with all games, but does for some.
              I was testing a method for dumping memory from games, and put the .ELF file on these forums somewhere, called Memory Dropper. It's not an effective method (tries to force an IOP reboot using it's functions rather than the game's functions, and re-launch itself via ExecPS2 system call). I find it worked mainly during MPEG sequences (cut scenes, whatever you call them).

              The only sure fire way I can guarantee you can dump a game is to manually write a code for the specific game... CodeMasters-Projects shows a way to make a save-dump code for the older module games, but for the newer games that have updated save functions you would have to take a different route. For example, SOCOM: Combined Assault, you can't follow the CMP save dump method on there, so I wrote a code and .ELF to manually dump at the press of a joker. The code forced the game to activate it's own reboot functions, and forced it to do a custom ExecPS2 system call rather than the original LoadExecPS2 system call. When you press the joker, the engine restores the .ELF file onto memory address 0x00090000, and then patches the game's memory to force the custom reboot to directly launch the .ELF restored onto RAM, which then loads the USB modules and saves 0x00100000 - 0x02000000 to the USB stick.
              Last edited by Gtlcpimp; 06-21-2011, 10:43:45 PM.

              Comment


              • #8
                That pretty bad ass, I check out CheatCentral few minutes ago and I like it, your a talented developer. And yeah I currently use Jimmy's dumper, and works amazingly on some games but others I can't get to work for my life. I'm always on the look out for a better technique for dumping LOL.

                Comment


                • #9
                  Well if you got the time and patients you could load up LDv3 and manually write down 32 MB's

                  What game are you trying to dump?

                  Comment


                  • #10
                    That's also a good idea pimp, but the only thing with LDv3 is that it doesn't work on some games. And nothing really specific I just would like to have a easier way of dumping for the PS2, like for the PSP its a click away from multiple live dumps (my favorite console). Is your SOCOM: Combined Assault dump sub released? Or do you mind share it?

                    Comment


                    • #11
                      No, not yet. It's 95% .ELF and 5% hard coded assembly.

                      The .ELF boots up, stores it's entire self into kernel (0x80030000), and writes the main engine into kernel (0x80078250), and then hooks it with the master positive Syscall jump and link line (0x800002FC). The engine reads the game's static controller input address (0x0071575c), and waits for it to match the desired input (I set it to the press of R3). Once I hit the button, it restores the .ELF back onto user space from the kernel preserved space, and then writes a few patches to the game memory. It patches the game's LoadExecPS2 Syscall to instead of booting the SLUS file it will perform an ExecPS2 System call with the arguments set to launch the .ELF it just restored (0x000900e0 entry point) with bogus name arguments (to prevent failure). Then it patches the game to force it to execute the game's reset function so when it returns back from the System call the game will reboot itself. The game does it's normal reboot routine, flush IOP and remove all replacement modules off RAM, etc. etc. etc., BUT, it won't launch it's SLUS file, it's been patched up to execute the restored .ELF, which then performs an IOP reset (again just to be safe) and then loads modules from ROM0 along with a USB driver to save memory 0x00100000 - 0x02000000 to a USB file

                      Flawless victory, method is guaranteed to work on every game. The only downside is, it's a game specific set up (meaning you have to manually write the code to match the game you want to dump). However the METHOD itself is the exact same. You will not be able to return to the game after the dump, you will have to boot the game back up all over again (which is another downside, but hey you get a dump of the game do you not?)

                      I could release the source, but would have to wait 'til I get back home.

                      Comment


                      • #12
                        Oh I see, umm seems like a very thought out and effective method of dumping over all. Would it be a difficult task porting it over to other games though?

                        Comment


                        • #13
                          Wouldn't call it porting, would be more like re-making for another game. Shouldn't be too difficult, as long as the game was set up to reboot itself upon installing update, or returning to main menu, or anything that would make the developer want to reboot the game. It's easy to trace a reboot

                          Bonus side of it, is it allows you to take any game (that has the ability to reboot itself like explained above) and modify it to exploit your console. So you wouldn't have to purchase a cheat device or mod chip to run home brew. You could rip an image, inject the mods, burn the DVD, boot + swap to load mods and hit your joker to launch the home brew application.
                          Last edited by Gtlcpimp; 06-25-2011, 01:36:03 PM.

                          Comment

                          Working...
                          X