Merge pull request #3 from PikalaxALT/field_map_obj

Field map obj

5 files changed, 3423 insertions, 313 deletions

diff --git a/src/battle_2.c b/src/battle_2.c
index a9f0fd57a..f2ce737d6 100644
--- a/src/battle_2.c
+++ b/src/battle_2.c
@@ -1,4 +1,5 @@
 #include "global.h"
+#include "asm.h"
 #include "battle.h"
 #include "main.h"
 #include "text.h"
@@ -10,6 +11,16 @@
 #include "link.h"
 #include "name_string_util.h"
 #include "battle_setup.h"
+#include "rng.h"
+#include "sound.h"
+#include "songs.h"
+#include "trig.h"
+#include "abilities.h"
+
+struct MonCoords
+{
+    u8 x, y;
+};
 
 struct UnknownStruct5
 {
@@ -55,35 +66,198 @@ struct UnknownPokemonStruct2
     /*0x1D*/ u8 language;
 };
 
+struct UnknownStruct9
+{
+    u8 unk0;
+    u16 unk2;
+};
+
+struct UnknownStruct10
+{
+    u8 unk0_0:1;
+    u8 unk0_1:1;
+    u8 unk0_2:1;
+    u8 filler1[1];
+    u8 unk2;
+    u8 unk3;
+    u8 filler4[8];
+};
+
+struct UnknownStruct11
+{
+    u8 unk0;
+    u8 unk1;
+    u8 unk2;
+    u8 unk3;
+    u8 unk4;
+    u8 unk5_0:1;
+    u8 unk5_1:1;
+    u16 unk6;
+    u8 unk8[10];
+    u8 unk12;
+    u8 unk13;
+    u8 unk14[10];
+    u8 filler1E[2];
+    u16 unk20;
+    u16 unk22;
+    u16 unk24;
+    u16 unk26;
+    u16 unk28;
+    u8 unk2A[10];
+    u8 filler34[2];
+    u8 unk36[10];
+};
+
+struct UnknownStruct12
+{
+    u32 unk0;
+    u8 filler4[0x54];
+};
+
+struct UnknownStruct13
+{
+    u32 unk0_0:1;
+    u32 unk0_1:1;
+    u32 unk0_2:1;
+    u32 unk0_3:1;
+    u32 unk0_4:1;
+    u32 unk0_5:1;
+    u32 unk0_6:1;
+    u32 unk0_7:1;
+    u32 unk1_0:1;
+    u32 unk1_1:1;
+    u32 unk1_2:1;
+    u32 unk1_3:2;
+    u32 unk1_5:1;
+    u32 unk1_6:1;
+    u32 unk1_7:1;
+    u32 unk2_0:1;
+    u32 unk2_1:1;
+    u32 unk2_2:1;
+    u32 unk2_3:1;
+    u8 filler4[12];
+};
+
 extern const struct UnknownStruct5 gUnknown_081F9674;
 extern const u8 gUnknown_081F96C8[];
+extern void *const gUnknown_081FAF4C[];
+extern const u16 gUnknown_08D004E0[];
 extern const struct Trainer gTrainers[];
 extern const u8 gSpeciesNames[][11];
 extern const struct BattleMove gBattleMoves[];
+extern const struct MonCoords gMonFrontPicCoords[];
+extern const struct MonCoords gCastformFrontSpriteCoords[];
+extern const struct BaseStats gBaseStats[];
+extern const u32 gBitTable[];
 
 extern u8 ewram[];
 #define ewram0 (*(struct UnknownStruct7 *)(ewram + 0x0))
 #define ewram4 (*(struct UnknownStruct8 *)(ewram + 0x4))
+#define ewram16000 (ewram[0x16000])
+#define ewram16001 (ewram[0x16001])
+#define ewram16002 (ewram[0x16002])
+#define ewram16003 (ewram[0x16003])
+#define ewram1600C (ewram[0x1600C])
+#define ewram1600E (ewram[0x1600E])
+#define ewram1601B (ewram[0x1601B])
+#define ewram16020 ((u8 *)(ewram + 0x16020))
+#define ewram16056 (ewram[0x16056])
+#define ewram16058 (ewram[0x16058])
+#define ewram16059 (ewram[0x16059])
+#define ewram16078 (ewram[0x16078])
+#define ewram16084 (ewram[0x16084])
+#define ewram16086 (ewram[0x16086])
+#define ewram16087 (ewram[0x16087])
+#define ewram16088 (ewram[0x16088])
+#define ewram16089 (ewram[0x16089])
+#define ewram160A1 (ewram[0x160A1])
+#define ewram160A6 (ewram[0x160A6])
+#define ewram160AC ((u8 *)(ewram + 0x160AC))
+#define ewram160BC ((u16 *)(ewram + 0x160BC))  // hp
+#define ewram160C8 (ewram[0x160C8])
+#define ewram160C9 (ewram[0x160C9])
 #define ewram160CB (ewram[0x160CB])
+#define ewram160CC ((u8 *)(ewram + 0x160CC))
+#define ewram160E6 (ewram[0x160E6])
+#define ewram160E8 ((u8 *)(ewram + 0x160E8))
+#define ewram160F0 ((u8 *)(ewram + 0x160F0))
+#define ewram160F9 (ewram[0x160F9])
+#define ewram16100 ((u8 *)(ewram + 0x16100))
+#define ewram16108 ((u8 *)(ewram + 0x16108))
+#define ewram16110 (ewram[0x16110])
+#define ewram16111 (ewram[0x16111])
+#define ewram16113 (ewram[0x16113])
+#define ewram17100 ((u32 *)(ewram + 0x17100))
+#define ewram17130 (ewram[0x17130])
+#define ewram17160 (ewram[0x17160])
+#define ewram17800 ((struct UnknownStruct9 *)(ewram + 0x17800))
+#define ewram17810 ((struct UnknownStruct10 *)(ewram + 0x17810))
 #define ewram1D000 ((struct Pokemon *)(ewram + 0x1D000))
 
 extern struct UnknownPokemonStruct2 gUnknown_02023A00[];
+extern u8 gUnknown_02024260[][0x200];
+extern u8 gUnknown_02024A60;
+extern u32 gUnknown_02024A64;
+extern u8 gUnknown_02024A68;
+extern u16 gUnknown_02024A6A[];
+extern u8 gUnknown_02024A7F;
+extern u8 gUnknown_02024A7A[];
+extern struct UnknownStruct12 gUnknown_02024AD0[];
+extern u8 gUnknown_02024BE0[];
+extern u16 gUnknown_02024BE6;
+extern u8 byte_2024C06;
+extern u8 gUnknown_02024C0B;
+extern u8 gUnknown_02024C0C;
+extern u8 gUnknown_02024C0E;
+extern u8 gUnknown_02024C18[];
+extern u16 gUnknown_02024C2C[];
+extern u16 gUnknown_02024C34[];
+extern u16 gUnknown_02024C3C[];
+extern u16 gUnknown_02024C44[];
+extern u16 gUnknown_02024C4C[];
+extern u16 gUnknown_02024C54[];
+extern u8 gUnknown_02024C5C[];
+extern u16 gUnknown_02024C60[];
+extern u32 gUnknown_02024C6C;
+extern u8 gUnknown_02024C70[];
+extern u16 gUnknown_02024C7A[];
+extern u8 gUnknown_02024C80[][12];
+extern u32 gUnknown_02024C98[];
+//extern u8 gUnknown_02024CA8[][0x1C];
+extern u16 gUnknown_02024D18;
+extern u16 gUnknown_02024D1A;
+extern u16 gUnknown_02024D1C;
 extern u8 gUnknown_02024D1E[];
 extern u8 gUnknown_02024D1F[];  // I don't actually know what type this is.
+extern u8 gUnknown_02024D26;
+extern struct UnknownStruct13 gUnknown_02024D28[];
+extern u8 gUnknown_02024DBC[];
+extern u16 gUnknown_02024DE8;
+extern u8 gUnknown_02024E60[];
+extern u8 gUnknown_02024E64[];
+extern u8 gUnknown_02038470[];
 extern u16 gUnknown_030041B0;
 extern u16 gUnknown_030041B4;
 extern u16 gUnknown_030041B8;
 extern struct Window gUnknown_030041D0;
+extern u16 gUnknown_03004200;
 extern struct Window gUnknown_03004210;
+extern u16 gUnknown_03004244;
 extern struct Window gUnknown_03004250;
 extern u16 gUnknown_03004240;
 extern u16 gUnknown_03004280;
+extern u32 gUnknown_03004284;
 extern u16 gUnknown_03004288;
 extern u16 gUnknown_030042A0;
 extern u16 gUnknown_030042A4;
 extern u16 gUnknown_030042C0;
 extern u16 gUnknown_030042C4;
 extern MainCallback gUnknown_030042D0;
+extern void (*gUnknown_030042D4)(void);
+extern struct UnknownStruct11 gUnknown_030042E0;
+extern u8 gUnknown_03004324;
+extern void (*gUnknown_03004330[])(void);
+extern u8 gUnknown_03004340[];
 extern struct UnknownStruct6 gUnknown_03004DE0;
 //extern u16 gUnknown_03004DE0[][0xA0];  // possibly?
 extern u16 gBattleTypeFlags;
@@ -92,6 +266,13 @@ extern u8 gReservedSpritePaletteCount;
 extern u16 gTrainerBattleOpponent;
 extern struct BattleEnigmaBerry gEnigmaBerries[];
 extern u16 gBlockRecvBuffer[MAX_LINK_PLAYERS][BLOCK_BUFFER_SIZE / 2];
+extern u8 gBattleMonForms[];
+extern u8 gPlayerMonIndex;
+extern u8 gEnemyMonIndex;
+extern u16 gBattleWeather;
+extern u32 gBattleMoveDamage;
+extern struct BattlePokemon gBattleMons[];
+extern u8 gBattleMoveFlags;
 
 extern void sub_800B858(void);
 extern void dp12_8087EA4(void);
@@ -106,6 +287,29 @@ extern void sub_800DE30(u8);
 extern void sub_800B950(void);
 extern u8 battle_load_something();
 extern void OpenPartyMenu();
+extern void sub_8089668();
+extern void sub_800D74C();
+extern void sub_804777C(u8);
+extern void sub_8043DFC();
+extern u8 CreateInvisibleSpriteWithCallback(void (*)(struct Sprite *));
+extern void dp01_build_cmdbuf_x00_a_b_0(u8 a, u8 b, u8 c);
+extern void dp01_build_cmdbuf_x04_4_4_4(u8 a);
+extern void dp01_build_cmdbuf_x07_7_7_7(u8 a);
+extern void dp01_build_cmdbuf_x12_a_bb(u8 a, u8 b, u16 c);
+extern void dp01_build_cmdbuf_x2E_a(u8 a, u8 b);
+extern void dp01_build_cmdbuf_x2F_2F_2F_2F(u8 a);
+extern void dp01_build_cmdbuf_x30_TODO(u8 a, u8 *b, u8 c);
+extern void dp01_battle_side_mark_buffer_for_execution();
+extern u8 sub_8090D90();
+extern void sub_800C704(u8, u8, u8);
+extern u8 sub_8018324();
+extern u8 sub_801A02C();
+extern u8 sub_8015DFC();
+extern u8 sub_8016558();
+extern u8 sub_80173A4();
+extern u8 sub_80170DC();
+extern u8 ItemId_GetHoldEffect(u16);
+extern void sub_8094C98();
 
 void sub_800E7F8(void);
 void sub_800EC9C(void);
@@ -116,6 +320,40 @@ void sub_800F838(struct Sprite *);
 u8 CreateNPCTrainerParty(struct Pokemon *, u16);
 void sub_800FCFC(void);
 void sub_8010824(void);
