Thread: Development: Adding New Moves to Gen 3
View Single Post
  #134    
Old April 1st, 2016 (3:41 PM).
Gamer2020's Avatar
Gamer2020 Gamer2020 is offline
Accept no Imitations!
     
    Join Date: Jun 2008
    Location: Distant Land
    Gender: Male
    Nature: Bold
    Posts: 939
    I'm back from my "vacation" and can finally post what I've got. I finished the last routine. I also rewrote the 3rd routine and all problems with the move tutor now seem to be fixed. These are for Fire Red.

    I did not have time to finish the routines for Emerald since I was working on several things. Emerald has 8 routines in total. I was able to port the 6 from FR but the last two are still needed. The routines are at 0819FF98 and 081A01E8. I will release all 8 routines once I have the last 2.

    I've gathered all the needed routines for Fire Red so that they can all be in one post. Just follow the tutorial and use these routines instead. I've also added these routines to Pokemon Game Editor's Attack Adder for those that aren't as experienced with this stuff. Pokemon Game Editor will even convert the move sets to the new style for you so it will be way faster than doing it by hand. I'll be releasing the update as soon as I get settled in.

    Spoiler:

    Code:
    .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle1
    
    /* By: Jambo51 */
    /* Change 0x3EB20 to 18 49 08 47. Then navigate to 0x3EB84 and change it to XX XX XX 08, where the XX XX XX stands for the pointer to this routine plus 1. */
    
    main:
     mov r1, r9
     lsl r1, r1, #0x2
     ldr r0, table
     add r0, r0, r1
     ldr r0, [r0, #0x0]
     ldr r6, there
     add r6, #0x6
     ldrb r7, [r6, #0x0]
    loop: lsl r1, r7, #0x1
     add r1, r1, r7
     add r3, r0, r1
     ldrb r1, [r3, #0x2]
     mov r4, r10
     cmp r4, r1
     beq learn
     cmp r1, #0xFF
     beq exit
     add r7, #0x1
     b loop
    learn: ldr r2, there
     add r7, #0x1
     strb r7, [r6, #0x0]
     ldrb r1, [r3, #0x1]
     lsl r1, r1, #0x8
     ldrb r0, [r3, #0x0]
     orr r0, r1
     strh r0, [r2, #0x0]
     ldr r1, return
     bx r1
    exit: ldr r0, return2
     bx r0
    .align
    return:  .word 0x0803EB65
    return2: .word 0x0803EB73
    there:  .word 0x02024022
    table:  .word 0x0825D7B4
    Code:
    .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle2
    
    /* By: Jambo51 */
    /* Improved by: DoesntKnowHowToPlay */
    /* Change 0x3EA10 to 00 49 08 47 XX XX XX 08 where the XX XX XX stands for the pointer to this routine plus 1. */
    
    main:
     ldrb r1, [r0, #0x2]
     mov r2, #0xFF
     cmp r1, r2
     beq exit2
     lsl r2, #0x8
     add r2, #0xFF
     mov r9, r2
     mov r3, #0x0
    loop: lsl r0, r3, #0x1
     add r0, r0, r3
     ldr r1, movesettable
     add r1, r1, r6
     ldr r1, [r1, #0x0]
     add r7, r0, r1
     ldrb r0, [r7, #0x2]
     mov r4, r10
     cmp r0, r4
     bgt exit2
     ldrb r1, [r7, #0x1]
     ldrb r0, [r7, #0x0]
     lsl r1, r1, #0x8
     orr r1, r0
     mov r0, r8
     str r3, [sp, #0x0]
     mov r4, r1
     bl branchone
     mov r5, #0xFF
     ldr r3, [sp, #0x0]
     cmp r0, r9
     bne exit
     mov r0, r8
     add r1, r4, #0x0
     bl branchtwo
     ldr r3, [sp, #0x0]
    exit: add r3, #0x1
    # lsl r1, r3, #0x1
    # add r1, r1, r3
    # add r0, r7, r1
     mov r1, #0x3
     add r0, r7, r1
     ldrb r0, [r0, #0x2]
     cmp r0, r5
     bne loop
    exit2: add sp, #0x4
     pop {r3-r5}
     mov r8, r3
     mov r9, r4
     mov r10, r5
     pop {r4-r7}
     pop {r0}
     bx r0
    branchone: push {r4-r7,lr}
     add sp, #-0x4
     ldr r7, gothere
     bx r7
    branchtwo: push {r4-r7,lr}
     ldr r7, gothere2
     bx r7
    .align
    gothere: .word 0x0803E8B5
    gothere2: .word 0x0803EC43
    movesettable: .word 0x0825D7B4
    Code:
     .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle3
    
    /* By: Gamer2020 */
    /* Change 0x043CD0 to 00490847 XXXXXXXX where the XX XX XX stands for the pointer to this routine plus 1. */
    
    main:
    MOV    R5, #0x0
    LDR     R6, .learned_moves_ptr
    LSL    R1, R7, #0x2
    ADD    R2, R1, R6
    LDR     R3, [R2]
    ldrb r0, [r3, #0x2]
    STR     R1, [SP,#0x14]
    CMP     R0, #0xFF
    BEQ     loc_8043DB4
    MOV     R9, R2
    STR     R3, [SP,#0x10]
    
    loc_8043CE8:
    mov r2,#0x03
    mul r2, r2, r5 /*mult 3*/
        ldr     r1,[sp, #0x10] /* Use these two lines to get current attack address.*/
        add     r0,r2,r1
        mov     r7,r2
     ldrb r1, [r0, #0x0]
     ldrb r3, [r0, #0x1]
     lsl r3, r3, #0x8
     orr r3, r1 /*Puts attack in r3.*/
    ldrb r0, [r0, #0x2] /*Puts level in r0.*/
    ldr     r1,[sp,#0x0C] /* Loads current level */
        add     r5, #0x1 /* Loop counter? */
        mov     r12,r5
        cmp     r0,r1 /* compares levels */
        bgt     loc_8043D9E
        mov     r4, #0x0
        mov     r0,r13
        ldrh    r1,[r0]
        mov     r0,r3 /* Puts attack in r0 */
        cmp     r1,r0
        beq     loc_8043D38
        ldr     r0,[sp,#0x14]
        ldr     r1, .learned_moves_ptr
        add     r6,r0,r1
        mov     r3,r13
        mov     r5,r7
    
    loc_8043D20:
        add     r3, #0x2
        add     r4, #0x1
        cmp     r4, #0x3
        bgt     loc_8043D38
        ldr     r0,[r6]
        add     r0,r5,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Puts attack in r0.*/
        ldrh    r2,[r3]
        cmp     r2,r0
        bne     loc_8043D20
    
    loc_8043D38:
        cmp     r4,#0x4
        bne     loc_8043D9E
        mov     r4,#0x0
        cmp     r4,r10
        bge     loc_8043D7C
        mov     r1,r9
        ldr     r0,[r1]
        add     r0,r7,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Puts attack in r0.*/
    ldr     r2,[sp,#0x8]
    ldrh    r2,[r2]
        cmp     r2,r0
        beq     loc_8043D7C
        ldr     r1,[sp, #0x14]
        ldr     r2, .learned_moves_ptr
        add     r6,r1,r2
        ldr     r3,[sp, #0x8]
        mov     r5,r7
    
    loc_8043D64:
        add     r3, #0x2
        add     r4,#0x1
        cmp     r4,r10
        bge     loc_8043D7C
        ldr     r0,[r6]
        add     r0,r5,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Puts attack in r0.*/
        ldrh    r2,[r3]
        cmp     r2,r0
        bne     loc_8043D64
    
    loc_8043D7C:
        cmp     r4,r10
        bne     loc_8043D9E
        mov     r0,r10
        add     r0,#0x1
        lsl     r0,r0,#0x18
        lsr     r0,r0,#0x18
        mov     r10,r0
        lsl     r2,r4, #0x1
        ldr     r1,[sp,#0x8]
        add     r2,r2,r1
        mov     r4,r9
        ldr     r0,[r4]
        add     r0,r7,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Puts attack in r0.*/
        strh    r0,[r2]
    
    loc_8043D9E:
        mov     r5,r12
        cmp     r5, #0x13
        bgt     loc_8043DB4
        mov     r1,r9
        ldr     r0,[r1]
    mov r1,#0x03
    mul r1, r1, r5 /*mult 3*/
        add     r1,r1,r0
        ldrh    r0,[r1] /* Load bytes for term check. */
    ldrb r0, [r1, #0x2]
    cmp     r0, #0xFF /*Term Check*/
        bne     loc_8043CE8
    
    loc_8043DB4:
        mov     r0,r10
        add     sp, #0x18
        pop     {r3-r5}
        mov     r8,r3
        mov     r9,r4
        mov     r10,r5
        pop     {r4-r7}
        pop     {r1}
        bx      r1
    
    .align 2
    .learned_moves_ptr:
        .word 0x0825D7B4
    Code:
    .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle4
    
    /* By: Gamer2020 */
    /*at 8043E2C 004B1847xxxxxxxx */
    
    /*08043E2C*/
    main:
        PUSH    {R4-R7,LR}
        MOV     R7, R10
        MOV     R6, R9
        MOV     R5, R8
        PUSH    {R5-R7}
        sub sp, sp, #0x3C
        add r6, r0, #0x0
        mov r0, #0x0
        mov r10, r0
        add r0, r6, #0x0
        mov r1, #0x41
        mov r2, #0x0
        ldr r3, .READ_Poke_DATA /*Get Species*/
        bl bx_r3
        lsl r0, r0, #0x10
        lsr r4, r0, #0x10
        add r0, r6, #0x0
        mov r1, #0x38
        mov r2, #0x0
        ldr r3, .READ_Poke_DATA /*Get Level*/
        bl bx_r3
        lsl r0, r0, #0x18 /*Drops leading 000000??*/
        lsr r0, r0, #0x18
        str r0, [sp, #0x30]
        mov r0, #0xce /*Check if slot 412*/
        lsl r0, r0, #0x01
        cmp r4, r0
        bne     loc_8043E68
        mov r0, #0x0
        b       exit
    
    loc_8043E68:
        mov r5, #0x0
        lsl r4, r4, #0x02 /*Species x 4*/
        str r4, [sp, #0x38] /*Stores value for later */
        mov r4, sp
    
    loc_8043E70:
        mov r1, r5
        add r1, #0xd
        mov r0, r6
        mov r2, #0x0
        ldr r3, .READ_Poke_DATA /*Get attacks*/
        bl bx_r3
        strh r0, [r4]
        add r4, #0x2
        add r5, #0x1 /*Loops through 4 attacks on Poke*/
        cmp r5, #0x3
        ble loc_8043E70
        mov r5, #0x0
        ldr     r3, .learned_moves_ptr
        ldr r2, [sp, #0x38]
        add r1, r2, r3
        ldr     r0,[r1]
    ldrb r0, [r0, #0x2]
    CMP     R0, #0xFF
        BEQ     loc_8043F70
        mov     r9,r1
        mov     r4,r13
        add     r4,#0x8
        str     r4,[sp,#0x34]        
    
    loc_8043EA0:
        mov     r1,r9
        ldr     r0,[r1]
    mov r2,#0x03
    mul r2, r2, r5 /*mult 3*/
        add     r0,r2,r0
    ldrb r0, [r0, #0x2] /*Puts level in r0.*/
        ldr     r4,[sp, #0x30] /*Loads mon level*/
    mov     r1,r4
        mov     r7,r2
        add     r5, #0x1 /*Incremeants place*/
        mov     r12,r5
        cmp     r0,r1  /*Level Check*/
        bgt     loc_8043F5A
        mov     r4, #0x0
    mov     r0,r9
    ldr     r0,[r0]
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Puts attack in r0.*/
         mov     r1,r13
        ldrh    r1,[r1]
        cmp     r1,r0
        beq     loc_8043EF2
        ldr     r0,[sp, #0x38]
        ldr     r1, .learned_moves_ptr
        add     r6,r0,r1
        mov     r3,r13
        mov     r5,r7
    
    loc_8043EDA:
        add     r3, #0x2
        add     r4, #0x1
        cmp     r4, #0x3
        bgt     loc_8043EF2
        ldr     r0,[r6]
        add     r0,r5,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Loads bytes Gets attack put into r0*/
        ldrh    r2,[r3]
        cmp     r2,r0
        bne     loc_8043EDA
    
    loc_8043EF2:
        cmp     r4, #0x4
        bne     loc_8043F5A
        mov     r4, #0x0
        cmp     r4,r10
        bge     loc_8043F38
        mov     r1,r9
        ldr     r0,[r1]
        add     r0,r7,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r1, r0 /*Loads bytes Gets attack put into r1*/
        ldr     r0,[sp,#0x34]
        ldrh    r2,[r0]
    mov     r0,r1 /*Gets attack put into r0*/
        add     r1,sp,#0x8
        cmp     r2,r0
        beq     loc_8043F38
        ldr     r2,[sp,#0x38]
        ldr     r0, .learned_moves_ptr
        add     r6,r2,r0
        mov     r3,r1
        mov     r5,r7
    
    loc_8043F20:
        add     r3, #0x2
        add     r4, #0x1
        cmp     r4,r10
        bge     loc_8043F38
        ldr     r0,[r6]
        add     r0,r5,r0 /*Attack*/
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Loads bytes Gets attack put into r0*/
        ldrh    r2,[r3]
        cmp     r2,r0
        bne     loc_8043F20
    
    loc_8043F38:
        cmp     r4,r10
        bne     loc_8043F5A
        mov     r0,r10
        add     r0, #0x1
        lsl     r0,r0, #0x18
        lsr     r0,r0, #0x18
        mov     r10,r0
        lsl     r2,r4, #0x1 /*mult 2?*/
        ldr     r4,[sp,#0x34]
        add     r2,r4,r2
        mov     r1,r9
        ldr     r0,[r1]
        add     r0,r7,r0
     ldrb r1, [r0, #0x0]
     ldrb r0, [r0, #0x1]
     lsl r0, r0, #0x8
     orr r0, r1 /*Loads bytes Gets attack put into r0*/
        strh    r0,[r2] 
    
    loc_8043F5A:
        mov     r5,r12
        cmp     r5, #0x13 /*Some kind of limit to attacks?*/
        bgt     loc_8043F70
        mov     r2,r9
        ldr     r0,[r2]
    mov r1,#0x03
    mul r1, r1, r5
        add     r1,r1,r0
    ldrb r0, [r1, #0x2]
    cmp     r0, #0xFF /*Term Check*/
        bne     loc_8043EA0
    
    loc_8043F70:
        mov     r0,r10 /*Return Value*/
    
    exit:
        add     sp, #0x3C
        pop     {r3-r5}
        mov     r8,r3
        mov     r9,r4
        mov     r10,r5
        pop     {r4-r7}
        pop     {r1}
        bx      r1 
    
    bx_r3:
        bx r3
        
    .align 2
    .READ_Poke_DATA:
        .word 0x0803FBE9
    .learned_moves_ptr:
        .word 0x0825D7B4
    Code:
    .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle5
    
    /* By: Gamer2020 */
    /*at 0803EAFC write 00490847xxxxxxxx */
    /* At 0803EAD4 write 8078C046C046C046C046*/
    /* At 0803EB04 write FF29*/
    /* at 0803EAE2 write 5446C046*/
    /* at 0803EB18  write 081CC046*/
    
    /*0803EAFC*/
    main:
        mov r1,#0x03
        mul r0, r0, r1 /*mult 3*/
        ldr     r1,[r3] /* Loads offset for mon*/
        add     r0,r0,r1
        ldrb r1, [r0, #0x2]    
        ldr    r0, .return
        bx    r0
        
    .align 2
    .return:
        .word 0x0803EB05
    Code:
    .text
    .align 2
    .thumb
    .thumb_func
    .global newmovesetstyle6
    
    /* By: Gamer2020 */
    /* Write this routine at 08043DD4. If you edit the routine and make it longer you may have to branch to it.*/
    
    /*08043DD4*/
    main:    
        push    {r4-r7,r14}
        mov     r6,r1
        lsl     r0,r0,#0x10 /* r0 holds species.*/
        mov     r5, #0x0
        mov     r4, #0x0
        ldr     r1,=.learned_moves_ptr
        lsr     r0,r0, #0x0E
        add     r0,r0,r1
        ldr     r2,[r0]
    ldrb r0, [r2, #0x2]
    cmp     r0, #0xFF /*Term Check*/
        beq     loc_8043E18
        mov     r3,r2
    
    loc_8043DF6:
        mov     r1,r5
        add     r0,r1, #0x1
        lsl     r0,r0, #0x18
        lsr     r5,r0, #0x18
        lsl     r1,r1, #0x1
        add     r1,r1,r6
    ldrb r2, [r3, #0x0]
    ldrb r0, [r3, #0x1]
    lsl r0, r0, #0x8
    orr r0, r2 /*Loads bytes Gets attack put into r0*/
        strh    r0,[r1] 
        add     r3, #0x3 /* Increment. */
        add     r4, #0x1
        cmp     r4, #0x13
        bgt     loc_8043E18
    ldrb r0, [r3, #0x2]
    cmp     r0, #0xFF /*Term Check*/
        bne     loc_8043DF6
    
    loc_8043E18: 
        mov     r0,r5
        pop     {r4-r7}
        pop     {r1}
        bx      r1
    
    .align 2
    .learned_moves_ptr:
        .word 0x0825D7B4


    Happy Hacking!
    __________________

    The new home for ROM Hacking!
    Reply With Quote