The PokéCommunity Forums Fan Games ROM Hacking Research & Development
Development Adding New Moves to Gen 3

Research & Development Got a well-founded knack with ROM hacking? Love reverse-engineering the Pokémon games? Or perhaps you love your assembly language. This is the spot for polling and gathering your ideas, and then implementing them! Share your hypothesis, get ideas from others, and collaborate to create!


Reply
 
Thread Tools
  #126    
Old August 29th, 2015 (4:03 PM).
Againsts's Avatar
Againsts Againsts is offline
     
    Join Date: Aug 2015
    Gender: Female
    Posts: 27
    ok,thank you
    Reply With Quote

    Relevant Advertising!

      #127    
    Old November 22nd, 2015 (9:31 AM). Edited November 22nd, 2015 by TARDISam.
    TARDISam's Avatar
    TARDISam TARDISam is offline
    Photon Director
       
      Join Date: Oct 2010
      Location: Coventry, UK
      Gender: Male
      Nature: Relaxed
      Posts: 27
      No matter what I do, I can't seem to get this to work correctly in PGE. Upon selecting the new, added move, I get an unhandled exception of the form "RecordNumber is not a valid value", at which point the program will not allow me to do anything else on the grounds of another program apparently using the file.

      Has anyone else had similar errors? I'm pretty sure the table repointing has gone correctly for the most part, but PGE just seems to not handle the new moves after Psycho Boost.


      EDIT: Ok, it seems as if the problem was the Attack Description Table. I tried recreating an extended version of that and repointing as necessary and it's working fine now. I wonder why this wasn't included in the tutorials in the same way as the Data, Names and Animation tables? It seems to be just as necessary from experience.
      __________________
      Osla eb traeh ruoy lliw ereht, si erusaert ruoy erehw
      Reply With Quote
        #128    
      Old January 2nd, 2016 (4:06 AM). Edited January 2nd, 2016 by Gamer2020.
      Gamer2020's Avatar
      Gamer2020 Gamer2020 is offline
      Accept no Imitations!
         
        Join Date: Jun 2008
        Location: Distant Land
        Gender: Male
        Nature: Bold
        Posts: 934
        While coding the attack expander in PGE I noticed that if you delete the old data, field moves will end up looking like this:



        To fix it you just have to repoint a few pointers to the new name locations for those attacks. These are the pointer locations:

        Flash - 45A6A8
        Cut - 45A6B0
        Fly - 45A6B8
        Strength - 45A6C0
        Surf - 45A6C8
        Rock Smash - 45A6D0
        Waterfall - 45A6D8
        Teleport - 45A6E0
        Dig - 45A6E8
        Milk Drink - 45A6F0
        Softboiled - 45A6F8
        Sweet Scent - 45A700
        __________________

        The new home for ROM Hacking!
        Reply With Quote
          #129    
        Old January 6th, 2016 (9:43 AM). Edited January 6th, 2016 by Gamer2020.
        Gamer2020's Avatar
        Gamer2020 Gamer2020 is offline
        Accept no Imitations!
           
          Join Date: Jun 2008
          Location: Distant Land
          Gender: Male
          Nature: Bold
          Posts: 934
          These are the field move pointer locations for Emerald.

          Flash - 615CA8
          Cut - 615CA0
          Fly - 615CC8
          Strength - 615CB8
          Surf -615CC0
          Rock Smash - 615CB0
          Waterfall - 615CD8
          Dive - 615CD0
          Teleport - 615CE0
          Dig - 615CE8
          Secret Power - 615CF0
          Milk Drink - 615CF8
          Softboiled - 615D00
          Sweet Scent - 615D08
          __________________

          The new home for ROM Hacking!
          Reply With Quote
            #130    
          Old February 10th, 2016 (6:22 AM).
          NicolasLukas NicolasLukas is offline
             
            Join Date: Aug 2015
            Location: Germany
            Gender: Male
            Nature: Relaxed
            Posts: 164
            Hello Gamer2020,
            I have a problem with PokemonGameEditor.
            I add 100 attacks and then I want to edit them, but they aren´t saving. What can I do?
            Lastly I have another question: When will you finish the next update?
            Reply With Quote
              #131    
            Old February 17th, 2016 (4:04 AM). Edited February 22nd, 2016 by Gamer2020.
            Gamer2020's Avatar
            Gamer2020 Gamer2020 is offline
            Accept no Imitations!
               
              Join Date: Jun 2008
              Location: Distant Land
              Gender: Male
              Nature: Bold
              Posts: 934
              A week or so ago, someone (A-bird?) on the irc mentioned to me that the move relearner would not work properly if the Pokemon could not learn any moves. I tried to reproduce the problem and sure enough this happens:



              I made a mental note to look into it at some point. While working on PGE I noticed that there were 6 pointers to the level up attacks but remembered that Jambo51 only posted 3 routines. I took a look and there are 3 more routines that need to be edited.

              One of these routines is called when the move relearner is run. This routine, located at 08043E2C, seems to return the number of attacks the Pokemon can relearn. I rewrote the routine and here it is:

              This is for Fire Red. I will port it eventually.
              Code:
              .text
              .align 2
              .thumb
              .thumb_func
              .global newmovesetstyle4
              
              /*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
              This routine takes care of the pointer at 08043F84. I tested this routine and it seemed to work fine but it could always be optimized a bit more. This seems to fix most of the problems but I think that Jambo51's third routine may need some tweaking. There are two more pointers at 0803EB10 and 08043E20 but I currently have no time to look into the routines that use them.
              __________________

              The new home for ROM Hacking!
              Reply With Quote
                #132    
              Old February 17th, 2016 (2:59 PM). Edited February 22nd, 2016 by Gamer2020.
              Gamer2020's Avatar
              Gamer2020 Gamer2020 is offline
              Accept no Imitations!
                 
                Join Date: Jun 2008
                Location: Distant Land
                Gender: Male
                Nature: Bold
                Posts: 934
                I've updated the above routine because LDRH doesn't work with misaligned data I guess.

                This is for Fire Red. I will port it eventually.
                Code:
                .text
                .align 2
                .thumb
                .thumb_func
                .global newmovesetstyle4
                
                /*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
                __________________

                The new home for ROM Hacking!
                Reply With Quote
                  #133    
                Old February 22nd, 2016 (4:50 PM).
                Gamer2020's Avatar
                Gamer2020 Gamer2020 is offline
                Accept no Imitations!
                   
                  Join Date: Jun 2008
                  Location: Distant Land
                  Gender: Male
                  Nature: Bold
                  Posts: 934
                  Ok so I figured out that the routine at 0803EA88 was a check for the Rare Candy to see if the Pokemon can learn a move once it's leveled up. If you were to try to use a Rare Candy on a Pokemon it would not learn moves when it should. The following small routine and byte changes fixes that. Now all that's left is to fix the routine at 08043DD4.

                  This is for Fire Red. I will port it eventually.
                  Code:
                  .text
                  .align 2
                  .thumb
                  .thumb_func
                  .global newmovesetstyle5
                  
                  /*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
                  I am going to be going on a trip that will last at least a month. I will not have internet during that time. I will continue ROM hacking but will not be able to post updates till I get back. By then whatever I find will be added to PGE to make it easier for people. Cya then!
                  __________________

                  The new home for ROM Hacking!
                  Reply With Quote
                    #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: 934
                    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
                      #135    
                    Old April 2nd, 2016 (3:58 AM).
                    LCCoolJ95's Avatar
                    LCCoolJ95 LCCoolJ95 is offline
                    Limited Capacity
                       
                      Join Date: May 2009
                      Location: The World That Never Was
                      Age: 23
                      Gender: Male
                      Nature: Naive
                      Posts: 550
                      Gamer2020, are the routines you are talking about the working routines for moves above 511 to work?
                      __________________
                      "The greatest obstacle in life is Yourself. Overcome it, and you will achieve the greatest accomplishment of all." -Art Beins, 1982

                      Pokémon Theta Emerald EX: https://www.pokecommunity.com/showthread.php?t=386240
                      Reply With Quote
                        #136    
                      Old April 2nd, 2016 (10:31 AM).
                      Gamer2020's Avatar
                      Gamer2020 Gamer2020 is offline
                      Accept no Imitations!
                         
                        Join Date: Jun 2008
                        Location: Distant Land
                        Gender: Male
                        Nature: Bold
                        Posts: 934
                        Quote:
                        Originally Posted by LCCoolJ95 View Post
                        Gamer2020, are the routines you are talking about the working routines for moves above 511 to work?
                        Yes...
                        __________________

                        The new home for ROM Hacking!
                        Reply With Quote
                          #137    
                        Old March 20th, 2018 (3:34 PM).
                        danfelre danfelre is offline
                           
                          Join Date: Mar 2014
                          Posts: 9
                          "In all seriousness, you want to navigate to 0x250C04 and select 4260 bytes of data, then copy it to some aligned free space in your rom, and then repoint all references to that table. This is the silly part, there are ALSO pointers to 0x250C08 in the ROM which must also be repointed, which are used when writing the new moves' PP onto your Pokémon's data." Just how can i repoint anything anyway ? I'm using Gold Finger Hex Editor.
                          __________________
                          John 3:16
                          For God so loved the world that He gave His only begotten Son, that everyone who believes into Him shall by no means perish but have eternal life.

                          Acts 2:21
                          And everyone who calls on the name of the Lord will be saved.

                          Jesus, The Lord!
                          Reply With Quote
                          Reply

                          Quick Reply

                          Join the conversation!

                          Create an account to post a reply in this thread, participate in other discussions, and more!

                          Create a PokéCommunity Account

                          Sponsored Links
                          Thread Tools

                          Posting Rules
                          You may not post new threads
                          You may not post replies
                          You may not post attachments
                          You may not edit your posts

                          BB code is On
                          Smilies are On
                          [IMG] code is On
                          HTML code is Off

                          Forum Jump


                          All times are GMT -8. The time now is 8:58 AM.