+void sub_80101B8(void);
+void c2_081284E0(void);
+void sub_8010278(struct Sprite *);
+void sub_80102AC(struct Sprite *);
+void nullsub_37(struct Sprite *);
+void sub_8010320(struct Sprite *);
+void sub_8010494(struct Sprite *);
+void sub_801053C(struct Sprite *);
+void oac_poke_ally_(struct Sprite *);
+void nullsub_86(struct Sprite *);
+void objc_dp11b_pingpong(struct Sprite *);
+void sub_8010874(void);
+void bc_8012FAC(void);
+void bc_load_battlefield(void);
+void sub_8011384(void);
+void bc_801333C(void);
+void bc_battle_begin_message(void);
+void bc_8013568(void);
+void sub_8011800(void);
+void sub_8011834(void);
+void bc_801362C(void);
+void sub_8011970(void);
+void sub_80119B4(void);
+void sub_8011B00(void);
+void sub_8011E8C(void);
+void sub_8012324(void);
+void sub_8012FBC(u8, u8);
+u8 b_first_side();
+void sub_801365C(u8);
+void sub_801377C(void);
+void sub_80138F0(void);
+void b_cancel_multi_turn_move_maybe(u8);
+void b_std_message();
+void sub_80156DC();
 
 void sub_800E7C4(void)
 {
@@ -565,25 +803,42 @@ void sub_800F298(void)
     BuildOamBuffer();
     switch (gUnknown_02024D1E[0])
     {
-        case 0:
-            if (gReceivedRemoteLinkPlayers != 0 && sub_8007ECC())
+    case 0:
+        if (gReceivedRemoteLinkPlayers != 0 && sub_8007ECC())
+        {
+            ewram0.unk0 = 1;
+            ewram0.unk1 = 1;
+            sub_800E9EC();
+            sub_800EAAC();
+            SendBlock(bitmask_all_link_players_but_self(), ewram, 0x20);
+            gUnknown_02024D1E[0]++;
+        }
+        break;
+    case 1:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            u8 taskId;
+
+            ResetBlockReceivedFlags();
+            id = 0;
+            if (gBlockRecvBuffer[0][0] == 0x100)
             {
-                ewram0.unk0 = 1;
-                ewram0.unk1 = 1;
-                sub_800E9EC();
-                sub_800EAAC();
-                SendBlock(bitmask_all_link_players_but_self(), ewram, 0x20);
-                gUnknown_02024D1E[0]++;
+                if (playerId == 0)
+                    gBattleTypeFlags |= 12;
+                else
+                    gBattleTypeFlags |= 8;
+                id++;
             }
-            break;
-        case 1:
-            if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+            if (id == 0)
             {
-                u8 taskId;
+                s32 i;
 
-                ResetBlockReceivedFlags();
-                id = 0;
-                if (gBlockRecvBuffer[0][0] == 0x100)
+                for (i = 0; i < MAX_LINK_PLAYERS; i++)
+                {
+                    if (gBlockRecvBuffer[0][0] != gBlockRecvBuffer[i][0])
+                        break;
+                }
+                if (i == MAX_LINK_PLAYERS)
                 {
                     if (playerId == 0)
                         gBattleTypeFlags |= 12;
@@ -593,231 +848,214 @@ void sub_800F298(void)
                 }
                 if (id == 0)
                 {
-                    s32 i;
-
-                    for (i = 0; i < MAX_LINK_PLAYERS; i++)
+                    while (id < MAX_LINK_PLAYERS)
                     {
-                        if (gBlockRecvBuffer[0][0] != gBlockRecvBuffer[i][0])
+                        if (gBlockRecvBuffer[id][0] == 0x0101 && id != playerId)
+                            if (id < playerId)
+                                break;
+                        if (gBlockRecvBuffer[id][0] > 0x0101 && id != playerId)
                             break;
-                    }
-                    if (i == MAX_LINK_PLAYERS)
-                    {
-                        if (playerId == 0)
-                            gBattleTypeFlags |= 12;
-                        else
-                            gBattleTypeFlags |= 8;
                         id++;
                     }
-                    if (id == 0)
-                    {
-                        while (id < MAX_LINK_PLAYERS)
-                        {
-                            if (gBlockRecvBuffer[id][0] == 0x0101 && id != playerId)
-                                if (id < playerId)
-                                    break;
-                            if (gBlockRecvBuffer[id][0] > 0x0101 && id != playerId)
-                                break;
-                            id++;
-                        }
-                        if (id == MAX_LINK_PLAYERS)
-                            gBattleTypeFlags |= 12;
-                        else
-                            gBattleTypeFlags |= 8;
-                    }
+                    if (id == MAX_LINK_PLAYERS)
+                        gBattleTypeFlags |= 12;
+                    else
+                        gBattleTypeFlags |= 8;
+                }
+            }
+            sub_800EB08();
+            memcpy(ewram1D000, gPlayerParty, sizeof(struct Pokemon) * 3);
+            taskId = CreateTask(sub_800DE30, 0);
+            gTasks[taskId].data[1] = 0x10E;
+            gTasks[taskId].data[2] = 0x5A;
+            gTasks[taskId].data[5] = 0;
+            gTasks[taskId].data[3] = 0;
+            gTasks[taskId].data[4] = 0;
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            {
+                switch (gLinkPlayers[id].lp_field_18)
+                {
+                case 0:
+                    gTasks[taskId].data[3] |= gBlockRecvBuffer[id][1] & 0x3F;
+                    break;
+                case 1:
+                    gTasks[taskId].data[4] |= gBlockRecvBuffer[id][1] & 0x3F;
+                    break;
+                case 2:
+                    gTasks[taskId].data[3] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
+                    break;
+                case 3:
+                    gTasks[taskId].data[4] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
+                    break;
                 }
-                sub_800EB08();
-                memcpy(ewram1D000, gPlayerParty, sizeof(struct Pokemon) * 3);
-                taskId = CreateTask(sub_800DE30, 0);
-                gTasks[taskId].data[1] = 0x10E;
-                gTasks[taskId].data[2] = 0x5A;
-                gTasks[taskId].data[5] = 0;
-                gTasks[taskId].data[3] = 0;
-                gTasks[taskId].data[4] = 0;
-                for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            }
+            ZeroPlayerPartyMons();
+            ZeroEnemyPartyMons();
+            gUnknown_02024D1E[0]++;
+            goto step_2;
+        }
+        break;
+    case 2:
+      step_2:
+        if (sub_8007ECC())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), ewram1D000, sizeof(struct Pokemon) * 2);
+            gUnknown_02024D1E[0]++;
+        }
+        break;
+    case 3:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            {
+                if (id == playerId)
                 {
                     switch (gLinkPlayers[id].lp_field_18)
                     {
-                        case 0:
-                            gTasks[taskId].data[3] |= gBlockRecvBuffer[id][1] & 0x3F;
-                            break;
-                        case 1:
-                            gTasks[taskId].data[4] |= gBlockRecvBuffer[id][1] & 0x3F;
-                            break;
-                        case 2:
-                            gTasks[taskId].data[3] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
-                            break;
-                        case 3:
-                            gTasks[taskId].data[4] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
-                            break;
+                    case 0:
+                    case 3:
+                        memcpy(gPlayerParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                        break;
+                    case 1:
+                    case 2:
+                        memcpy(gPlayerParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                        break;
                     }
                 }
-                ZeroPlayerPartyMons();
-                ZeroEnemyPartyMons();
-                gUnknown_02024D1E[0]++;
-                goto step_2;
-            }
-            break;
-        case 2:
-          step_2:
-            if (sub_8007ECC())
-            {
-                SendBlock(bitmask_all_link_players_but_self(), ewram1D000, sizeof(struct Pokemon) * 2);
-                gUnknown_02024D1E[0]++;
-            }
-            break;
-        case 3:
-            if ((GetBlockReceivedStatus() & 0xF) == 0xF)
-            {
-                ResetBlockReceivedFlags();
-                for (id = 0; id < MAX_LINK_PLAYERS; id++)
+                else
                 {
-                    if (id == playerId)
+                    if ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerId].lp_field_18 & 1))
+                     || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerId].lp_field_18 & 1)))
                     {
                         switch (gLinkPlayers[id].lp_field_18)
                         {
-                            case 0:
-                            case 3:
-                                memcpy(gPlayerParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                break;
-                            case 1:
-                            case 2:
-                                memcpy(gPlayerParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                break;
+                        case 0:
+                        case 3:
+                            memcpy(gPlayerParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                            break;
+                        case 1:
+                        case 2:
+                            memcpy(gPlayerParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                            break;
                         }
                     }
                     else
                     {
-                        if ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerId].lp_field_18 & 1))
-                         || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerId].lp_field_18 & 1)))
-                        {
-                            switch (gLinkPlayers[id].lp_field_18)
-                            {
-                                case 0:
-                                case 3:
-                                    memcpy(gPlayerParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                    break;
-                                case 1:
-                                case 2:
-                                    memcpy(gPlayerParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                    break;
-                            }
-                        }
-                        else
+                        switch (gLinkPlayers[id].lp_field_18)
                         {
-                            switch (gLinkPlayers[id].lp_field_18)
-                            {
-                                case 0:
-                                case 3:
-                                    memcpy(gEnemyParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                    break;
-                                case 1:
-                                case 2:
-                                    memcpy(gEnemyParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
-                                    break;
-                            }
+                        case 0:
+                        case 3:
+                            memcpy(gEnemyParty, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                            break;
+                        case 1:
+                        case 2:
+                            memcpy(gEnemyParty + 3, gBlockRecvBuffer[id], sizeof(struct Pokemon) * 2);
+                            break;
                         }
                     }
                 }
-                gUnknown_02024D1E[0]++;
             }
-            break;
-        case 4:
-            if (sub_8007ECC())
-            {
-                SendBlock(bitmask_all_link_players_but_self(), ewram1D000 + 2, sizeof(struct Pokemon));
-                gUnknown_02024D1E[0]++;
-            }
-            break;
-        case 5:
-            if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+            gUnknown_02024D1E[0]++;
+        }
+        break;
+    case 4:
+        if (sub_8007ECC())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), ewram1D000 + 2, sizeof(struct Pokemon));
+            gUnknown_02024D1E[0]++;
+        }
+        break;
+    case 5:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
             {
-                ResetBlockReceivedFlags();
-                for (id = 0; id < MAX_LINK_PLAYERS; id++)
+                if (id == playerId)
+                {
+                    switch (gLinkPlayers[id].lp_field_18)
+                    {
+                    case 0:
+                    case 3:
+                        memcpy(gPlayerParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                        break;
+                    case 1:
+                    case 2:
+                        memcpy(gPlayerParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                        break;
+                    }
+                }
+                else
                 {
-                    if (id == playerId)
+                    if ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerId].lp_field_18 & 1))
+                     || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerId].lp_field_18 & 1)))
                     {
                         switch (gLinkPlayers[id].lp_field_18)
                         {
-                            case 0:
-                            case 3:
-                                memcpy(gPlayerParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                break;
-                            case 1:
-                            case 2:
-                                memcpy(gPlayerParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                break;
+                        case 0:
+                        case 3:
+                            memcpy(gPlayerParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                            break;
+                        case 1:
+                        case 2:
+                            memcpy(gPlayerParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                            break;
                         }
                     }
                     else
                     {
-                        if ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerId].lp_field_18 & 1))
-                         || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerId].lp_field_18 & 1)))
-                        {
-                            switch (gLinkPlayers[id].lp_field_18)
-                            {
-                                case 0:
-                                case 3:
-                                    memcpy(gPlayerParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                    break;
-                                case 1:
-                                case 2:
-                                    memcpy(gPlayerParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                    break;
-                            }
-                        }
-                        else
+                        switch (gLinkPlayers[id].lp_field_18)
                         {
-                            switch (gLinkPlayers[id].lp_field_18)
-                            {
-                                case 0:
-                                case 3:
-                                    memcpy(gEnemyParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                    break;
-                                case 1:
-                                case 2:
-                                    memcpy(gEnemyParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
-                                    break;
-                            }
+                        case 0:
+                        case 3:
+                            memcpy(gEnemyParty + 2, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                            break;
+                        case 1:
+                        case 2:
+                            memcpy(gEnemyParty + 5, gBlockRecvBuffer[id], sizeof(struct Pokemon));
+                            break;
                         }
                     }
                 }
+            }
 
-                shedinja_something(&gPlayerParty[0]);
-                shedinja_something(&gPlayerParty[1]);
-                shedinja_something(&gPlayerParty[2]);
-                shedinja_something(&gPlayerParty[3]);
-                shedinja_something(&gPlayerParty[4]);
-                shedinja_something(&gPlayerParty[5]);
+            shedinja_something(&gPlayerParty[0]);
+            shedinja_something(&gPlayerParty[1]);
+            shedinja_something(&gPlayerParty[2]);
+            shedinja_something(&gPlayerParty[3]);
+            shedinja_something(&gPlayerParty[4]);
+            shedinja_something(&gPlayerParty[5]);
 
-                shedinja_something(&gEnemyParty[0]);
-                shedinja_something(&gEnemyParty[1]);
-                shedinja_something(&gEnemyParty[2]);
-                shedinja_something(&gEnemyParty[3]);
-                shedinja_something(&gEnemyParty[4]);
-                shedinja_something(&gEnemyParty[5]);
+            shedinja_something(&gEnemyParty[0]);
+            shedinja_something(&gEnemyParty[1]);
+            shedinja_something(&gEnemyParty[2]);
+            shedinja_something(&gEnemyParty[3]);
+            shedinja_something(&gEnemyParty[4]);
+            shedinja_something(&gEnemyParty[5]);
 
-                gUnknown_02024D1E[0]++;
-            }
-            break;
-        case 6:
-            sub_800B950();
             gUnknown_02024D1E[0]++;
-            gUnknown_02024D1E[1] = 0;
-            gUnknown_02024D1E[2] = 0;
-            break;
-        case 7:
-            if (battle_load_something(gUnknown_02024D1F, gUnknown_02024D1F + 1) != 0)
+        }
+        break;
+    case 6:
+        sub_800B950();
+        gUnknown_02024D1E[0]++;
+        gUnknown_02024D1E[1] = 0;
+        gUnknown_02024D1E[2] = 0;
+        break;
+    case 7:
+        if (battle_load_something(gUnknown_02024D1F, gUnknown_02024D1F + 1) != 0)
+        {
+            gUnknown_030042D0 = gMain.callback1;
+            gMain.callback1 = sub_8010824;
+            SetMainCallback2(sub_800F808);
+            if (gBattleTypeFlags & BATTLE_TYPE_LINK)
             {
-                gUnknown_030042D0 = gMain.callback1;
-                gMain.callback1 = sub_8010824;
-                SetMainCallback2(sub_800F808);
-                if (gBattleTypeFlags & BATTLE_TYPE_LINK)
-                {
-                    gTrainerBattleOpponent = 0x800;
-                    gBattleTypeFlags |= BATTLE_TYPE_20;
-                }
+                gTrainerBattleOpponent = 0x800;
+                gBattleTypeFlags |= BATTLE_TYPE_20;
             }
-            break;
+        }
+        break;
     }
 }
 
@@ -842,42 +1080,42 @@ void sub_800F838(struct Sprite *sprite)
 
     switch (sprite->data0)
     {
-        case 0:
-            sprite->data0++;
-            sprite->data1 = 0;
-            sprite->data2 = 0x281;
-            sprite->data3 = 0;
-            sprite->data4 = 1;
-            // fall through
-        case 1:
-            sprite->data4--;
-            if (sprite->data4 == 0)
-            {
-                s32 i;
-                s32 r2;
-                s32 r0;
+    case 0:
+        sprite->data0++;
+        sprite->data1 = 0;
+        sprite->data2 = 0x281;
+        sprite->data3 = 0;
+        sprite->data4 = 1;
+        // fall through
+    case 1:
+        sprite->data4--;
+        if (sprite->data4 == 0)
+        {
+            s32 i;
+            s32 r2;
+            s32 r0;
 
-                sprite->data4 = 2;
-                r2 = sprite->data1 + sprite->data3 * 32;
-                r0 = sprite->data2 - sprite->data3 * 32;
-                for (i = 0; i < 29; i += 2)
-                {
-                    arr[r2 + i] = 0x3D;
-                    arr[r0 + i] = 0x3D;
-                }
-                sprite->data3++;
-                if (sprite->data3 == 21)
-                {
-                    sprite->data0++;
-                    sprite->data1 = 32;
-                }
+            sprite->data4 = 2;
+            r2 = sprite->data1 + sprite->data3 * 32;
+            r0 = sprite->data2 - sprite->data3 * 32;
+            for (i = 0; i < 29; i += 2)
+            {
+                arr[r2 + i] = 0x3D;
+                arr[r0 + i] = 0x3D;
             }
-            break;
-        case 2:
-            sprite->data1--;
-            if (sprite->data1 == 20)
-                SetMainCallback2(sub_800E7C4);
-            break;
+            sprite->data3++;
+            if (sprite->data3 == 21)
+            {
+                sprite->data0++;
+                sprite->data1 = 32;
+            }
+        }
+        break;
+    case 2:
+        sprite->data1--;
+        if (sprite->data1 == 20)
+            SetMainCallback2(sub_800E7C4);
+        break;
     }
 }
 
