Research: Critical Capture

[ghoulslash]

Thanks to Daniils and JPAN and everyone else who has worked on expanding pokeballs, we can expand pokeballs and create custom catch rate functions. However, I have yet to see any work on porting the critical capture to Gen 3 games (at least any public work)

I would like to share some research I have done into the subject. I noticed from koople's dodge rate routine that there is some index that appears to determine the outcome of the throw (see below).

First, some info on how the catch rate and subsequent success is determined:
1. The catch rate is calculated starting at 0802d620 and finally loaded into r6:

Spoiler:

0802d620 491c ldr r1, [$0802d694] (=$08250892)
0802d622 8810 ldrh r0, [r2, #0x0]
0802d624 3802 sub r0, #0x2
0802d626 1840 add r0, r0, r1
0802d628 7804 ldrb r4, [r0, #0x0]
0802d62a 1c28 add r0, r5, #0x0
0802d62c 4360 mul r0, r4
0802d62e 210a mov r1, #0xa
0802d630 f1b6 bl $081e4018
0802d634 4d18 ldr r5, [$0802d698] (=$02023be4)
0802d636 4919 ldr r1, [$0802d69c] (=$02023d6c)
0802d638 780a ldrb r2, [r1, #0x0]
0802d63a 2158 mov r1, #0x58
0802d63c 1c14 add r4, r2, #0x0
0802d63e 434c mul r4, r1
0802d640 1963 add r3, r4, r5
0802d642 8d9a ldrh r2, [r3, #0x2c]
0802d644 0051 lsl r1, r2, #0x01
0802d646 1889 add r1, r1, r2
0802d648 8d1a ldrh r2, [r3, #0x28]
0802d64a 0052 lsl r2, r2, #0x01
0802d64c 1a8a sub r2, r1, r2
0802d64e 4350 mul r0, r2
0802d650 f1b6 bl $081e4018
0802d654 1c06 add r6, r0, #0x0
0802d656 354c add r5, #0x4c
0802d658 1964 add r4, r4, r5
0802d65a 6824 ldr r4, [r4, #0x0]
0802d65c 2027 mov r0, #0x27
0802d65e 4020 and r0, r4
0802d660 2800 cmp r0, #0x0
0802d662 d000 beq $0802d666
0802d664 0076 lsl r6, r6, #0x01
0802d666 20d8 mov r0, #0xd8
0802d668 4004 and r4, r0
0802d66a 2c00 cmp r4, #0x0
0802d66c d005 beq $0802d67a
0802d66e 0130 lsl r0, r6, #0x04
0802d670 1b80 sub r0, r0, r6
0802d672 210a mov r1, #0xa
0802d674 f1b6 bl $081e460c
0802d678 1c06 add r6, r0, #0x0

2. There is then a check for safari ball and master ball, and we jump to 0802d6a8 for everything else. Eventually, we end up at 0802d752, which is a loop that gets a random value, and compares to the catch rate in r6.

Spoiler:

0802d74c 1c60 add r0, r4, #0x1
0802d74e 0600 lsl r0, r0, #0x18
0802d750 0e04 lsr r4, r0, #0x18
0802d752 2c03 cmp r4, #0x3
0802d754 d805 bhi $0802d762
0802d756 f017 bl $08044ec8
0802d75a 0400 lsl r0, r0, #0x10
0802d75c 0c00 lsr r0, r0, #0x10
0802d75e 42b0 cmp r0, r6
0802d760 d3f4 bcc $0802d74c
0802d762 4d15 ldr r5, [$0802d7b8] (=$02023d68)    @thrown ball index
0802d764 8828 ldrh r0, [r5, #0x0]
0802d766 2801 cmp r0, #0x1
0802d768 d100 bne $0802d76c
0802d76a 2404 mov r4, #0x4        @master ball automatically sets catch index to 0x4
0802d76c 2000 mov r0, #0x0
0802d76e 1c21 add r1, r4, #0x0     @r1 holds "catch index"
0802d770 f7e0 bl $0800e194
0802d770 f7e0 bl $0800e194
0802d774 4811 ldr r0, [$0802d7bc] (=$02023bc4)
0802d776 7800 ldrb r0, [r0, #0x0]
0802d778 f7e9 bl $08017248
0802d77c 2c04 cmp r4, #0x4
0802d77e d131 bne $0802d7e4
0802d780 490f ldr r1, [$0802d7c0] (=$02023d74)
0802d782 4810 ldr r0, [$0802d7c4] (=$081d9a42)   @caught poke battle script
0802d784 6008 str r0, [r1, #0x0]

0802d7e4 4803 ldr r0, [$0802d7f4] (=$02023e82)
0802d7e6 7144 strb r4, [r0, #0x5]
0802d7e8 4903 ldr r1, [$0802d7f8] (=$02023d74)
0802d7ea 4804 ldr r0, [$0802d7fc] (=$081d9a93)    @breakout battle script
0802d7ec 6008 str r0, [r1, #0x0]
0802d7ee bc70 pop {r4-r6}
0802d7f0 bc01 pop {r0}
0802d7f2 4700 bx r0

The loop incrementally increases r4 to a maximum value of 0x4, which holds the "catch index" as follows:

r4 = 0x0 --> breakout immediately
r4 = 0x1 --> shake once and breakout
r4 = 0x2 --> shake twice and breaout
r4 = 0x3 --> shake three times and breakout
r4 = 0x4 --> shake three times and catch
r4 = 0x5 --> trainer deflection (handled separately)
r4 = 0x6 --> ghost battle dodge (handled separately)
r4 > 0x6 -> ball rolls [r4] times and breaks out. sort of funny to watch it roll 10 times

An non-ideal critical capture routine could be made with a tentative algorithm such as this:

1. get ratio of caught pokemon to pokedex size
2. check brackets via [URL="https://bulbapedia.bulbagarden.net/wiki/Catch_rate#Critical_capture"]this guide[/URL]
3. get crit_catch_rate * catch_rate (eg. (0 - 2.5)*r6)
4. get random value via 08044ec8
5. compare critical capture rate to random value
6. if lower, critical capture has occurred. otherwise, perform regular capture checks (ie jump to 0802d752)
7. for critical capture: only perform one "shake check". 
7a. set r4 to 0x2 and jump to 0802d74c, or do logic yourself

This routine would theoretically imitate the logic for critical capture; however, the pokeball would still shake three times before capture instead of just once. I haven't had much luck with figuring out how the number of shakes is tied to the catch index yet. I have to imagine it is related to the ball object template table, as it contains data that appears to be related to "shaking" the pokeball. I would guess that the game loops over some animation related to shaking the pokeball based on the value of the "catch index" above.

(hopefully) more to follow. I hope to having a working code of the proposed algorithm soon.

EDIT: Here is an initial working version of the critical capture algorithm. The shaking animation and throwing sound need to be fixed, still

Spoiler:

.text
.align 2
.thumb
.thumb_func
.global CriticalCapture
/*
insert 00 48 00 47 (xx+1) xx xx 08 at 2d67c

see 2nd post in thread for notes about routine
*/

Main:
	ldrh r0, [r1]		@thrown ball
	cmp r0, #0x5
	beq SafariBall
	cmp r0, #0x1
	bne CheckNationalDex
	
MasterBall:
	ldr r0, =(0x0802d686 +1)
	bx r0
	
SafariBall:
	ldr r0, =(0x0802d6bc +1)
	bx r0
	
CheckNationalDex:
	mov r7, r6
	push {r2-r6}
	ldr r0, .TrainerData
	ldr r0, [r0]
	ldrb r0, [r0, #0x1b]
	cmp r0, #0xb9	@[0300500c] + 0x1b set to 0xb9 with special 0x16F to enable national dex
	bne LocalDex
	ldr r0, =(0x00000840)	@flag 0x840 set with sp. 0x16f (redundant check but whatevs)
	bl CheckFlag
	cmp r0, #0x0	
	beq LocalDex
	
NationalDex:
	mov r0, #0x1
	bl GetNationalDexCount
	b CheckBrackets
	
LocalDex:
	mov r0, #0x1
	bl GetLocalDexCount
		
CheckBrackets:
	mov r5, r0		@r5 = num caught pokemon
	ldr r6, =(0x00000xxx)	@r7 = size of your pokedex (0x182 = 386 if no expanded dex)
	
CheckLargest:
	mov r4, #0x19	@2.5x critical capture rate
	lsr r0, r6, #0x2
	sub r0, r6, r0		@3/4 dex size
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check2nd:
	mov r4, #0x14
	mov r0, #0x9
	mul r0, r6
	mov r1, #0x10	@9/16ths dex size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check3rd:
	mov r4, #0xF	
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x8	   @3/8ths dex_size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check4th:
	mov r4, #0xA
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x10	@3/16ths dex size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
CheckLast:
	mov r4, #0x5
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x50	@3/80ths dex size
	bl Divide
	cmp r5, r0
	bls NoCriticalCapture
	
GetCritCatchMultiplier:
	mov r0, r4		@critical capture chance multiplier
	mul r0, r7
	pop {r2-r6}
	mov r6, r7
	mov r1, #0x3C
	bl Divide	@r0 = c = (([0:5:25] x catch rate) / 10)  /  6)
	push {r0}
	bl Random
	mov r1, r0
	lsl r1, r1, #0x18
	lsr r1, r1, #0x18
	pop {r0}
	cmp r1, r0
	bls CritCapture	@if rand(0,255) <= c, critical capture occurs
	
NoCriticalCapture:
	pop {r2-r6}
	ldr r0, =(0x0802d6a8 +1)	@return to check all 3 shakes
	bx r0
	
CritCapture:
	bl Random
	lsl r0, r0, #0x18
	lsr r0, r0, #0x18
	cmp r0, r6
	bcc SuccessCritCatch	@rand < catch rate
	
FailedCritCapture:
	mov r4, #0x1			@shake once and breakout
	ldr r0, =(0x0802d76c +1)
	bx r0
	
SuccessCritCatch:
	mov r4, #0x4
	ldr r0, =(0x08xxxxxx)		@battle script to load (see below for example)
	ldr r1, .ScriptPointer
	str r0, [r1]
	mov r0, #0x0
	mov r1, #0x4		@3 shakes then catch - need to find a way to make 1 shake and catch
	ldr r2, =(0x0800E194 +1)    @store catch index
	bl jump_r2
	ldr r0, =(0x02023bc4)
	ldrb r0, [r0]
	ldr r2, =(0x08017248 +1)
	bl jump_r2
	ldr r1, =(0x0802d6d6 +1)
	bx r1
	
Random:
	ldr r2, =(0x08044ec8 +1)
	b jump_r2	
	
Divide:
	ldr r2, =(0x081e4018 +1)
	
jump_r2:
	bx r2
	
CheckFlag:
	ldr r1, =(0x0806e6d0 +1)
	bx r1
	
GetLocalDexCount:
	ldr r4, =(0x08088edc +1)
	bx r4
	
GetNationalDexCount:
	ldr r4, =(0x08088e8c +1)
	bx r4
		
.align 2
.ScriptPointer:	.word 0x02023d74
.TrainerData:	.word 0x0300500c
	
	
/* battle script example:

#org @start
setword 0x0203c020 0x08xxxxxx		//custom critical capture string
jumpifhalfword 0x0 0x2023D68 0x5 @safari
cmd60 0xB
printstring 0x184
goto 0x8165781

#org @safari
printstring 0x184
goto 0x81D9A53     //catch pokemon

*/

 

[AkameTheBulbasaur]

Hey this is pretty cool!

Last summer I was trying to figure out a similar sort of mechanic. I was trying to have a chance of being guaranteed to capture the pokemon based in certain things like level differences or Speed boosts. I forgot how it worked because I never ended up using it.

The part that I had the most trouble with was getting the game to have a separate animation for when these sorts of captures would occur. Well, not really a separate animation as much as having different sound effects, much like how actual critical captures have a different sound effect when the ball is thrown.

I'd been looking at the battle scripts called when Poke Balls are thrown but I found nothing that I could make use of :(. Hopefully we can all figure something out.

 

[ghoulslash]

Hey this is pretty cool!

Last summer I was trying to figure out a similar sort of mechanic. I was trying to have a chance of being guaranteed to capture the pokemon based in certain things like level differences or Speed boosts. I forgot how it worked because I never ended up using it.

The part that I had the most trouble with was getting the game to have a separate animation for when these sorts of captures would occur. Well, not really a separate animation as much as having different sound effects, much like how actual critical captures have a different sound effect when the ball is thrown.

I'd been looking at the battle scripts called when Poke Balls are thrown but I found nothing that I could make use of :(. Hopefully we can all figure something out.

Yeah the animation/sound effects seems to be the trickiest part. The battle scripts appear to only print the relevant strings/add data to pokedex/etc after the animation has run its course.

With that, here is a bit more preliminary research I've done:

Spoiler:

From the animation_cursor RAM (0x02037ED4), it appears that the throw_pokeball animation loads an animation at 1d6524. This animation looks like:

05 						waitstate
03 B9 F4 0E 08 02 00 	call 080ef4b8, args 0x2, 0x0
08						end (1d652c)

the assembly at 080ef4b8 does something with loading the ball object image and palette tables, but I haven't been able to figure out much else from it. If the pokemon breaks out of the ball, the animation cursor advances to 1d652c to end the animation, but does not if the pokemon is caught, which indicates to me that the necessary animation/sound is tied up in that routine somehow.

EDIT: I think somewhere in the 1d65xx area is the start of the ball throw animation; and it ends up at 1d6524 for several cases, as there are a couple pointers using the 'jump' animation command. The trick is finding out where the overall animation starts and what each task_call (cmd 03) does/which one determines the number of shakes/breakout animation.

It's also noted that after the 'catch index' is calculated, it is stored in 02022874 +1 within the function call 0800e194, though I haven't been able to find reference to this RAM again in other ball object/animation functions

To be continued...

I've also come up with a (fully?) working 'critical capture' routine using the algorithm I originally described. It also allows for a custom string to be displayed when critical capture succeeds:

Spoiler:

Assembly Routine: insert 00 48 00 47 (xx+1) xx xx 08 at 2d67c

Spoiler:

.text
.align 2
.thumb
.thumb_func
.global CriticalCapture

Main:
	ldrh r0, [r1]		@thrown ball
	cmp r0, #0x5
	beq SafariBall
	cmp r0, #0x1
	bne CheckNationalDex
	
MasterBall:
	ldr r0, =(0x0802d686 +1)
	bx r0
	
SafariBall:
	ldr r0, =(0x0802d6bc +1)
	bx r0
	
CheckNationalDex:
	mov r7, r6
	push {r2-r6}
	ldr r0, .TrainerData
	ldr r0, [r0]
	ldrb r0, [r0, #0x1b]
	cmp r0, #0xb9	@[0300500c] + 0x1b set to 0xb9 with special 0x16F to enable national dex
	bne LocalDex
	ldr r0, =(0x00000840)	@flag 0x840 set with sp. 0x16f (redundant check but whatevs)
	bl CheckFlag
	cmp r0, #0x0	
	beq LocalDex
	
NationalDex:
	mov r0, #0x1
	bl GetNationalDexCount
	b CheckBrackets
	
LocalDex:
	mov r0, #0x1
	bl GetLocalDexCount
		
CheckBrackets:
	mov r5, r0		@r5 = num caught pokemon
	ldr r6, =(0x00000xxx)	@r7 = size of your pokedex (0x182 = 386 if no expanded dex)
	
CheckLargest:
	mov r4, #0x19	@2.5x critical capture rate
	lsr r0, r6, #0x2
	sub r0, r6, r0		@3/4 dex size
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check2nd:
	mov r4, #0x14
	mov r0, #0x9
	mul r0, r6
	mov r1, #0x10	@9/16ths dex size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check3rd:
	mov r4, #0xF	
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x8	   @3/8ths dex_size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
Check4th:
	mov r4, #0xA
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x10	@3/16ths dex size
	bl Divide
	cmp r5, r0
	bgt GetCritCatchMultiplier
	
CheckLast:
	mov r4, #0x5
	mov r0, #0x3
	mul r0, r6
	mov r1, #0x50	@3/80ths dex size
	bl Divide
	cmp r5, r0
	bls NoCriticalCapture
	
GetCritCatchMultiplier:
	mov r0, r4		@critical capture chance multiplier
	mul r0, r7
	pop {r2-r6}
	mov r6, r7
	mov r1, #0x3C
	bl Divide	@r0 = c = (([0:5:25] x catch rate) / 10)  /  6)
	push {r0}
	bl Random
	mov r1, r0
	lsl r1, r1, #0x18
	lsr r1, r1, #0x18
	pop {r0}
	cmp r1, r0
	bls CritCapture	@if rand(0,255) <= c, critical capture occurs
	
NoCriticalCapture:
	pop {r2-r6}
	ldr r0, =(0x0802d6a8 +1)	@return to check all 3 shakes
	bx r0
	
CritCapture:
	bl Random
	lsl r0, r0, #0x18
	lsr r0, r0, #0x18
	cmp r0, r6
	bcc SuccessCritCatch	@rand < catch rate
	
FailedCritCapture:
	mov r4, #0x1			@shake once and breakout
	ldr r0, =(0x0802d76c +1)
	bx r0
	
SuccessCritCatch:
	mov r4, #0x4
	ldr r0, =(0x08xxxxxx)		@battle script to load (see below for example)
	ldr r1, .ScriptPointer
	str r0, [r1]
	mov r0, #0x0
	mov r1, #0x4		@3 shakes then catch - need to find a way to make 1 shake and catch
	ldr r2, =(0x0800E194 +1)    @store catch index
	bl jump_r2
	ldr r0, =(0x02023bc4)
	ldrb r0, [r0]
	ldr r2, =(0x08017248 +1)
	bl jump_r2
	ldr r1, =(0x0802d6d6 +1)
	bx r1
	
Random:
	ldr r2, =(0x08044ec8 +1)
	b jump_r2	
	
Divide:
	ldr r2, =(0x081e4018 +1)
	
jump_r2:
	bx r2
	
CheckFlag:
	ldr r1, =(0x0806e6d0 +1)
	bx r1
	
GetLocalDexCount:
	ldr r4, =(0x08088edc +1)
	bx r4
	
GetNationalDexCount:
	ldr r4, =(0x08088e8c +1)
	bx r4
		
.align 2
.ScriptPointer:	.word 0x02023d74
.TrainerData:	.word 0x0300500c
	
	
/* battle script example:

#org @start
setword 0x0203c020 0x08xxxxxx		//custom critical capture string
jumpifhalfword 0x0 0x2023D68 0x5 @safari
cmd60 0xB
printstring 0x184
goto 0x8165781

#org @safari
printstring 0x184
goto 0x81D9A53     //catch pokemon

*/

A little info on how it works:

• The critical catch rate is determined by the number of pokemon registered in the pokedex, with >600 being the highest bracket.
• I broke the values from here into rough fractions of the total number of pokemon in the game, which I rounded to 800. so >75% is the highest multiplier, then 9/16ths (450/800), and so on.
• Let's call this multiplier y
• The number of registered pokemon is obtained, and each bracket is checked. Then, a random value is compared to the 'critical catch rate, x, where x = a*y / 6.
• Note: I divide by 60 in the routine because each y is a multiple of 10 (eg. 2.5x = 25).
• If this random value, rand(0,255) < x, critical capture occurs.
• If critical capture occurs, a new random value is obtained, rand(0,255), and compared to the original catch rate, a. if rand(0,255) < a, critical capture is a success. Otherwise, the pokemon breaks out after a single shake.

So just change the ldr r6, =(0x00000xxx) to the size of your pokedex in hex, and fix the pointer at the end to your custom critical capture battle script, and you are good to go! Also feel free to tamper with the formula, obviously.

 

[AkameTheBulbasaur]

So I've figured out how to add a new animation for critical captures.

There's a table at 0x1C6F18 that has a bunch of pointers to animations. The important one is the third entry, 0x1D64F9, which is the PokeBall throwing animation.

You can repoint this table and add a new entry for your new animation.

I used a small routine to actually reroute the game to play your new animation.

Spoiler:

/*Put 00 48 00 47 XX XX XX 08 at 0x327D8*/
.text
.align 2
.thumb
.thumb_func

Main:
lsl r2, r2, #0x18
lsr r2, r2, #0x18
mov r0, r4
mov r1, r4

CheckVar:
push {r1-r2}
ldr r2, .Var8010
ldrh r2, [r2]
cmp r2, #0x1
beq Animation
b Return1

Animation:
mov r3, #0x9
ldr r2, .Var8010
mov r1, #0x0
strh r1, [r2]
pop {r1-r2}
ldr r4, .Address2
bx r4

Return1:
pop {r1-r2}
ldr r3, .Address1
bx r3

.align 2
.Var8010: .word 0x020370D6
.Address1: .word 0x080327E1
.Address2: .word 0x080327E3

Essentially the way this works is you put a 1 into 0x020370D6. This is the RAM for the temporary var 8010. This will stay the same throughout the battle, so you can set this to 1 during the catch rate routine and then it will know to play the other animation. I picked 8010 for this because it was a var I thought most people wouldn't need to actually use. This, of course, can be changed for some other piece of RAM, but do so at your own risk.

Now for the animation, I just used the default animation, but changed the "19 36 00" to "19 BB AA" where AABB is the sound you want the game to play.

For good measure, I also made a routine for determining guaranteed capture. It's based on the difference between your Speed and the foe's Speed. In other words, if you have a much higher Speed than the wild Pokemon, there is a chance for a guaranteed capture (regardless of Poke Ball) that approached 50%.

For example, if you and the wild Pokemon have the exact same Speed stat, the chance will be 25%.

Spoiler:

/*Put 00 48 00 47 XX XX XX 08 at 0x2D77C*/
.text
.align 2
.thumb
.thumb_func
.global SpeedCapture

CompareCatchRate:
cmp r4, #0x4
beq Guarantee

GetSpeed:
/*The Speed stats are put into r4 and r5*/
/*Yours in r4*/
/*Theirs in r5*/
push {r0-r6}
push {r4}
ldr r0, .FirstPoke
mov r1, #0x3D
bl Decrypt
mov r4, r0
ldr r0, .WildPoke
mov r1, #0x3D
bl Decrypt
mov r5, r0

GetNumber:
bl RNG
lsl r0, r0, #0x10
mov r1, #0xFF
lsl r1, r1, #0x10
and r1, r0
lsr r1, r1, #0x10
mov r6, r1

GetRatio:
/*Divides r4/r5*/
/*Then divides by 4*/
/*If < 1 sets to 1, if > 50 sets to 50*/
mov r1, #0x64
mul r4, r1
mov r0, r4
mov r1, r5
bl Divide
mov r1, #0x4
bl Divide
cmp r0, #0x0
beq SetToOne
cmp r0, #0x32
bgt SetTo50
b Other

SetToOne:
mov r5, #0x1
b StatBoost

SetTo50:
mov r5, #0x7F
b StatBoost

Other:
/*Changes the percent to out of 255*/
/*Multiplies it by 255 then divides by 100*/
cmp r3, #0xFF
ble Next
mov r3, #0xFF

Next:
mov r2, #0xFF
mul r3, r2
mov r0, r3
mov r1, #0x64
bl Divide
mov r5, r0

StatBoost:
/*Currently the RNG number is r6*/
/*The percent out of 255 is r5*/
/*Then the Speed Boosts are r3*/
ldr r0, .UserBank
ldr r1, .Attacker
ldrb r1, [r1]
mov r2, #0x58
mul r1, r2
add r0, r0, r1
ldrb r3, [r0, #0x1B]
sub r3, r3, #0x6
add r5, r5, r3

Chance:
cmp r6, r5
ble SetVar
b Return

SetVar:
/*Sets the temporary variable 0x8010 to 1*/
/*This will let the game know*/
/*to use a different animation later*/
pop {r4}
ldr r0, .Var8010
mov r1, #0x1
strh r1, [r0]
pop {r0-r6}
mov r4, #0x4

Guarantee:
ldr r1, .LoadScript
ldr r0, .BattleScript
str r0, [r1]
mov r0, #0x0
mov r1, #0x4
bl StoreThing
ldr r0, .RAM
ldrb r0, [r0]
bl Thing2
ldr r0, .Return
bx r0

StoreThing:
ldr r2, .RAM2
bx r2

Thing2:
ldr r2, .RAM3
bx r2

Return:
pop {r4}
pop {r0-r6}
ldr r0, .Return2
bx r0

RNG:
ldr r2, .RNG
bx r2

Decrypt:
ldr r3, .Decrypter
bx r3

Divide:
ldr r2, .Divider
bx r2

.align 2
.FirstPoke: .word 0x02024284
.WildPoke: .word 0x0202402C
.Decrypter: .word 0x0803FBE9
.Divider: .word 0x081E4019
.UserBank: .word 0x02023BE4
.Attacker: .word 0x02023D6B
.Return: .word 0x0802D787
.Return2: .word 0x0802D7E5
.LoadScript: .word 0x02023D74
.BattleScript: .word 0x081D9A42
.Var8010: .word 0x020370D6
.RNG: .word 0x08044EC9
.RAM: .word 0x02023BC4
.RAM2: .word 0x0800E195
.RAM3: .word 0x08017249

 

[ghoulslash]

Awesome work, Akame! Here's a bit more info on the copied animation at 1d64f9:

03 91 F4 0E 08 02 00 04 00    -> call task 080ef490
19 36 00 00 				-> play throw pokeball sound (0x36)
03 AD F5 0E 08 02 00 		-> 080ef5ac  -> must somehow related to catching
03 E1 F4 0E 08 02 00 		-> call task 080ef4e0 (check trainer block vs. dodgeball indices)
21 07 FF FF 2D 65 1D 08   -> jump to 1d652d if trainer deflection
21 07 FE FF 55 65 1D 08   -> jump to 1d6555 if dodging animation
05 
03 B9 F4 0E 08 02 00   -> call task 080ef4b8
08

Task 080ef5ac loads the ball object table/ball ID, and has a BL to 08074480. This routine looks like so:

08074480 b530 push {r4,r5,lr}
08074482 0600 lsl r0, r0, #0x18
08074484 0e05 lsr r5, r0, #0x18
08074486 0609 lsl r1, r1, #0x18
08074488 0e0c lsr r4, r1, #0x18
0807448a 2c04 cmp r4, #0x4
0807448c d838 bhi $08074500	  @table limiter or catch index limiter?
0807448e 00a0 lsl r0, r4, #0x02
08074490 4901 ldr r1, [$08074498] (=$0807449c)
08074492 1840 add r0, r0, r1
08074494 6800 ldr r0, [r0, #0x0]
08074496 4687 mov pc, r0

The table at 7449c: (I think a routine is loaded based on the catch index?)
080744b0
080744d8 -> these first three routines appear to load a byte from some table at 3ae01c, not sure what it does
080744b0
08074500 -> my hunch is that this routine results in actually catching the pokemon
08074500:

Spoiler:

08074500 1c28 add r0, r5, #0x0	@I think this holds anim_defender?
08074502 f000 bl $080751c4		@battle_side_get_owner
08074506 0600 lsl r0, r0, #0x18
08074508 2800 cmp r0, #0x0
0807450a d015 beq $08074538
0807450c 4807 ldr r0, [$0807452c] (=$02024018)	@dp11_
0807450e 6800 ldr r0, [r0, #0x0]
08074510 6801 ldr r1, [r0, #0x0]
08074512 00a8 lsl r0, r5, #0x02
08074514 1841 add r1, r0, r1
08074516 8848 ldrh r0, [r1, #0x2]	@?
08074518 2800 cmp r0, #0x0
0807451a d129 bne $08074570
0807451c 4904 ldr r1, [$08074530] (=$02023bce)	@b_intra_team_id_by_side
0807451e 0068 lsl r0, r5, #0x01
08074520 1840 add r0, r0, r1
08074522 8801 ldrh r1, [r0, #0x0]
08074524 2064 mov r0, #0x64
08074526 4348 mul r0, r1
08074528 4902 ldr r1, [$08074534] (=$0202402c)	@enemy data
0807452a e014 b $08074556

08074556 1840 add r0, r0, r1
08074558 210b mov r1, #0xb
0807455a f7cb bl $0803fbe8	@get species
0807455e 0400 lsl r0, r0, #0x10
08074560 0c01 lsr r1, r0, #0x10
08074562 e006 b $08074572

08074570 8849 ldrh r1, [r1, #0x2]
08074572 2c03 cmp r4, #0x3
08074574 d102 bne $0807457c
08074576 1c28 add r0, r5, #0x0
08074578 2201 mov r2, #0x1           @my hunch is that this (vs. the mov r2, #0x0) relates to actually catching
0807457a e001 b $08074580
0807457c 1c28 add r0, r5, #0x0
0807457e 2200 mov r2, #0x0
08074580 f000 bl $080747ac       @does something with personality ID
08074584 0600 lsl r0, r0, #0x18
08074586 0e00 lsr r0, r0, #0x18
08074588 bc30 pop {r4,r5}
0807458a bc02 pop {r1}
0807458c 4708 bx r1

I haven't messed around too much with these routines, but I am fairly confident that 080ef5ac determines the shake animations.