@@ -910,68 +1148,1454 @@ u8 CreateNPCTrainerParty(struct Pokemon *party, u16 trainerNum)
 
             switch (gTrainers[trainerNum].partyFlags)
             {
-                case 0:
+            case 0:
+            {
+                struct TrainerPartyMember0 *partyData = gTrainers[trainerNum].party;
+
+                for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
+                    nameHash += gSpeciesNames[partyData[i].species][j];
+                personalityValue += nameHash << 8;
+                fixedIV = partyData[i].iv * 31 / 255;
+                CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+                break;
+            }
+            case 1:
+            {
+                struct TrainerPartyMember1 *partyData = gTrainers[trainerNum].party;
+
+                for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
+                    nameHash += gSpeciesNames[partyData[i].species][j];
+                personalityValue += nameHash << 8;
+                fixedIV = partyData[i].iv * 31 / 255;
+                CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+
+                for (j = 0; j < 4; j++)
                 {
-                    struct TrainerPartyMember0 *partyData = gTrainers[trainerNum].party;
+                    SetMonData(&party[i], MON_DATA_MOVE1 + j, (u8 *)&partyData[i].moves[j]);
+                    SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
+                }
+                break;
+            }
+            case 2:
+            {
+                struct TrainerPartyMember2 *partyData = gTrainers[trainerNum].party;
 
-                    for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
-                        nameHash += gSpeciesNames[partyData[i].species][j];
-                    personalityValue += nameHash << 8;
-                    fixedIV = partyData[i].iv * 31 / 255;
-                    CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
-                    break;
+                for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
+                    nameHash += gSpeciesNames[partyData[i].species][j];
+                personalityValue += nameHash << 8;
+                fixedIV = partyData[i].iv * 31 / 255;
+                CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+
+                SetMonData(&party[i], MON_DATA_HELD_ITEM, (u8 *)&partyData[i].heldItem);
+                break;
+            }
+            case 3:
+            {
+                struct TrainerPartyMember3 *partyData = gTrainers[trainerNum].party;
+
+                for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
+                    nameHash += gSpeciesNames[partyData[i].species][j];
+                personalityValue += nameHash << 8;
+                fixedIV = partyData[i].iv * 31 / 255;
+                CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+
+                SetMonData(&party[i], MON_DATA_HELD_ITEM, (u8 *)&partyData[i].heldItem);
+                for (j = 0; j < 4; j++)
+                {
+                    SetMonData(&party[i], MON_DATA_MOVE1 + j, (u8 *)&partyData[i].moves[j]);
+                    SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
                 }
-                case 1:
+                break;
+            }
+            }
+        }
+        gBattleTypeFlags |= gTrainers[trainerNum].doubleBattle;
+    }
+    return gTrainers[trainerNum].partySize;
+}
+
+void sub_800FCD4(void)
+{
+    if (REG_VCOUNT < 0xA0 && REG_VCOUNT >= 0x6F )
+        REG_BG0CNT = 0x9800;
+}
+
+void sub_800FCFC(void)
+{
+    Random();  // unused return value
+    REG_BG0HOFS = gUnknown_030042A4;
+    REG_BG0VOFS = gUnknown_030042A0;
+    REG_BG1HOFS = gUnknown_030042C0;
+    REG_BG1VOFS = gUnknown_030041B4;
+    REG_BG2HOFS = gUnknown_03004288;
+    REG_BG2VOFS = gUnknown_03004280;
+    REG_BG3HOFS = gUnknown_030041B0;
+    REG_BG3VOFS = gUnknown_030041B8;
+    REG_WIN0H = gUnknown_030042C4;
+    REG_WIN0V = gUnknown_03004240;
+    REG_WIN1H = gUnknown_03004200;
+    REG_WIN1V = gUnknown_03004244;
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+    sub_8089668();
+}
+
+void nullsub_36(struct Sprite *sprite)
+{
+}
+
+void sub_800FDB0(struct Sprite *sprite)
+{
+    if (sprite->data0 != 0)
+        sprite->pos1.x = sprite->data1 + ((sprite->data2 & 0xFF00) >> 8);
+    else
+        sprite->pos1.x = sprite->data1 - ((sprite->data2 & 0xFF00) >> 8);
+    sprite->data2 += 0x180;
+    if (sprite->affineAnimEnded)
+    {
+        FreeSpriteTilesByTag(0x2710);
+        FreeSpritePaletteByTag(0x2710);
+        FreeSpriteOamMatrix(sprite);
+        DestroySprite(sprite);
+    }
+}
+
+void sub_800FE20(struct Sprite *sprite)
+{
+    StartSpriteAffineAnim(sprite, 1);
+    sprite->callback = sub_800FDB0;
+    PlaySE(SE_BT_START);
+}
+
+void sub_800FE40(u8 taskId)
+{
+    struct Pokemon *sp4 = NULL;
+    struct Pokemon *sp8 = NULL;
+    u8 r2 = ewram160CB;
+    u32 r7;
+    s32 i;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+    {
+        switch (gLinkPlayers[r2].lp_field_18)
+        {
+        case 0:
+        case 2:
+            sp4 = gPlayerParty;
+            sp8 = gEnemyParty;
+            break;
+        case 1:
+        case 3:
+            sp4 = gEnemyParty;
+            sp8 = gPlayerParty;
+            break;
+        }
+    }
+    else
+    {
+        sp4 = gPlayerParty;
+        sp8 = gEnemyParty;
+    }
+
+    r7 = 0;
+    for (i = 0; i < 6; i++)
+    {
+        u16 species = GetMonData(&sp4[i], MON_DATA_SPECIES2);
+        u16 hp = GetMonData(&sp4[i], MON_DATA_HP);
+        u32 status = GetMonData(&sp4[i], MON_DATA_STATUS);
+
+        if (species == 0)
+            continue;
+        if (species != SPECIES_EGG && hp != 0 && status == 0)
+            r7 |= 1 << i * 2;
+
+        if (species == 0)
+            continue;
+        if (hp != 0 && (species == SPECIES_EGG || status != 0))
+            r7 |= 2 << i * 2;
+
+        if (species == 0)
+            continue;
+        if (species != SPECIES_EGG && hp == 0)
+            r7 |= 3 << i * 2;
+    }
+    gTasks[taskId].data[3] = r7;
+
+    r7 = 0;
+    for (i = 0; i < 6; i++)
+    {
+        u16 species = GetMonData(&sp8[i], MON_DATA_SPECIES2);
+        u16 hp = GetMonData(&sp8[i], MON_DATA_HP);
+        u32 status = GetMonData(&sp8[i], MON_DATA_STATUS);
+
+        if (species == 0)
+            continue;
+        if (species != SPECIES_EGG && hp != 0 && status == 0)
+            r7 |= 1 << i * 2;
+
+        if (species == 0)
+            continue;
+        if (hp != 0 && (species == SPECIES_EGG || status != 0))
+            r7 |= 2 << i * 2;
+
+        if (species == 0)
+            continue;
+        if (species != SPECIES_EGG && hp == 0)
+            r7 |= 3 << i * 2;
+    }
+    gTasks[taskId].data[4] = r7;
+}
+
+void c2_8011A1C(void)
+{
+    s32 i;
+    u8 taskId;
+
+    SetHBlankCallback(NULL);
+    SetVBlankCallback(NULL);
+    CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+    REG_MOSAIC = 0;
+    REG_WIN0H = 0xF0;
+    REG_WIN0V = 0x5051;
+    REG_WININ = 0;
+    REG_WINOUT = 0;
+    gUnknown_030042C4 = 0xF0;
+    gUnknown_03004240 = 0x5051;
+    dp12_8087EA4();
+
+    for (i = 0; i < 80; i++)
+    {
+        gUnknown_03004DE0.unk0[i] = 0xF0;
+        gUnknown_03004DE0.unk780[i] = 0xF0;
+    }
+    for (i = 80; i < 160; i++)
+    {
+        asm(""::"r"(i));  // Needed to stop the compiler from optimizing out the loop counter
+        gUnknown_03004DE0.unk0[i] = 0xFF10;
+        gUnknown_03004DE0.unk780[i] = 0xFF10;
+    }
+    SetUpWindowConfig(&gWindowConfig_81E6C58);
+    ResetPaletteFade();
+    gUnknown_030042A4 = 0;
+    gUnknown_030042A0 = 0;
+    gUnknown_030042C0 = 0;
+    gUnknown_030041B4 = 0;
+    gUnknown_03004288 = 0;
+    gUnknown_03004280 = 0;
+    gUnknown_030041B0 = 0;
+    gUnknown_030041B8 = 0;
+
+    InitWindowFromConfig(&gUnknown_03004210, &gWindowConfig_81E6C58);
+    InitWindowFromConfig(&gUnknown_030041D0, &gWindowConfig_81E71D0);
+    InitWindowFromConfig(&gUnknown_03004250, &gWindowConfig_81E71EC);
+    sub_800D6D4();
+    LoadCompressedPalette(gUnknown_08D004E0, 0, 64);
+    sub_800D74C();
+    ResetSpriteData();
+    ResetTasks();
+    sub_800E23C();
+    REG_WINOUT = 0x37;
+    FreeAllSpritePalettes();
+    gReservedSpritePaletteCount = 4;
+    SetVBlankCallback(sub_800FCFC);
+    taskId = CreateTask(sub_800DE30, 0);
+    gTasks[taskId].data[1] = 0x10E;
+    gTasks[taskId].data[2] = 0x5A;
+    gTasks[taskId].data[5] = 1;
+    sub_800FE40(taskId);
+    SetMainCallback2(sub_80101B8);
+    gUnknown_02024D1E[0] = 0;
+}
+
+void sub_80101B8(void)
+{
+    c2_081284E0();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+    RunTasks();
+}
+
+void c2_081284E0(void)
+{
+    switch (gUnknown_02024D1E[0])
+    {
+    case 0:
+        gUnknown_02024D1E[1] = 0xFF;
+        gUnknown_02024D1E[0]++;
+        break;
+    case 1:
+        gUnknown_02024D1E[1]--;
+        if (gUnknown_02024D1E[1] == 0)
+        {
+            BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
+            gUnknown_02024D1E[0]++;
+        }
+        break;
+    case 2:
+        if (!gPaletteFade.active)
+            SetMainCallback2(gMain.savedCallback);
+        break;
+    }
+}
+
+void oac_poke_opponent(struct Sprite *sprite)
+{
+    sprite->callback = sub_8010278;
+    StartSpriteAnimIfDifferent(sprite, 0);
+    BeginNormalPaletteFade(0x00020000, 0, 10, 10, 0x3DEF);
+}
+
+void sub_8010278(struct Sprite *sprite)
+{
+    if ((gUnknown_02024DE8 & 1) == 0)
+    {
+        sprite->pos2.x += 2;
+        if (sprite->pos2.x == 0)
+        {
+            sprite->callback = sub_80102AC;
+            PlayCry1(sprite->data2, 25);
+        }
+    }
+}
+
+void sub_80102AC(struct Sprite *sprite)
+{
+    if (sprite->animEnded)
+    {
+        sub_804777C(sprite->data0);
+        sub_8043DFC(gUnknown_03004340[sprite->data0]);
+        sprite->callback = nullsub_37;
+        StartSpriteAnimIfDifferent(sprite, 0);
+        BeginNormalPaletteFade(0x00020000, 0, 10, 0, 0x3DEF);
+    }
+}
+
+void nullsub_37(struct Sprite *sprite)
+{
+}
+
+void unref_sub_801030C(struct Sprite *sprite)
+{
+    sprite->data3 = 6;
+    sprite->data4 = 1;
+    sprite->callback = sub_8010320;
+}
+
+void sub_8010320(struct Sprite *sprite)
+{
+    sprite->data4--;
+    if (sprite->data4 == 0)
+    {
+        sprite->data4 = 8;
+        sprite->invisible ^= 1;
+        sprite->data3--;
+        if (sprite->data3 == 0)
+        {
+            sprite->invisible = FALSE;
+            sprite->callback = nullsub_37;
+            gUnknown_03004284 = 0;
+        }
+    }
+}
+
+void sub_8010384(struct Sprite *sprite)
+{
+    u8 r6 = sprite->data0;
+    u16 species;
+    u8 yOffset;
+
+    if (ewram17800[r6].unk2 != 0)
+        species = ewram17800[r6].unk2;
+    else
+        species = sprite->data2;
+
+    GetMonData(&gEnemyParty[gUnknown_02024A6A[r6]], MON_DATA_PERSONALITY);  // Unused return value
+
+    if (species == SPECIES_UNOWN)
+    {
+        u32 personalityValue = GetMonData(&gEnemyParty[gUnknown_02024A6A[r6]], MON_DATA_PERSONALITY);
+        u16 unownForm = ((((personalityValue & 0x3000000) >> 18) | ((personalityValue & 0x30000) >> 12) | ((personalityValue & 0x300) >> 6) | (personalityValue & 3)) % 0x1C);
+        u16 unownSpecies;
+
+        if (unownForm == 0)
+            unownSpecies = SPECIES_UNOWN;  // Use the A Unown form
+        else
+            unownSpecies = NUM_SPECIES + unownForm;  // Use one of the other Unown letters
+
+        yOffset = gMonFrontPicCoords[unownSpecies].y;
+    }
+    else if (species == SPECIES_CASTFORM)
+    {
+        yOffset = gCastformFrontSpriteCoords[gBattleMonForms[r6]].y;
+    }
+    else if (species > NUM_SPECIES)
+    {
+        yOffset = gMonFrontPicCoords[SPECIES_NONE].y;
+    }
+    else
+    {
+        yOffset = gMonFrontPicCoords[species].y;
+    }
+
+    sprite->data3 = 8 - yOffset / 8;
+    sprite->data4 = 1;
+    sprite->callback = sub_8010494;
+}
+
+void sub_8010494(struct Sprite *sprite)
+{
+    s32 i;
+
+    sprite->data4--;
+    if (sprite->data4 == 0)
+    {
+        sprite->data4 = 2;
+        sprite->pos2.y += 8;
+        sprite->data3--;
+        if (sprite->data3 < 0)
+        {
+            FreeSpriteOamMatrix(sprite);
+            DestroySprite(sprite);
+        }
+        else
+        {
+            u8 *dst = (u8 *)gUnknown_081FAF4C[battle_get_per_side_status(sprite->data0)] + (gBattleMonForms[sprite->data0] << 11) + (sprite->data3 << 8);
+
+            for (i = 0; i < 0x100; i++)
+                *(dst++) = 0;
+            StartSpriteAnim(sprite, gBattleMonForms[sprite->data0]);
+        }
+    }
+}
+
+void sub_8010520(struct Sprite *sprite)
+{
+    sprite->data3 = 8;
+    sprite->data4 = sprite->invisible;
+    sprite->callback = sub_801053C;
+}
+
+void sub_801053C(struct Sprite *sprite)
+{
+    sprite->data3--;
+    if (sprite->data3 == 0)
+    {
+        sprite->invisible ^= 1;
+        sprite->data3 = 8;
+    }
+}
+
+void sub_8010574(struct Sprite *sprite)
+{
+    sprite->invisible = sprite->data4;
+    sprite->data4 = FALSE;
+    sprite->callback = nullsub_37;
+}
+
+void sub_80105A0(struct Sprite *sprite)
+{
+    sprite->callback = oac_poke_ally_;
+}
+
+void oac_poke_ally_(struct Sprite *sprite)
+{
+    if ((gUnknown_02024DE8 & 1) == 0)
+    {
+        sprite->pos2.x -= 2;
+        if (sprite->pos2.x == 0)
+        {
+            sprite->callback = nullsub_86;
+            sprite->data1 = 0;
+        }
+    }
+}
+
+void sub_80105DC(struct Sprite *sprite)
+{
+    sprite->callback = nullsub_86;
+}
+
+void nullsub_86(struct Sprite *sprite)
+{
+}
+
+void sub_80105EC(struct Sprite *sprite)
+{
+    if ((gUnknown_02024DE8 & 1) == 0)
+    {
+        sprite->pos2.x += sprite->data1;
+        sprite->pos2.y += sprite->data2;
+    }
+}
+
+void dp11b_obj_instanciate(u8 a, u8 b, s8 c, s8 d)
+{
+    u8 spriteId;
+    u8 r7;
+
+    if (b)
+    {
+        if (ewram17810[a].unk0_1)
+            return;
+    }
+    else
+    {
+        if (ewram17810[a].unk0_2)
+            return;
+    }
+
+    spriteId = CreateInvisibleSpriteWithCallback(objc_dp11b_pingpong);
+    if (b == TRUE)
+    {
+        r7 = gUnknown_03004340[a];
+        ewram17810[a].unk2 = spriteId;
+        ewram17810[a].unk0_1 = 1;
+        gSprites[spriteId].data0 = 0x80;
+    }
+    else
+    {
+        r7 = gUnknown_02024BE0[a];
+        ewram17810[a].unk3 = spriteId;
+        ewram17810[a].unk0_2 = 1;
+        gSprites[spriteId].data0 = 0xC0;
+    }
+    gSprites[spriteId].data1 = c;
+    gSprites[spriteId].data2 = d;
+    gSprites[spriteId].data3 = r7;
+    gSprites[spriteId].data4 = b;
+    gSprites[r7].pos2.x = 0;
+    gSprites[r7].pos2.y = 0;
+}
+
+void dp11b_obj_free(u8 a, u8 b)
+{
+    u8 r4;
+
+    if (b == TRUE)
+    {
+        if (!ewram17810[a].unk0_1)
+            return;
+        r4 = gSprites[ewram17810[a].unk2].data3;
+        DestroySprite(&gSprites[ewram17810[a].unk2]);
+        ewram17810[a].unk0_1 = 0;
+    }
+    else
+    {
+        if (!ewram17810[a].unk0_2)
+            return;
+        r4 = gSprites[ewram17810[a].unk3].data3;
+        DestroySprite(&gSprites[ewram17810[a].unk3]);
+        ewram17810[a].unk0_2 = 0;
+    }
+    gSprites[r4].pos2.x = 0;
+    gSprites[r4].pos2.y = 0;
+}
+
+void objc_dp11b_pingpong(struct Sprite *sprite)
+{
+    u8 spriteId = sprite->data3;
+    s32 var;
+
+    if (sprite->data4 == 1)
+        var = sprite->data0;
+    else
+        var = sprite->data0;
+
+    gSprites[spriteId].pos2.y = Sin(var, sprite->data2) + sprite->data2;
+    sprite->data0 = (sprite->data0 + sprite->data1) & 0xFF;
+}
+
+void nullsub_41(void)
+{
+}
+
+void sub_8010800(void)
+{
+    sub_8010874();
+    gUnknown_02024D1E[1] = 0;
+    gUnknown_030042D4 = bc_8012FAC;
+}
+
+void sub_8010824(void)
+{
+    gUnknown_030042D4();
+    gUnknown_02024A60 = 0;
+
+    for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        gUnknown_03004330[gUnknown_02024A60]();
+}
+
+void sub_8010874(void)
+{
+    s32 i;
+    s32 j;
+    u8 *r4;
+
+    sub_801365C(0);
+    sub_801377C();
+
+    for (i = 0; i < 4; i++)
+    {
+        gUnknown_02024C98[i] = 0;
+
+        r4 = (u8 *)&gUnknown_02024CA8[i];
+        for (j = 0; j < (u32)0x1C; j++)
+            r4[j] = 0;
+
+        gUnknown_02024CA8[i].unk16 = 2;
+        gUnknown_02024C70[i] = 0;
+        gUnknown_02024C34[i] = 0;
+        gUnknown_02024C3C[i] = 0;
+        gUnknown_02024C44[i] = 0;
+        gUnknown_02024C4C[i] = 0;
+        gUnknown_02024C5C[i] = 0xFF;
+        gUnknown_02024C54[i] = 0;
+        gUnknown_02024C2C[i] = 0;
+        ewram17100[i] = 0;
+    }
+
+    for (i = 0; i < 2; i++)
+    {
+        gUnknown_02024C7A[i] = 0;
+
+        r4 = (u8 *)&gUnknown_02024C80[i];
+        for (j = 0; j < (u32)12; j++)
+            r4[j] = 0;
+    }
+
+    gPlayerMonIndex = 0;
+    gEnemyMonIndex = 0;
+    gBattleWeather = 0;
+
+    r4 = (u8 *)&gUnknown_02024DBC;
+    for (i = 0; i < (u32)0x2C; i++)
+        r4[i] = 0;
+
+    gUnknown_02024C6C = 0;
+    if ((gBattleTypeFlags & 2) == 0 && gSaveBlock2.optionsBattleSceneOff == TRUE)
+        gUnknown_02024C6C = 0x80;
+    ewram16084 = gSaveBlock2.optionsBattleStyle;
+    gUnknown_02024C0E = 0;
+    gUnknown_02024D26 = 0;
+    gUnknown_02024A64 = 0;
+    gUnknown_02024D1A = 0;
+    ewram17130 = 0;
+    ewram17160 = 0;
+    for (i = 0; i < 8; i++)
+        gUnknown_02024D1E[i] = 0;
+    gUnknown_02024D18 = 0;
+    gBattleMoveDamage = 0;
+    gUnknown_02024DE8 = 0;
+    ewram16002 = 0;
+    ewram160A1 = 0;
+    gUnknown_03004324 = 0;
+    gUnknown_02024C0C = 0;
+    ewram16078 = 0;
+    ewram16086 = 0;
+    ewram16087 = 0;
+    ewram16089 = gBaseStats[GetMonData(&gEnemyParty[0], MON_DATA_SPECIES)].catchRate * 100 / 1275;
+    ewram16088 = 3;
+    ewram1601B = 0;
+    ewram16056 = 1;
+
+    for (i = 0; i < 8; i++)
+    {
+        ewram[i + 0x160AC] = 0;
+        ewram[i + 0x160CC] = 0;
+        ewram[i + 0x160E8] = 0;
+        ewram[i + 0x160F0] = 0;
+        ewram[i + 0x16100] = 0;
+        ewram[i + 0x16108] = 0;
+    }
+
+    ewram160C8 = 6;
+    ewram160C9 = 6;
+    ewram16113 = 0;
+    for (i = 0; i < 11; i++)
+        gUnknown_030042E0.unk36[i] = 0;
+    gUnknown_030042E0.unk13 = 0;
+    gUnknown_030042E0.unk0 = 0;
+    gUnknown_030042E0.unk1 = 0;
+    gUnknown_030042E0.unk2 = 0;
+    gUnknown_030042E0.unk3 = 0;
+    gUnknown_030042E0.unk4 = 0;
+    gUnknown_030042E0.unk5_0 = 0;
+    gUnknown_030042E0.unk5_1 = 0;
+    gUnknown_030042E0.unk20 = 0;
+    gUnknown_030042E0.unk22 = 0;
+    gUnknown_030042E0.unk24 = 0;
+    gUnknown_030042E0.unk6 = 0;
+    gUnknown_030042E0.unk26 = 0;
+    gUnknown_030042E0.unk28 = 0;
+    for (i = 0; i < 10; i++)
+    {
+        gUnknown_030042E0.unk8[i] = 0;
+        gUnknown_030042E0.unk14[i] = 0;
+        gUnknown_030042E0.unk2A[i] = 0;
+    }
+}
+
+void sub_8010B88(void)
+{
+    struct UnknownStruct4 sp0 = gUnknown_02024CA8[gUnknown_02024A60];
+    s32 i;
+    u8 *ptr;
+    u32 *ptr2;
+
+    if (gBattleMoves[gUnknown_02024BE6].effect != 0x7F)
+    {
+        for (i = 0; i < 8; i++)
+            gBattleMons[gUnknown_02024A60].statStages[i] = 6;
+        for (i = 0; i < gUnknown_02024A68; i++)
+        {
+            struct UnknownStruct12 *sp20 = &gUnknown_02024AD0[i];
+
+            if ((sp20->unk0 & 0x04000000) && gUnknown_02024CA8[i].unk14 == gUnknown_02024A60)
+                sp20->unk0 &= ~0x04000000;
+            if ((gUnknown_02024C98[i] & 0x18) && gUnknown_02024CA8[i].unk15 == gUnknown_02024A60)
+            {
+                gUnknown_02024C98[i] &= ~0x18;
+                gUnknown_02024CA8[i].unk15 = 0;
+            }
+        }
+    }
+    if (gBattleMoves[gUnknown_02024BE6].effect == 0x7F)
+    {
+        gBattleMons[gUnknown_02024A60].status2 &= 0x15100007;
+        gUnknown_02024C98[gUnknown_02024A60] &= 0x3043F;
+
+        for (i = 0; i < gUnknown_02024A68; i++)
+        {
+            if (battle_side_get_owner(gUnknown_02024A60) != battle_side_get_owner(i)
+             && (gUnknown_02024C98[i] & 0x18) != 0
+             && (gUnknown_02024CA8[i].unk15 == gUnknown_02024A60))
+            {
+                gUnknown_02024C98[i] &= ~0x18;
+                gUnknown_02024C98[i] |= 0x10;
+            }
+        }
+    }
+    else
+    {
+        gBattleMons[gUnknown_02024A60].status2 = 0;
+        gUnknown_02024C98[gUnknown_02024A60] = 0;
+    }
+
+    for (i = 0; i < gUnknown_02024A68; i++)
+    {
+        if (gUnknown_02024AD0[i].unk0 & (gBitTable[gUnknown_02024A60] << 16))
+            gUnknown_02024AD0[i].unk0 &= ~(gBitTable[gUnknown_02024A60] << 16);
+        if ((gUnknown_02024AD0[i].unk0 & 0xE000) && ewram[0x16020 + i] == gUnknown_02024A60)
+            gUnknown_02024AD0[i].unk0 &= ~0xE000;
+    }
+
+    gUnknown_02024E60[gUnknown_02024A60] = 0;
+    gUnknown_02024E64[gUnknown_02024A60] = 0;
+
+    ptr = (u8 *)&gUnknown_02024CA8[gUnknown_02024A60];
+    for (i = 0; i < (u32)0x1C; i++)
+        ptr[i] = 0;
+
+    if (gBattleMoves[gUnknown_02024BE6].effect == 0x7F)
+    {
+        gUnknown_02024CA8[gUnknown_02024A60].unkA = sp0.unkA;
+        gUnknown_02024CA8[gUnknown_02024A60].unk15 = sp0.unk15;
+        gUnknown_02024CA8[gUnknown_02024A60].unkF_0 = sp0.unkF_0;
+        gUnknown_02024CA8[gUnknown_02024A60].unkF_4 = sp0.unkF_4;
+    }
+
+    gUnknown_02024CA8[gUnknown_02024A60].unk16 = 2;
+    gUnknown_02024C34[gUnknown_02024A60] = 0;
+    gUnknown_02024C3C[gUnknown_02024A60] = 0;
+    gUnknown_02024C44[gUnknown_02024A60] = 0;
+    gUnknown_02024C4C[gUnknown_02024A60] = 0;
+    gUnknown_02024C2C[gUnknown_02024A60] = 0;
+    gUnknown_02024C5C[gUnknown_02024A60] = 0xFF;
+
+    ewram[0x160AC + gUnknown_02024A60 * 2 + 0] = 0;
+    ewram[0x160AC + gUnknown_02024A60 * 2 + 1] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 0] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 1] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 2] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 3] = 0;
+    ewram[0x160E8 + gUnknown_02024A60 * 2 + 0] = 0;
+    ewram[0x160E8 + gUnknown_02024A60 * 2 + 1] = 0;
+
+    ptr2 = (u32 *)(ewram + 0x17100);
+    ptr2[gUnknown_02024A60] = 0;
+
+    gUnknown_02024BE6 = 0;
+}
+
+void sub_8010F48(void)
+{
+    s32 i;
+    u8 *ptr;
+    u32 *ptr2;
+
+    for (i = 0; i < 8; i++)
+        gBattleMons[gUnknown_02024A60].statStages[i] = 6;
+    gBattleMons[gUnknown_02024A60].status2 = 0;
+    gUnknown_02024C98[gUnknown_02024A60] = 0;
+    for (i = 0; i < gUnknown_02024A68; i++)
+    {
+        if ((gBattleMons[i].status2 & 0x4000000) && gUnknown_02024CA8[i].unk14 == gUnknown_02024A60)
+            gBattleMons[i].status2 &= ~0x4000000;
+        if (gBattleMons[i].status2 & (gBitTable[gUnknown_02024A60] << 16))
+            gBattleMons[i].status2 &= ~(gBitTable[gUnknown_02024A60] << 16);
+        if ((gBattleMons[i].status2 & 0xE000) && ewram[0x16020 + i] == gUnknown_02024A60)
+            gBattleMons[i].status2 &= ~0xE000;
+    }
+    gUnknown_02024E60[gUnknown_02024A60] = 0;
+    gUnknown_02024E64[gUnknown_02024A60] = 0;
+
+    ptr = (u8 *)&gUnknown_02024CA8[gUnknown_02024A60];
+    for (i = 0; i < (u32)0x1C; i++)
+        ptr[i] = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_0 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_1 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_2 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_3 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_4 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_5 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_6 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk0_7 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_0 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_1 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_2 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_3 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_5 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_6 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk1_7 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk2_0 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk2_1 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk2_2 = 0;
+    gUnknown_02024D28[gUnknown_02024A60].unk2_3 = 0;
+
+    gUnknown_02024CA8[gUnknown_02024A60].unk16 = 2;
+    gUnknown_02024C34[gUnknown_02024A60] = 0;
+    gUnknown_02024C3C[gUnknown_02024A60] = 0;
+    gUnknown_02024C44[gUnknown_02024A60] = 0;
+    gUnknown_02024C4C[gUnknown_02024A60] = 0;
+    gUnknown_02024C2C[gUnknown_02024A60] = 0;
+    gUnknown_02024C5C[gUnknown_02024A60] = 0xFF;
+
+    ewram[0x160E8 + gUnknown_02024A60 * 2 + 0] = 0;
+    ewram[0x160E8 + gUnknown_02024A60 * 2 + 1] = 0;
+    ewram[0x160AC + gUnknown_02024A60 * 2 + 0] = 0;
+    ewram[0x160AC + gUnknown_02024A60 * 2 + 1] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 0] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 1] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 2] = 0;
+    ewram[0x16100 + gUnknown_02024A60 * 4 + 3] = 0;
+
+    ptr2 = (u32 *)(ewram + 0x17100);
+    ptr2[gUnknown_02024A60] = 0;
+
+    gBattleMons[gUnknown_02024A60].type1 = gBaseStats[gBattleMons[gUnknown_02024A60].species].type1;
+    gBattleMons[gUnknown_02024A60].type2 = gBaseStats[gBattleMons[gUnknown_02024A60].species].type2;
+}
+
+void bc_8012FAC(void)
+{
+    switch (gUnknown_02024D1E[0])
+    {
+    case 0:
+        gUnknown_02024A60 = gUnknown_02024D1E[1];
+        dp01_build_cmdbuf_x00_a_b_0(0, 0, 0);
+        dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+        gUnknown_02024D1E[0]++;
+        break;
+    case 1:
+        if (gUnknown_02024A64 == 0)
+        {
+            gUnknown_02024D1E[1]++;
+            if (gUnknown_02024D1E[1] == gUnknown_02024A68)
+                gUnknown_030042D4 = bc_load_battlefield;
+            else
+                gUnknown_02024D1E[0] = 0;
+        }
+        break;
+    }
+}
+
+void bc_load_battlefield(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        gUnknown_02024A60 = battle_get_side_with_given_state(0);
+        dp01_build_cmdbuf_x2E_a(0, gBattleTerrain);
+        dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+        gUnknown_030042D4 = sub_8011384;
+        gUnknown_02024D1E[0] = 0;
+        gUnknown_02024D1E[1] = 0;
+    }
+}
+
+void sub_8011384(void)
+{
+    u8 *ptr;
+    s32 i;
+
+    if (gUnknown_02024A64 == 0)
+    {
+        for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        {
+            if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+             && battle_side_get_owner(gUnknown_02024A60) == 0)
+            {
+                ptr = (u8 *)&gBattleMons[gUnknown_02024A60];
+                for (i = 0; i < (u32)0x58; i++)
+                    ptr[i] = 0;
+            }
+            else
+            {
+                u8 r0;
+
+                ptr = (u8 *)&gBattleMons[gUnknown_02024A60];
+                for (i = 0; i < (u32)0x58; i++)
+                    ptr[i] = gUnknown_02024260[gUnknown_02024A60][4 + i];
+
+                gBattleMons[gUnknown_02024A60].type1 = gBaseStats[gBattleMons[gUnknown_02024A60].species].type1;
+                gBattleMons[gUnknown_02024A60].type2 = gBaseStats[gBattleMons[gUnknown_02024A60].species].type2;
+                gBattleMons[gUnknown_02024A60].ability = GetAbilityBySpecies(gBattleMons[gUnknown_02024A60].species, gBattleMons[gUnknown_02024A60].altAbility);
+                r0 = battle_side_get_owner(gUnknown_02024A60);
+                ewram160BC[r0] = gBattleMons[gUnknown_02024A60].hp;
+                for (i = 0; i < 8; i++)
+                    gBattleMons[gUnknown_02024A60].statStages[i] = 6;
+                gBattleMons[gUnknown_02024A60].status2 = 0;
+            }
+
+            if (battle_get_per_side_status(gUnknown_02024A60) == 0)
+            {
+                dp01_build_cmdbuf_x07_7_7_7(0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+
+            if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+            {
+                if (battle_get_per_side_status(gUnknown_02024A60) == 1)
                 {
-                    struct TrainerPartyMember1 *partyData = gTrainers[trainerNum].party;
+                    dp01_build_cmdbuf_x07_7_7_7(0);
+                    dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+                }
+                if (battle_side_get_owner(gUnknown_02024A60) == 1
+                 && !(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK)))
+                    sub_8090D90(SpeciesToNationalPokedexNum(gBattleMons[gUnknown_02024A60].species), 2);
+            }
+            else
+            {
+                if (battle_side_get_owner(gUnknown_02024A60) == 1
+                 && !(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK)))
+                {
+                    sub_8090D90(SpeciesToNationalPokedexNum(gBattleMons[gUnknown_02024A60].species), 2);
+                    dp01_build_cmdbuf_x04_4_4_4(0);
+                    dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+                }
+            }
+
+            if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+            {
+                if (battle_get_per_side_status(gUnknown_02024A60) == 2
+                 || battle_get_per_side_status(gUnknown_02024A60) == 3)
+                {
+                    dp01_build_cmdbuf_x07_7_7_7(0);
+                    dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+                }
+            }
+        }
+        gUnknown_030042D4 = bc_801333C;
+    }
+}
 
-                    for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
-                        nameHash += gSpeciesNames[partyData[i].species][j];
-                    personalityValue += nameHash << 8;
-                    fixedIV = partyData[i].iv * 31 / 255;
-                    CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+void bc_801333C(void)
+{
+    s32 i;
 
-                    for (j = 0; j < 4; j++)
-                    {
-                        SetMonData(&party[i], MON_DATA_MOVE1 + j, (u8 *)&partyData[i].moves[j]);
-                        SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
-                    }
-                    break;
+    if (gUnknown_02024A64 == 0)
+    {
+        struct
+        {
+            u16 hp;
+            u32 status;
+        } sp0[6];
+
+        if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+        {
+            for (i = 0; i < 6; i++)
+            {
+                if (GetMonData(&gEnemyParty[i], MON_DATA_SPECIES2) == 0
+                 || GetMonData(&gEnemyParty[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+                {
+                    sp0[i].hp = 0xFFFF;
+                    sp0[i].status = 0;
                 }
-                case 2:
+                else
                 {
-                    struct TrainerPartyMember2 *partyData = gTrainers[trainerNum].party;
+                    sp0[i].hp = GetMonData(&gEnemyParty[i], MON_DATA_HP);
+                    sp0[i].status = GetMonData(&gEnemyParty[i], MON_DATA_STATUS);
+                }
+            }
+            gUnknown_02024A60 = battle_get_side_with_given_state(1);
+            dp01_build_cmdbuf_x30_TODO(0, (u8 *)sp0, 0x80);
+            dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
 
-                    for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
-                        nameHash += gSpeciesNames[partyData[i].species][j];
-                    personalityValue += nameHash << 8;
-                    fixedIV = partyData[i].iv * 31 / 255;
-                    CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+            for (i = 0; i < 6; i++)
+            {
+                if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2) == 0
+                 || GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+                {
+                    sp0[i].hp = 0xFFFF;
+                    sp0[i].status = 0;
+                }
+                else
+                {
+                    sp0[i].hp = GetMonData(&gPlayerParty[i], MON_DATA_HP);
+                    sp0[i].status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS);
+                }
+            }
+            gUnknown_02024A60 = battle_get_side_with_given_state(0);
+            dp01_build_cmdbuf_x30_TODO(0, (u8 *)sp0, 0x80);
+            dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
 
-                    SetMonData(&party[i], MON_DATA_HELD_ITEM, (u8 *)&partyData[i].heldItem);
-                    break;
+            gUnknown_030042D4 = bc_battle_begin_message;
+        }
+        else
+        {
+            // The array gets set here, but nothing is ever done with it.
+            // Likely unfinished code.
+
+            for (i = 0; i < 6; i++)
+            {
+                if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2) == 0
+                 || GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2) == SPECIES_EGG)
+                {
+                    sp0[i].hp = 0xFFFF;
+                    sp0[i].status = 0;
                 }
-                case 3:
+                else
                 {
-                    struct TrainerPartyMember3 *partyData = gTrainers[trainerNum].party;
+                    sp0[i].hp = GetMonData(&gPlayerParty[i], MON_DATA_HP);
+                    sp0[i].status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS);
+                }
+            }
 
-                    for (j = 0; gSpeciesNames[partyData[i].species][j] != 0xFF; j++)
-                        nameHash += gSpeciesNames[partyData[i].species][j];
-                    personalityValue += nameHash << 8;
-                    fixedIV = partyData[i].iv * 31 / 255;
-                    CreateMon(&party[i], partyData[i].species, partyData[i].level, fixedIV, TRUE, personalityValue, 2, 0);
+            gUnknown_030042D4 = bc_8013568;
+        }
+    }
+}
 
-                    SetMonData(&party[i], MON_DATA_HELD_ITEM, (u8 *)&partyData[i].heldItem);
-                    for (j = 0; j < 4; j++)
-                    {
-                        SetMonData(&party[i], MON_DATA_MOVE1 + j, (u8 *)&partyData[i].moves[j]);
-                        SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
-                    }
-                    break;
+void bc_battle_begin_message(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        gUnknown_02024A60 = battle_get_side_with_given_state(1);
+        b_std_message(0, gUnknown_02024A60);
+        gUnknown_030042D4 = sub_8011800;
+    }
+}
+
+void bc_8013568(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        gUnknown_030042D4 = sub_8011970;
+        b_std_message(0, 0);
+    }
+}
+
+void sub_8011800(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        b_std_message(1, battle_get_side_with_given_state(1));
+        gUnknown_030042D4 = sub_8011834;
+    }
+}
+
+void sub_8011834(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        {
+            if (battle_get_per_side_status(gUnknown_02024A60) == 1)
+            {
+                dp01_build_cmdbuf_x2F_2F_2F_2F(0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+            if ((gBattleTypeFlags & BATTLE_TYPE_MULTI)
+             && battle_get_per_side_status(gUnknown_02024A60) == 3)
+            {
+                dp01_build_cmdbuf_x2F_2F_2F_2F(0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+        }
+        gUnknown_030042D4 = bc_801362C;
+    }
+}
+
+void bc_801362C(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        {
+            if (battle_side_get_owner(gUnknown_02024A60) == 1
+             && !(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK)))
+                sub_8090D90(SpeciesToNationalPokedexNum(gBattleMons[gUnknown_02024A60].species), 2);
+        }
+        gUnknown_030042D4 = sub_8011970;
+    }
+}
+
+void unref_sub_8011950(void)
+{
+    if (gUnknown_02024A64 == 0)
+        gUnknown_030042D4 = sub_8011970;
+}
+
+void sub_8011970(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI))
+            b_std_message(1, battle_get_side_with_given_state(0));
+        gUnknown_030042D4 = sub_80119B4;
+    }
+}
+
+void sub_80119B4(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        {
+            if (battle_get_per_side_status(gUnknown_02024A60) == 0)
+            {
+                dp01_build_cmdbuf_x2F_2F_2F_2F(0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+            if ((gBattleTypeFlags & BATTLE_TYPE_MULTI)
+             && battle_get_per_side_status(gUnknown_02024A60) == 2)
+            {
+                dp01_build_cmdbuf_x2F_2F_2F_2F(0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+        }
+        ewram16058 = 0;
+        ewram160F9 = 0;
+        ewram160E6 = 0;
+        gUnknown_030042D4 = sub_8011B00;
+    }
+}
+
+void unref_sub_8011A68(void)
+{
+    if (gUnknown_02024A64 == 0)
+    {
+        for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+        {
+            if (battle_side_get_owner(gUnknown_02024A60) == 0)
+            {
+                sub_800C704(0, gUnknown_02024A6A[gUnknown_02024A60], 0);
+                dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+            }
+        }
+        ewram16058 = 0;
+        ewram160F9 = 0;
+        ewram160E6 = 0;
+        gUnknown_030042D4 = sub_8011B00;
+    }
+}
+
+void sub_8011B00(void)
+{
+    s32 i;
+    s32 j;
+    u8 r9 = 0;
+
+    if (gUnknown_02024A64 == 0)
+    {
+        if (ewram16058 == 0)
+        {
+            for (i = 0; i < gUnknown_02024A68; i++)
+                gUnknown_02024A7A[i] = i;
+            for (i = 0; i < gUnknown_02024A68 - 1; i++)
+            {
+                for (j = i + 1; j < gUnknown_02024A68; j++)
+                {
+                    if (b_first_side(gUnknown_02024A7A[i], gUnknown_02024A7A[j], 1) != 0)
+                        sub_8012FBC(i, j);
                 }
             }
         }
-        gBattleTypeFlags |= gTrainers[trainerNum].doubleBattle;
+        if (ewram160E6 == 0 && sub_8018324(0, 0, 0, 0xFF, 0) != 0)
+        {
+            ewram160E6 = 1;
+            return;
+        }
+        while (ewram16058 < gUnknown_02024A68)
+        {
+            if (sub_8018324(0, gUnknown_02024A7A[ewram16058], 0, 0, 0) != 0)
+                r9++;
+            ewram16058++;
+            if (r9 != 0)
+                return;
+        }
+        if (sub_8018324(9, 0, 0, 0, 0) != 0)
+            return;
+        if (sub_8018324(11, 0, 0, 0, 0) != 0)
+            return;
+        while (ewram160F9 < gUnknown_02024A68)
+        {
+            if (sub_801A02C(0, gUnknown_02024A7A[ewram160F9], 0) != 0)
+                r9++;
+            ewram160F9++;
+            if (r9 != 0)
+                return;
+        }
+        // Absolutely pointless for-loop that somehow doesn't get optimized out
+        for (i = 0; i < gUnknown_02024A68; i++)
+            ;
+        for (i = 0; i < 4; i++)
+        {
+            ewram[0x16068 + i] = 6;
+            gUnknown_02024C18[i] = 0xFF;
+            gUnknown_02024C60[i] = 0;
+        }
+        sub_801365C(0);
+        sub_801377C();
+        ewram160A6 = gUnknown_02024C0C;
+        gUnknown_030042D4 = sub_8012324;
+        sub_80156DC();
+        for (i = 0; i < 8; i++)
+            gUnknown_02024D1E[i] = 0;
+        for (i = 0; i < gUnknown_02024A68; i++)
+            gBattleMons[i].status2 &= ~8;
+        ewram16000 = 0;
+        ewram16001 = 0;
+        ewram16110 = 0;
+        ewram16111 = 0;
+        ewram1600C = 0;
+        ewram16059 = 0;
+        ewram1600E = 0;
+        gBattleMoveFlags = 0;
+        gUnknown_02024D1C = Random();
     }
-    return gTrainers[trainerNum].partySize;
-}
\ No newline at end of file
+}
+
+void bc_8013B1C(void)
+{
+    s32 i;
+
+    if (gUnknown_02024A64 == 0)
+    {
+        gUnknown_030042D4 = sub_8011E8C;
+        for (i = 0; i < 8; i++)
+            gUnknown_02024D1E[i] = 0;
+        for (i = 0; i < gUnknown_02024A68; i++)
+        {
+            gBattleMons[i].status2 &= ~8;
+            if ((gBattleMons[i].status1 & 7) && (gBattleMons[i].status2 & 0x1000))
+                b_cancel_multi_turn_move_maybe(i);
+        }
+        ewram16000 = 0;
+        ewram16001 = 0;
+        ewram16110 = 0;
+        ewram16111 = 0;
+        ewram1600E = 0;
+        gBattleMoveFlags = 0;
+    }
+}
+
+void sub_8011E8C(void)
+{
+    s32 i;
+
+    sub_801365C(1);
+    if (gUnknown_02024D26 == 0)
+    {
+        if (sub_8015DFC() != 0)
+            return;
+        if (sub_8016558() != 0)
+            return;
+    }
+    if (sub_80173A4() != 0)
+        return;
+    ewram16059 = 0;
+    if (sub_80170DC() != 0)
+        return;
+    sub_801365C(0);
+    gUnknown_02024C6C &= ~0x200;
+    gUnknown_02024C6C &= ~0x80000;
+    gUnknown_02024C6C &= ~0x400000;
+    gUnknown_02024C6C &= ~0x100000;
+    ewram16002 = 0;
+    ewram160A1 = 0;
+    ewram1600C = 0;
+    gBattleMoveDamage = 0;
+    gBattleMoveFlags = 0;
+    for (i = 0; i < 5; i++)
+        gUnknown_02024D1E[i] = 0;
+    if (gUnknown_02024D26 != 0)
+    {
+        gUnknown_02024A7F = 12;
+        gUnknown_030042D4 = sub_80138F0;
+        return;
+    }
+    if (gUnknown_030042E0.unk13 < 0xFF)
+        gUnknown_030042E0.unk13++;
+    for (i = 0; i < gUnknown_02024A68; i++)
+    {
+        gUnknown_02024C18[i] = 0xFF;
+        gUnknown_02024C60[i] = 0;
+    }
+    for (i = 0; i < 4; i++)
+        ewram[0x16068 + i] = 6;
+    ewram160A6 = gUnknown_02024C0C;
+    gUnknown_030042D4 = sub_8012324;
+    gUnknown_02024D1C = Random();
+}
+
+u8 sub_8012028(void)
+{
+    u8 r2;
+    u8 r6;
+    s32 i;
+
+    if (gBattleMons[gUnknown_02024A60].item == 0xAF)
+        r2 = gEnigmaBerries[gUnknown_02024A60].holdEffect;
+    else
+        r2 = ItemId_GetHoldEffect(gBattleMons[gUnknown_02024A60].item);
+    gUnknown_02024C0B = gUnknown_02024A60;
+    if (r2 == 0x25)
+        return 0;
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        return 0;
+    if (gBattleMons[gUnknown_02024A60].ability == ABILITY_RUN_AWAY)
+        return 0;
+    r6 = battle_side_get_owner(gUnknown_02024A60);
+    for (i = 0; i < gUnknown_02024A68; i++)
+    {
+        if (r6 != battle_side_get_owner(i)
+         && gBattleMons[i].ability == 0x17)
+        {
+            ewram16003 = i;
+            byte_2024C06 = gBattleMons[i].ability;
+            gUnknown_02024D1E[5] = 2;
+            return 2;
+        }
+        if (r6 != battle_side_get_owner(i)
+         && gBattleMons[gUnknown_02024A60].ability != ABILITY_LEVITATE
+         && gBattleMons[gUnknown_02024A60].type1 != 2
+         && gBattleMons[gUnknown_02024A60].type2 != 2
+         && gBattleMons[i].ability == 0x47)
+        {
+            ewram16003 = i;
+            byte_2024C06 = gBattleMons[i].ability;
+            gUnknown_02024D1E[5] = 2;
+            return 2;
+        }
+    }
+    i = sub_8018324(15, gUnknown_02024A60, 0x2A, 0, 0);
+    if (i != 0 && (gBattleMons[gUnknown_02024A60].type1 == 8 || gBattleMons[gUnknown_02024A60].type2 == 8))
+    {
+        ewram16003 = i - 1;
+        byte_2024C06 = gBattleMons[i - 1].ability;
+        gUnknown_02024D1E[5] = 2;
+        return 2;
+    }
+    if ((gBattleMons[gUnknown_02024A60].status2 & 0x0400E000) || (gUnknown_02024C98[gUnknown_02024A60] & 0x400))
+    {
+        gUnknown_02024D1E[5] = 0;
+        return 1;
+    }
+    if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
+    {
+        gUnknown_02024D1E[5] = 1;
+        return 1;
+    }
+    return 0;
+}
+
+void sub_8012258(u8 a)
+{
+    s32 i;
+    u8 r4;
+    u8 r1;
+
+    for (i = 0; i < 3; i++)
+        gUnknown_02038470[i] = ewram[0x1606C + i + a * 3];
+    r4 = pokemon_order_func(gUnknown_02024A6A[a]);
+    r1 = pokemon_order_func(ewram[0x16068 + a]);
+    sub_8094C98(r4, r1);
+    if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+    {
+        for (i = 0; i < 3; i++)
+        {
+            ewram[0x1606C + i + a * 3] = gUnknown_02038470[i];
+            ewram[0x1606C + i + (a ^ 2) * 3] = gUnknown_02038470[i];
+        }
+    }
+    else
+    {
+        for (i = 0; i < 3; i++)
+        {
+            ewram[0x1606C + i + a * 3] = gUnknown_02038470[i];
+        }
+    }
+}
+
+/*
+void sub_8012324(void)
+{
+    u8 r5;
+
+    gUnknown_02024D1E[4] = 0;
+    // inverted loop
+    //_0801234C
+    for (gUnknown_02024A60 = 0; gUnknown_02024A60 < gUnknown_02024A68; gUnknown_02024A60++)
+    {
+        r5 = battle_get_per_side_status(gUnknown_02024A60);
+        switch (gUnknown_02024D1E[gUnknown_02024A60])
+        {
+            case 0:
+                ewram[0x016068 + gUnknown_02024A60] = 6;
+                if (!(gBattleTypeFlags & 0x40)
+                 && (r5 & 2)
+                 && !(ewram160A6 & gBitTable[battle_get_side_with_given_state(r5 ^ 2)])
+                 && gUnknown_02024D1E[battle_get_side_with_given_state(r5)] != 4)
+                    break;
+                //_080123F8
+                if (ewram160A6 & gBitTable[gUnknown_02024A60])
+                {
+                    gUnknown_02024C18[gUnknown_02024A60] = 13;
+                    if (!(gBattleTypeFlags & 0x40))
+                        gUnknown_02024D1E[gUnknown_02024A60] = 4;
+                    //_08012454
+                    else
+                        gUnknown_02024D1E[gUnknown_02024A60] = 3;
+                    break;
+                }
+                //_08012468
+                if ((gBattleMons[gUnknown_02024A60].status2 & 0x1000)
+                 || (gBattleMons[gUnknown_02024A60].status2 & 0x10000000))
+                {
+                    gUnknown_02024C18[gUnknown_02024A60] = 0;
+                    gUnknown_02024D1E[gUnknown_02024A60] = 3;
+                }
+                else
+                {
+                    dp01_build_cmdbuf_x12_a_bb(0, gUnknown_02024C18[0], gUnknown_02024260[0][1] | (gUnknown_02024260[0][2] << 8));
+                    dp01_battle_side_mark_buffer_for_execution(gUnknown_02024A60);
+                    gUnknown_02024D1E[gUnknown_02024A60]++;
+                }
+                break;
+            case 1:
+        }
+    }
+}
+*/
diff --git a/src/field_map_obj.c b/src/field_map_obj.c
index f7e09aacf..475620c28 100644
--- a/src/field_map_obj.c
+++ b/src/field_map_obj.c
@@ -4,8 +4,10 @@
 #include "berry.h"
 #include "event_data.h"
 #include "field_player_avatar.h"
+#include "field_effect.h"
 #include "palette.h"
 #include "rom4.h"
+#include "rng.h"
 #include "sprite.h"
 
 extern const struct SpriteTemplate *const gFieldEffectObjectTemplatePointers[36];
@@ -1503,19 +1505,19 @@ u16 npc_paltag_by_palslot(u8 a)
     return 0x11FF;
 }
 
-u32 sub_805C8A8(void);
+u8 sub_805C8A8(struct MapObject *mapObject, struct Sprite *sprite);
 
 void sub_805C884(struct Sprite *sprite)
 {
     meta_step(&gMapObjects[sprite->data0], sprite, sub_805C8A8);
 }
 
-u32 sub_805C8A8(void)
+u8 sub_805C8A8(struct MapObject *mapObject, struct Sprite *sprite)
 {
     return 0;
 }
 
-u32 sub_805C8D0(struct MapObject *, struct Sprite *);
+u8 sub_805C8D0(struct MapObject *, struct Sprite *);
 
 void sub_805C8AC(struct Sprite *sprite)
 {
@@ -1524,21 +1526,21 @@ void sub_805C8AC(struct Sprite *sprite)
 
 extern u8 (*const gUnknown_08375224[])();
 
-u32 sub_805C8D0(struct MapObject *mapObject, struct Sprite *sprite)
+u8 sub_805C8D0(struct MapObject *mapObject, struct Sprite *sprite)
 {
     return gUnknown_08375224[sprite->data1](mapObject, sprite);
 }
 
-void npc_reset();
+void npc_reset(struct MapObject *mapObject, struct Sprite *sprite);
 
 u8 sub_805C8F0(struct MapObject *mapObject, struct Sprite *sprite)
 {
-    npc_reset(mapObject);
+    npc_reset(mapObject, sprite);
     sprite->data1 = 1;
     return 1;
 }
 
-extern void FieldObjectSetRegularAnim();
+extern void FieldObjectSetRegularAnim(struct MapObject *, struct Sprite *, u8);
 
 u8 sub_805C904(struct MapObject *mapObject, struct Sprite *sprite)
 {
@@ -1547,3 +1549,1488 @@ u8 sub_805C904(struct MapObject *mapObject, struct Sprite *sprite)
     return 1;
 }
 
+extern u8 FieldObjectExecRegularAnim(struct MapObject *, struct Sprite *);
+extern const s16 gUnknown_0837520C[];
+extern const s16 gUnknown_0837521C[];
+extern void sub_8064820(struct Sprite *, s16);
+
+u8 sub_805C930(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) == 0)
+    {
+        return 0;
+    }
+    sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+    sprite->data1 = 3;
+    return 1;
+}
+
+extern u8 sub_8064824(struct Sprite *);
+
+u8 sub_805C96C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) != 0)
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+extern u8 sub_805FF20(struct MapObject *, u8);
+
+u8 sub_805C98C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_08375240, 4);
+    direction = directions[Random() & 3];
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 5;
+    if (sub_805FF20(mapObject, direction) != 0)
+    {
+        sprite->data1 = 1;
+    }
+    return 1;
+}
+
+u8 sub_805C9D8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18));
+    mapObject->mapobj_bit_1 = 1;
+    sprite->data1 = 6;
+    return 1;
+}
+
+u8 sub_805CA08(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) != 0)
+    {
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 1;
+    }
+    return 0;
+}
+
+u8 FieldObjectIsTrainerAndCloseToPlayer(struct MapObject *mapObject)
+{
+    s16 x;
+    s16 y;
+    s16 objx;
+    s16 objy;
+    s16 minx;
+    s16 maxx;
+    s16 miny;
+    s16 maxy;
+    if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_DASH) == 0)
+    {
+        return 0;
+    }
+    if (mapObject->trainerType != 1 && mapObject->trainerType != 3)
+    {
+        return 0;
+    }
+    PlayerGetDestCoords(&x, &y);
+    objx = mapObject->coords2.x;
+    objy = mapObject->coords2.y;
+    minx = objx - mapObject->trainerRange_berryTreeId;
+    miny = objy - mapObject->trainerRange_berryTreeId;
+    maxx = objx + mapObject->trainerRange_berryTreeId;
+    maxy = objy + mapObject->trainerRange_berryTreeId;
+    if (minx > x || maxx < x || miny > y || maxy < y)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+u8 sub_805CAAC(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    if (a2 > a3)
+    {
+        dirn = DIR_EAST;
+        if (a0 < 0)
+        {
+            dirn = DIR_WEST;
+        }
+    }
+    else
+    {
+        dirn = DIR_SOUTH;
+        if (a1 < 0)
+        {
+            dirn = DIR_NORTH;
+        }
+    }
+    return dirn;
+}
+
+u8 sub_805CADC(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = DIR_SOUTH;
+    if (a1 < 0)
+    {
+        dirn = DIR_NORTH;
+    }
+    return dirn;
+}
+
+u8 sub_805CAEC(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = DIR_EAST;
+    if (a0 < 0)
+    {
+        dirn = DIR_WEST;
+    }
+    return dirn;
+}
+
+u8 sub_805CB00(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_SOUTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+        if (dirn == DIR_EAST)
+        {
+            dirn = DIR_NORTH;
+        }
+    }
+    else if (dirn == DIR_EAST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+        if (dirn == DIR_SOUTH)
+        {
+            dirn = DIR_NORTH;
+        }
+    }
+    return dirn;
+}
+
+u8 sub_805CB5C(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_SOUTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+        if (dirn == DIR_WEST)
+        {
+            dirn = DIR_NORTH;
+        }
+    }
+    else if (dirn == DIR_WEST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+        if (dirn == DIR_SOUTH)
+        {
+            dirn = DIR_NORTH;
+        }
+    }
+    return dirn;
+}
+
+u8 sub_805CBB8(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_NORTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+        if (dirn == DIR_EAST)
+        {
+            dirn = DIR_SOUTH;
+        }
+    }
+    else if (dirn == DIR_EAST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+        if (dirn == DIR_NORTH)
+        {
+            dirn = DIR_SOUTH;
+        }
+    }
+    return dirn;
+}
+
+u8 sub_805CC14(s16 a0, s16 a1, s16 a2, s16 a3) {
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_NORTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+        if (dirn == DIR_WEST)
+        {
+            dirn = DIR_SOUTH;
+        }
+    }
+    else if (dirn == DIR_WEST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+        if (dirn == DIR_NORTH)
+        {
+            dirn = DIR_SOUTH;
+        }
+    }
+    return dirn;
+}
+
+u8 sub_805CC70(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_EAST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+    }
+    return dirn;
+}
+
+u8 sub_805CCAC(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_WEST)
+    {
+        dirn = sub_805CADC(a0, a1, a2, a3);
+    }
+    return dirn;
+}
+
+u8 sub_805CCE8(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_SOUTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+    }
+    return dirn;
+}
+
+u8 sub_805CD24(s16 a0, s16 a1, s16 a2, s16 a3)
+{
+    u8 dirn;
+    dirn = sub_805CAAC(a0, a1, a2, a3);
+    if (dirn == DIR_NORTH)
+    {
+        dirn = sub_805CAEC(a0, a1, a2, a3);
+    }
+    return dirn;
+}
+
+u8 sub_805CD60(struct MapObject *mapObject, u8 a1)
+{
+    s16 x;
+    s16 y;
+    s16 x2;
+    s16 y2;
+    if (!FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        return 0;
+    }
+    PlayerGetDestCoords(&x, &y);
+    x -= mapObject->coords2.x;
+    y -= mapObject->coords2.y;
+    x2 = x;
+    y2 = y;
+    if (x2 < 0)
+    {
+        x2 = -x2;
+    }
+    if (y2 < 0)
+    {
+        y2 = -y2;
+    }
+    return gUnknown_08375244[a1](x, y, x2, y2);
+}
+
+u8 sub_805CE0C(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805CDE8(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805CE0C);
+}
+
+u8 sub_805CE0C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375270[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805CE2C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805CE40(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805CE6C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) != 0)
+    {
+        sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805CEB0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805CEE0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_08375240, 4);
+    direction = sub_805CD60(mapObject, 0);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 3];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805CF4C(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805CF28(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805CF4C);
+}
+
+u8 sub_805CF4C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375284[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805CF6C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805CF80(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805CFAC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) == 0)
+    {
+        return 0;
+    }
+    sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+    sprite->data1 = 3;
+    return 1;
+}
+
+u8 sub_805CFE8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) != 0)
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D008(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_083752A0, 2);
+    direction = directions[Random() & 1];
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 5;
+    if (sub_805FF20(mapObject, direction) != 0)
+    {
+        sprite->data1 = 1;
+    }
+    return 1;
+}
+
+u8 sub_805D054(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18));
+    mapObject->mapobj_bit_1 = 1;
+    sprite->data1 = 6;
+    return 1;
+}
+
+u8 sub_805D084(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) != 0)
+    {
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 1;
+    }
+    return 0;
+}
+
+u8 sub_805D0D0(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D0AC(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D0D0);
+}
+
+u8 sub_805D0D0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083752A4[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D0F0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D104(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805D130(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) == 0)
+    {
+        return 0;
+    }
+    sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+    sprite->data1 = 3;
+    return 1;
+}
+
+u8 sub_805D16C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) != 0)
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D18C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_083752C0, 2);
+    direction = directions[Random() & 1];
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 5;
+    if (sub_805FF20(mapObject, direction) != 0)
+    {
+        sprite->data1 = 1;
+    }
+    return 1;
+}
+
+u8 sub_805D1D8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18));
+    mapObject->mapobj_bit_1 = 1;
+    sprite->data1 = 6;
+    return 1;
+}
+
+u8 sub_805D208(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) != 0)
+    {
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 1;
+    }
+    return 0;
+}
+
+u8 sub_805D254(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D230(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D254);
+}
+
+u8 sub_805D254(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083752C4[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D274(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D2A0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite) != 0)
+    {
+        sprite->data1 = 2;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D2C0(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    mapObject->mapobj_bit_1 = 0;
+    return 0;
+}
+
+u8 sub_805D314(struct MapObject *mapObject, struct Sprite *sprite);
+
+void FieldObjectCB_BerryTree(struct Sprite *sprite)
+{
+    struct MapObject *mapObject;
+    mapObject = &gMapObjects[sprite->data0];
+    if (!(sprite->data7 & 1))
+    {
+        get_berry_tree_graphics(mapObject, sprite);
+        sprite->data7 |= 1;
+    }
+    meta_step(mapObject, sprite, sub_805D314);
+}
+
+u8 sub_805D314(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083752D0[sprite->data1](mapObject, sprite);
+}
+
+extern u32 gUnknown_0202FF84[];
+
+u8 do_berry_tree_growth_sparkle_1(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 berryTreeStage;
+    npc_reset(mapObject, sprite);
+    mapObject->mapobj_bit_13 = 1;
+    sprite->invisible = 1;
+    berryTreeStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId);
+    if (!berryTreeStage)
+    {
+        if (!(sprite->data7 & 4) && sprite->animNum == 4)
+        {
+            gUnknown_0202FF84[0] = mapObject->coords2.x;
+            gUnknown_0202FF84[1] = mapObject->coords2.y;
+            gUnknown_0202FF84[2] = sprite->subpriority - 1;
+            gUnknown_0202FF84[3] = sprite->oam.priority;
+            FieldEffectStart(0x17);
+            sprite->animNum = 0;
+        }
+        return 0;
+    }
+    mapObject->mapobj_bit_13 = 0;
+    sprite->invisible = 0;
+    berryTreeStage--;
+    if (sprite->animNum != berryTreeStage)
+    {
+        sprite->data1 = 2;
+        return 1;
+    }
+    get_berry_tree_graphics(mapObject, sprite);
+    FieldObjectSetRegularAnim(mapObject, sprite, 0x39);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D3EC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sprite->data1 = 0;
+        return 1;
+    }
+    return 0;
+}
+
+u8 do_berry_tree_growth_sparkle_2(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    mapObject->mapobj_bit_1 = 1;
+    sprite->data1 = 3;
+    sprite->data2 = 0;
+    sprite->data7 |= 2;
+    gUnknown_0202FF84[0] = mapObject->coords2.x;
+    gUnknown_0202FF84[1] = mapObject->coords2.y;
+    gUnknown_0202FF84[2] = sprite->subpriority - 1;
+    gUnknown_0202FF84[3] = sprite->oam.priority;
+    FieldEffectStart(0x17);
+    return 1;
+}
+
+u8 sub_805D458(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->data2++;
+    mapObject->mapobj_bit_13 = ((sprite->data2 & 0x2) >> 1);
+    sprite->animPaused = 1;
+    if (sprite->data2 > 64)
+    {
+        get_berry_tree_graphics(mapObject, sprite);
+        sprite->data1 = 4;
+        sprite->data2 = 0;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D4A8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    sprite->data2++;
+    mapObject->mapobj_bit_13 = ((sprite->data2 & 0x2) >> 1);
+    sprite->animPaused = 1;
+    if (sprite->data2 > 64)
+    {
+        sprite->data1 = 0;
+        sprite->data7 &= (-3);
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D518(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D4F4(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D518);
+}
+
+u8 sub_805D518(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083752E4[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D538(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D54C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805D578(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805D5BC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D5EC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_083752A0, 2);
+    direction = sub_805CD60(mapObject, 1);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805D658(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D634(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D658);
+}
+
+u8 sub_805D658(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083752F8[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D678(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D68C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805D6B8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837520C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805D6FC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D72C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_083752C0, 2);
+    direction = sub_805CD60(mapObject, 2);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805D798(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D774(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D798);
+}
+
+u8 sub_805D798(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_0837530C[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D7B8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D7CC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805D7F8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805D83C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D86C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_08375320, 2);
+    direction = sub_805CD60(mapObject, 3);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805D8D8(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D8B4(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805D8D8);
+}
+
+u8 sub_805D8D8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375324[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805D8F8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805D90C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805D938(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805D97C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805D9AC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_08375338, 2);
+    direction = sub_805CD60(mapObject, 4);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805DA18(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805D9F4(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805DA18);
+}
+
+u8 sub_805DA18(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_0837533C[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805DA38(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DA4C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805DA78(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805DABC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805DAEC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_08375350, 2);
+    direction = sub_805CD60(mapObject, 5);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805DB58(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805DB34(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805DB58);
+}
+
+u8 sub_805DB58(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375354[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805DB78(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DB8C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805DBB8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805DBFC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805DC2C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[2];
+    memcpy(directions, gUnknown_08375368, 2);
+    direction = sub_805CD60(mapObject, 6);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 1];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805DC98(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805DC74(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805DC98);
+}
+
+u8 sub_805DC98(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_0837536C[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805DCB8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DCCC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805DCF8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805DD3C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805DD6C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_08375380, 4);
+    direction = sub_805CD60(mapObject, 7);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 3];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DDD8(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805DDB4(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805DDD8);
+}
+
+u8 sub_805DDD8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_08375384[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805DDF8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DE0C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805DE38(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805DE7C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805DEAC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_08375398, 4);
+    direction = sub_805CD60(mapObject, 8);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 3];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DF18(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805DEF4(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805DF18);
+}
+
+u8 sub_805DF18(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_0837539C[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805DF38(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805DF4C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805DF78(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805DFBC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805DFEC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_083753B0, 4);
+    direction = sub_805CD60(mapObject, 9);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 3];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805E058(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805E034(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805E058);
+}
+
+u8 sub_805E058(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083753B4[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805E078(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805E08C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 2;
+    return 1;
+}
+
+u8 sub_805E0B8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, gUnknown_0837521C[Random() & 3]);
+        mapObject->mapobj_bit_1 = 0;
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805E0FC(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 4;
+        return 1;
+    }
+    return 0;
+}
+
+u8 sub_805E12C(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[4];
+    memcpy(directions, gUnknown_083753C8, 4);
+    direction = sub_805CD60(mapObject, 10);
+    if (direction == 0)
+    {
+        direction = directions[Random() & 3];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 1;
+    return 1;
+}
+
+
+u8 sub_805E198(struct MapObject *mapObject, struct Sprite *sprite);
+
+void sub_805E174(struct Sprite *sprite)
+{
+    meta_step(&gMapObjects[sprite->data0], sprite, sub_805E198);
+}
+
+u8 sub_805E198(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    return gUnknown_083753CC[sprite->data1](mapObject, sprite);
+}
+
+u8 sub_805E1B8(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    npc_reset(mapObject, sprite);
+    FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18));
+    sprite->data1 = 1;
+    return 1;
+}
+
+u8 sub_805E1E4(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (FieldObjectExecRegularAnim(mapObject, sprite))
+    {
+        sub_8064820(sprite, 0x30);
+        sprite->data1 = 2;
+    }
+    return 0;
+}
+
+u8 sub_805E208(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    if (sub_8064824(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject))
+    {
+        sprite->data1 = 3;
+    }
+    return 0;
+}
+
+u8 sub_805E234(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    u8 direction;
+    u8 directions[5];
+    memcpy(directions, gUnknown_083753DC, 5);
+    direction = sub_805CD60(mapObject, 0);
+    if (direction == 0)
+    {
+        direction = directions[mapObject->mapobj_unk_18];
+    }
+    FieldObjectSetDirection(mapObject, direction);
+    sprite->data1 = 0;
+    return 1;
+}
+
+void sub_805E278(struct Sprite *sprite);
+void sub_805E37C(struct Sprite *sprite);
+void sub_805E5DC(struct Sprite *sprite);
+void sub_805E668(struct Sprite *sprite);
+void sub_805E6F4(struct Sprite *sprite);
+void sub_805E780(struct Sprite *sprite);
+void sub_805E80C(struct Sprite *sprite);
+void sub_805E898(struct Sprite *sprite);
+void sub_805E924(struct Sprite *sprite);
+void sub_805E9B0(struct Sprite *sprite);
+void sub_805EA3C(struct Sprite *sprite);
+void sub_805EAC8(struct Sprite *sprite);
+void sub_805EB54(struct Sprite *sprite);
+void sub_805EBE0(struct Sprite *sprite);
+void sub_805EC6C(struct Sprite *sprite);
+void sub_805ECF8(struct Sprite *sprite);
+void sub_805ED84(struct Sprite *sprite);
+void sub_805EE10(struct Sprite *sprite);
+void sub_805EE9C(struct Sprite *sprite);
+void sub_805EF28(struct Sprite *sprite);
+void sub_805EFB4(struct Sprite *sprite);
+void sub_805F040(struct Sprite *sprite);
+void sub_805F0CC(struct Sprite *sprite);
+void sub_805F158(struct Sprite *sprite);
+void sub_805F1E4(struct Sprite *sprite);
+void sub_805F270(struct Sprite *sprite);
+void sub_805F2FC(struct Sprite *sprite);
+void FieldObjectCB_TreeDisguise(struct Sprite *sprite);
+void FieldObjectCB_MountainDisguise(struct Sprite *sprite);
+void sub_805F8E0(struct Sprite *sprite);
+void FieldObjectCB_Hidden1(struct Sprite *sprite);
+void sub_805FB20(struct Sprite *sprite);
+void sub_805FB90(struct Sprite *sprite);
+void sub_805FC00(struct Sprite *sprite);
+void sub_805FC70(struct Sprite *sprite);
+
+asm(".section .text_b\n");
+
+void npc_reset(struct MapObject *mapObject, struct Sprite *sprite)
+{
+    mapObject->mapobj_bit_1 = 0;
+    mapObject->mapobj_bit_6 = 0;
+    mapObject->mapobj_bit_7 = 0;
+    mapObject->mapobj_unk_1C = 0xff;
+    sprite->data1 = 0;
+}
+
+extern const u8 gUnknown_083755F4[9];
+extern const u8 gUnknown_083755FD[9];
+extern const u8 gUnknown_08375606[9];
+extern const u8 gUnknown_0837560F[9];
+extern const u8 gUnknown_08375618[9];
+extern const u8 gUnknown_08375621[9];
+extern const u8 gUnknown_0837562A[9];
+extern const u8 gUnknown_08375633[9];
+extern const u8 gUnknown_0837563C[9];
+extern const u8 gUnknown_08375645[9];
+extern const u8 gUnknown_0837564E[9];
+extern const u8 gUnknown_08375657[9];
+extern const u8 gUnknown_08375660[9];
+extern const u8 gUnknown_08375669[9];
+extern const u8 gUnknown_08375672[9];
+
+u8 FieldObjectDirectionToImageAnimId(u8 direction)
+{
+    return gUnknown_083755F4[direction];
+}
+
+u8 get_go_image_anim_num(u8 direction)
+{
+    return gUnknown_083755FD[direction];
+}
+
+u8 get_go_fast_image_anim_num(u8 direction)
+{
+    return gUnknown_08375606[direction];
+}
+
+u8 get_go_faster_image_anim_num(u8 direction)
+{
+    return gUnknown_0837560F[direction];
+}
+
+u8 sub_805FD78(u8 direction)
+{
+    return gUnknown_08375618[direction];
+}
+
+u8 sub_805FD88(u8 direction)
+{
+    return gUnknown_08375621[direction];
+}
+
+u8 sub_805FD98(u8 direction)
+{
+    return gUnknown_0837562A[direction];
+}
+
+u8 unref_sub_805FDA8(u8 direction)
+{
+    return gUnknown_08375633[direction];
+}
+
+u8 sub_805FDB8(u8 direction)
+{
+    return gUnknown_0837563C[direction];
+}
+
+u8 sub_805FDC8(u8 direction)
+{
+    return gUnknown_08375645[direction];
+}
+
+u8 sub_805FDD8(u8 direction)
+{
+    return gUnknown_0837564E[direction];
+}
+
+u8 sub_805FDE8(u8 direction)
+{
+    return gUnknown_08375657[direction];
+}
+
+u8 sub_805FDF8(u8 direction)
+{
+    return gUnknown_08375660[direction];
+}
+
+u8 sub_805FE08(u8 direction)
+{
+    return gUnknown_08375669[direction];
+}
+
+u8 get_run_image_anim_num(u8 direction)
+{
+    return gUnknown_08375672[direction];
+}
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
index 6a0fe1dce..71ff40435 100644
--- a/src/field_player_avatar.c
+++ b/src/field_player_avatar.c
@@ -27,7 +27,7 @@ extern u8 gOtherText_ItGotAway[];
 extern u32 gUnknown_0202FF84[];
 
 //Functions
-static u32 sub_80587D8(void);
+static u8 sub_80587D8(void);
 static bool8 sub_8058854(struct MapObject *, u8);
 static void npc_clear_strange_bits(struct MapObject *a);
 static void MovePlayerAvatarUsingKeypadInput(u8 a, u16 b, u16 c);
@@ -252,7 +252,7 @@ void sub_80587B4(struct Sprite *sprite)
     meta_step(&gMapObjects[sprite->data0], sprite, sub_80587D8);
 }
 
-static u32 sub_80587D8(void)
+static u8 sub_80587D8(void)
 {
     return 0;
 }
diff --git a/src/rom3.c b/src/rom3.c
index 0169128cb..ef7b9a7ed 100644
--- a/src/rom3.c
+++ b/src/rom3.c
@@ -582,7 +582,7 @@ void sub_800C47C(u8 taskId)
     }
 }
 
-void dp01_build_cmdbuf_x00_a_b_0(u8 a, int b, int c)
+void dp01_build_cmdbuf_x00_a_b_0(u8 a, u8 b, u8 c)
 {
     gUnknown_03004040[0] = 0;
     gUnknown_03004040[1] = b;
@@ -591,7 +591,7 @@ void dp01_build_cmdbuf_x00_a_b_0(u8 a, int b, int c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x01_a_b_0(u8 a, int b, int c)
+void dp01_build_cmdbuf_x01_a_b_0(u8 a, u8 b, u8 c)
 {
     gUnknown_03004040[0] = 1;
     gUnknown_03004040[1] = b;
@@ -600,7 +600,7 @@ void dp01_build_cmdbuf_x01_a_b_0(u8 a, int b, int c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x02_a_b_varargs(u8 a, int b, int c, u8 d, u8 *e)
+void dp01_build_cmdbuf_x02_a_b_varargs(u8 a, u8 b, u8 c, u8 d, u8 *e)
 {
     int i;
 
@@ -612,7 +612,7 @@ void dp01_build_cmdbuf_x02_a_b_varargs(u8 a, int b, int c, u8 d, u8 *e)
     dp01_prepare_buffer(a, gUnknown_03004040, d + 3);
 }
 
-void unref_sub_800C6A4(u8 a, int b, u8 c, u8 *d)
+void unref_sub_800C6A4(u8 a, u8 b, u8 c, u8 *d)
 {
     int i;
 
@@ -633,7 +633,7 @@ void dp01_build_cmdbuf_x04_4_4_4(u8 a)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void sub_800C704(u8 a, int b, int c)
+void sub_800C704(u8 a, u8 b, u8 c)
 {
     gUnknown_03004040[0] = 5;
     gUnknown_03004040[1] = b;
@@ -642,7 +642,7 @@ void sub_800C704(u8 a, int b, int c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x06_a(u8 a, int b)
+void dp01_build_cmdbuf_x06_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 6;
     gUnknown_03004040[1] = b;
@@ -703,7 +703,7 @@ void dp01_build_cmdbuf_x0C_C_C_C(u8 a)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x0D_a(u8 a, int b)
+void dp01_build_cmdbuf_x0D_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 13;
     gUnknown_03004040[1] = b;
@@ -721,7 +721,7 @@ void unref_sub_800C828(u8 a, u8 b, u8 *c)
     dp01_prepare_buffer(a, gUnknown_03004040, b * 3 + 2);
 }
 
-void dp01_build_cmdbuf_x0F_aa_b_cc_dddd_e_mlc_weather_00_x1Cbytes(u8 a, u16 b, u8 c, u16 d, int e, u8 f, u8 *g)
+void dp01_build_cmdbuf_x0F_aa_b_cc_dddd_e_mlc_weather_00_x1Cbytes(u8 a, u16 b, u8 c, u16 d, s32 e, u8 f, u8 *g)
 {
     gUnknown_03004040[0] = 15;
     gUnknown_03004040[1] = b;
@@ -1039,7 +1039,7 @@ _0800CB54: .4byte gUnknown_030041C0\n\
     .syntax divided\n");
 }
 
-void dp01_build_cmdbuf_x12_a_bb(u8 a, int b, u16 c)
+void dp01_build_cmdbuf_x12_a_bb(u8 a, u8 b, u16 c)
 {
     gUnknown_03004040[0] = 18;
     gUnknown_03004040[1] = b;
@@ -1048,14 +1048,14 @@ void dp01_build_cmdbuf_x12_a_bb(u8 a, int b, u16 c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void unref_sub_800CB84(u8 a, int b)
+void unref_sub_800CB84(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 19;
     gUnknown_03004040[1] = b;
     dp01_prepare_buffer(a, gUnknown_03004040, 2);
 }
 
-void sub_800CBA4(u8 a, int b, int c, u8 *d)
+void sub_800CBA4(u8 a, u8 b, u8 c, u8 *d)
 {
     u32 i;
 
@@ -1078,7 +1078,7 @@ void sub_800CBE0(u8 a, u8 *b)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x16_a_b_c_ptr_d_e_f(u8 a, int b, int c, int d, u8 *e)
+void dp01_build_cmdbuf_x16_a_b_c_ptr_d_e_f(u8 a, u8 b, u8 c, u8 d, u8 *e)
 {
     int i;
 
@@ -1109,7 +1109,7 @@ void dp01_build_cmdbuf_x18_0_aa_health_bar_update(u8 a, s16 b)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x19_a_bb(u8 a, int b, s16 c)
+void dp01_build_cmdbuf_x19_a_bb(u8 a, u8 b, s16 c)
 {
     gUnknown_03004040[0] = 25;
     gUnknown_03004040[1] = b;
@@ -1132,7 +1132,7 @@ void dp01_build_cmdbuf_x1A_aaaa_bbbb(u8 a, u32 b, u32 c)
     dp01_prepare_buffer(a, gUnknown_03004040, 9);
 }
 
-void dp01_build_cmdbuf_x1B_aaaa_b(u8 a, int b, u32 c)
+void dp01_build_cmdbuf_x1B_aaaa_b(u8 a, u8 b, u32 c)
 {
     gUnknown_03004040[0] = 27;
     gUnknown_03004040[1] = b;
@@ -1143,7 +1143,7 @@ void dp01_build_cmdbuf_x1B_aaaa_b(u8 a, int b, u32 c)
     dp01_prepare_buffer(a, gUnknown_03004040, 6);
 }
 
-void dp01_build_cmdbuf_x1C_a(u8 a, int b)
+void dp01_build_cmdbuf_x1C_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 28;
     gUnknown_03004040[1] = b;
@@ -1203,7 +1203,7 @@ void unref_sub_800CE84(u8 a, u16 b, u8 *c)
     dp01_prepare_buffer(a, gUnknown_03004040, b + 3);
 }
 
-void dp01_build_cmdbuf_x21_a_bb(u8 a, int b, u16 c)
+void dp01_build_cmdbuf_x21_a_bb(u8 a, u8 b, u16 c)
 {
     gUnknown_03004040[0] = 33;
     gUnknown_03004040[1] = b;
@@ -1212,7 +1212,7 @@ void dp01_build_cmdbuf_x21_a_bb(u8 a, int b, u16 c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x22_a_three_bytes(u8 a, int b, u8 *c)
+void dp01_build_cmdbuf_x22_a_three_bytes(u8 a, u8 b, u8 *c)
 {
     int i;
 
@@ -1250,7 +1250,7 @@ void dp01_build_cmdbuf_x25_25_25_25(u8 a)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x26_a(u8 a, int b)
+void dp01_build_cmdbuf_x26_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 38;
     gUnknown_03004040[1] = b;
@@ -1320,7 +1320,7 @@ void dp01_build_cmdbuf_x2D_2D_2D_2D(u8 a)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x2E_a(u8 a, int b)
+void dp01_build_cmdbuf_x2E_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 46;
     gUnknown_03004040[1] = b;
@@ -1367,7 +1367,7 @@ void dp01_build_cmdbuf_x32_32_32_32(u8 a)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x33_a_33_33(u8 a, int b)
+void dp01_build_cmdbuf_x33_a_33_33(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 51;
     gUnknown_03004040[1] = b;
@@ -1376,7 +1376,7 @@ void dp01_build_cmdbuf_x33_a_33_33(u8 a, int b)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void dp01_build_cmdbuf_x34_a_bb_aka_battle_anim(u8 a, int b, u16 c)
+void dp01_build_cmdbuf_x34_a_bb_aka_battle_anim(u8 a, u8 b, u16 c)
 {
     gUnknown_03004040[0] = 52;
     gUnknown_03004040[1] = b;
@@ -1385,21 +1385,21 @@ void dp01_build_cmdbuf_x34_a_bb_aka_battle_anim(u8 a, int b, u16 c)
     dp01_prepare_buffer(a, gUnknown_03004040, 4);
 }
 
-void sub_800D1D8(u8 a, int b)
+void sub_800D1D8(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 53;
     gUnknown_03004040[1] = b;
     dp01_prepare_buffer(a, gUnknown_03004040, 2);
 }
 
-void dp01_build_cmdbuf_x38_a(u8 a, int b)
+void dp01_build_cmdbuf_x38_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 54;
     gUnknown_03004040[1] = b;
     dp01_prepare_buffer(a, gUnknown_03004040, 2);
 }
 
-void dp01_build_cmdbuf_x37_a(u8 a, int b)
+void dp01_build_cmdbuf_x37_a(u8 a, u8 b)
 {
     gUnknown_03004040[0] = 55;
     gUnknown_03004040[1] = b;
diff --git a/src/rom_8077ABC.c b/src/rom_8077ABC.c
index b216bbe97..437c62400 100644
--- a/src/rom_8077ABC.c
+++ b/src/rom_8077ABC.c
@@ -20,7 +20,6 @@
 #define NUM_BATTLE_SLOTS 4
 
 #define gBattleMonPartyPositions gUnknown_02024A6A
-#define gCastformFrontSpriteCoords gUnknownCastformCoords_0837F598
 #define gCastformElevations gUnknownCastformData_0837F5A8
 #define gCastformBackSpriteYCoords gUnknown_0837F5AC
 #define gTransformPersonalities gUnknown_02024E70