start decompiling battle2

5 files changed, 1355 insertions, 13 deletions

diff --git a/src/battle_2.c b/src/battle_2.c
new file mode 100644
index 000000000..844827326
--- /dev/null
+++ b/src/battle_2.c
@@ -0,0 +1,1343 @@
+#include "global.h"
+#include "battle.h"
+#include "recorded_battle.h"
+#include "main.h"
+#include "load_save.h"
+#include "gpu_regs.h"
+#include "unknown_task.h"
+#include "battle_setup.h"
+#include "pokemon.h"
+#include "palette.h"
+#include "task.h"
+#include "event_data.h"
+#include "species.h"
+#include "berry.h"
+#include "text.h"
+#include "items.h"
+#include "hold_effects.h"
+#include "link.h"
+#include "bg.h"
+#include "dma3.h"
+#include "string_util.h"
+#include "malloc.h"
+
+struct UnknownStruct6
+{
+    u16 unk0[0xA0];
+    u8 fillerA0[0x640];
+    u16 unk780[0xA0];
+};
+
+struct UnknownPokemonStruct2
+{
+    /*0x00*/ u16 species;
+    /*0x02*/ u16 heldItem;
+    /*0x04*/ u8 nickname[POKEMON_NAME_LENGTH + 1];
+    /*0x0F*/ u8 level;
+    /*0x10*/ u16 hp;
+    /*0x12*/ u16 maxhp;
+    /*0x14*/ u32 status;
+    /*0x18*/ u32 personality;
+    /*0x1C*/ u8 gender;
+    /*0x1D*/ u8 language;
+};
+
+extern u32 gBattleTypeFlags;
+extern u8 gBattleCommunication[];
+extern u8 gBattleTerrain;
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG0_Y;
+extern u16 gBattle_BG1_X;
+extern u16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_X;
+extern u16 gBattle_BG2_Y;
+extern u16 gBattle_BG3_X;
+extern u16 gBattle_BG3_Y;
+extern u16 gPartnerTrainerId;
+extern u16 gBattle_WIN0H;
+extern u16 gBattle_WIN0V;
+extern u16 gBattle_WIN1H;
+extern u16 gBattle_WIN1V;
+extern u16 gTrainerBattleOpponent_A;
+extern u16 gTrainerBattleOpponent_B;
+extern struct BattleEnigmaBerry gEnigmaBerries[BATTLE_BANKS_COUNT];
+extern void (*gPreBattleCallback1)(void);
+extern struct UnknownPokemonStruct2 gUnknown_02022FF8[3]; // what is it used for?
+extern struct UnknownPokemonStruct2* gUnknown_02023058; // what is it used for?
+
+extern struct UnknownStruct6 gUnknown_02038C28; // todo: identify & document
+
+extern void HandleLinkBattleSetup(void); // rom_3
+extern void SetUpBattleVarsAndBirchZigzagoon(void); // rom_3
+extern void sub_8032768(void); // rom_3
+extern void dp12_8087EA4(void);
+extern void c2_berry_program_update_menu(void);
+extern void GetFrontierTrainerName(u8* dst, u16 trainerId); // battle tower
+extern void sub_8166188(void); // battle tower, sets link battle mons level but why?
+extern void sub_8165B88(u8* dst, u16 trainerId); // battle tower, gets language
+extern void sub_81DB4DC(u8* dst, u8 arg2); //
+extern void sub_81B9150(void);
+extern void sub_800ADF8(void);
+extern void sub_800AC34(void);
+
+// this file's functions
+static void CB2_InitBattleInternal(void);
+static void CB2_PreInitMultiBattle(void);
+static void CB2_PreInitIngamePlayerPartnerBattle(void);
+static void CB2_HandleStartMultiPartnerBattle(void);
+static void CB2_HandleStartMultiBattle(void);
+static void CB2_HandleStartBattle(void);
+void shedinja_something(struct Pokemon *mon);
+void CreateNPCTrainerParty(struct Pokemon *party, u16 trainerNum, bool8 firstTrainer);
+void BattleMainCB1(void);
+
+void CB2_InitBattle(void)
+{
+    MoveSaveBlocks_ResetHeap();
+    AllocateBattleResrouces();
+    AllocateBattleSpritesData();
+    AllocateMonSpritesGfx();
+    sub_8185F84();
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+        {
+            CB2_InitBattleInternal();
+        }
+        else if (!(gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER))
+        {
+            HandleLinkBattleSetup();
+            SetMainCallback2(CB2_PreInitMultiBattle);
+        }
+        else
+        {
+            SetMainCallback2(CB2_PreInitIngamePlayerPartnerBattle);
+        }
+        gBattleCommunication[MULTIUSE_STATE] = 0;
+    }
+    else
+    {
+        CB2_InitBattleInternal();
+    }
+}
+
+static void CB2_InitBattleInternal(void)
+{
+    s32 i;
+
+    SetHBlankCallback(NULL);
+    SetVBlankCallback(NULL);
+
+    CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+
+    SetGpuReg(REG_OFFSET_MOSAIC, 0);
+    SetGpuReg(REG_OFFSET_WIN0H, 240);
+    SetGpuReg(REG_OFFSET_WIN0V, 0x5051);
+    SetGpuReg(REG_OFFSET_WININ, 0);
+    SetGpuReg(REG_OFFSET_WINOUT, 0);
+
+    gBattle_WIN0H = 240;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId != STEVEN_PARTNER_ID)
+    {
+        gBattle_WIN0V = 159;
+        gBattle_WIN1H = 240;
+        gBattle_WIN1V = 32;
+    }
+    else
+    {
+        gBattle_WIN0V = 0x5051;
+        dp12_8087EA4();
+
+        for (i = 0; i < 80; i++)
+        {
+            gUnknown_02038C28.unk0[i] = 0xF0;
+            gUnknown_02038C28.unk780[i] = 0xF0;
+        }
+        for (i = 80; i < 160; i++)
+        {
+            #ifndef NONMATCHING
+                asm(""::"r"(i)); // needed to match
+            #endif // NONMATCHING
+
+            gUnknown_02038C28.unk0[i] = 0xFF10;
+            gUnknown_02038C28.unk780[i] = 0xFF10;
+        }
+
+        sub_80BA038(gUnknown_0831AC70);
+    }
+
+    ResetPaletteFade();
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    gBattle_BG1_X = 0;
+    gBattle_BG1_Y = 0;
+    gBattle_BG2_X = 0;
+    gBattle_BG2_Y = 0;
+    gBattle_BG3_X = 0;
+    gBattle_BG3_Y = 0;
+
+    gBattleTerrain = BattleSetup_GetTerrainId();
+    if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+        gBattleTerrain = BATTLE_TERRAIN_INSIDE;
+
+    c2_berry_program_update_menu();
+    LoadBattleTextboxAndBackground();
+    ResetSpriteData();
+    ResetTasks();
+    LoadBattleEntryBackground();
+    FreeAllSpritePalettes();
+    gReservedSpritePaletteCount = 4;
+    SetVBlankCallback(VBlankCB_Battle);
+    SetUpBattleVarsAndBirchZigzagoon();
+
+    if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+        SetMainCallback2(CB2_HandleStartMultiPartnerBattle);
+    else if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)
+        SetMainCallback2(CB2_HandleStartMultiPartnerBattle);
+    else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+        SetMainCallback2(CB2_HandleStartMultiBattle);
+    else
+        SetMainCallback2(CB2_HandleStartBattle);
+
+    if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED)))
+    {
+        CreateNPCTrainerParty(&gEnemyParty[0], gTrainerBattleOpponent_A, TRUE);
+        if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
+            CreateNPCTrainerParty(&gEnemyParty[3], gTrainerBattleOpponent_B, FALSE);
+        SetWildMonHeldItem();
+    }
+
+    gMain.inBattle = TRUE;
+    gSaveBlock2Ptr->field_CA9_b = 0;
+
+    for (i = 0; i < 6; i++)
+        AdjustFriendship(&gPlayerParty[i], 3);
+
+    gBattleCommunication[MULTIUSE_STATE] = 0;
+}
+
+static void sub_8036A5C(void)
+{
+    u16 r6 = 0;
+    u16 species = 0;
+    u16 hp = 0;
+    u32 status = 0;
+    s32 i;
+
+    for (i = 0; i < 6; i++)
+    {
+        species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2);
+        hp = GetMonData(&gPlayerParty[i], MON_DATA_HP);
+        status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS);
+
+        if (species == SPECIES_NONE)
+            continue;
+        if (species != SPECIES_EGG && hp != 0 && status == 0)
+            r6 |= 1 << i * 2;
+
+        if (species == SPECIES_NONE)
+            continue;
+        if (hp != 0 && (species == SPECIES_EGG || status != 0))
+            r6 |= 2 << i * 2;
+
+        if (species == SPECIES_NONE)
+            continue;
+        if (species != SPECIES_EGG && hp == 0)
+            r6 |= 3 << i * 2;
+    }
+
+    gBattleStruct->field_182 = r6;
+    *(&gBattleStruct->field_183) = r6 >> 8;
+    gBattleStruct->field_183 |= FlagGet(SYS_FRONTIER_PASS) << 7;
+}
+
+static void SetPlayerBerryDataInBattleStruct(void)
+{
+    s32 i;
+    struct BattleStruct *battleStruct = gBattleStruct;
+    struct BattleEnigmaBerry *battleBerry = &battleStruct->battleEnigmaBerry;
+
+    if (IsEnigmaBerryValid() == TRUE)
+    {
+        for (i = 0; i < BERRY_NAME_COUNT - 1; i++)
+            battleBerry->name[i] = gSaveBlock1Ptr->enigmaBerry.berry.name[i];
+        battleBerry->name[i] = EOS;
+
+        for (i = 0; i < BERRY_ITEM_EFFECT_COUNT; i++)
+            battleBerry->itemEffect[i] = gSaveBlock1Ptr->enigmaBerry.itemEffect[i];
+
+        battleBerry->holdEffect = gSaveBlock1Ptr->enigmaBerry.holdEffect;
+        battleBerry->holdEffectParam = gSaveBlock1Ptr->enigmaBerry.holdEffectParam;
+    }
+    else
+    {
+        const struct Berry* berryData = GetBerryInfo(ItemIdToBerryType(ITEM_ENIGMA_BERRY));
+
+        for (i = 0; i < BERRY_NAME_COUNT - 1; i++)
+            battleBerry->name[i] = berryData->name[i];
+        battleBerry->name[i] = EOS;
+
+        for (i = 0; i < BERRY_ITEM_EFFECT_COUNT; i++)
+            battleBerry->itemEffect[i] = 0;
+
+        battleBerry->holdEffect = HOLD_EFFECT_NONE;
+        battleBerry->holdEffectParam = 0;
+    }
+}
+
+static void SetAllPlayersBerryData(void)
+{
+    s32 i;
+    s32 j;
+
+    if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
+    {
+        if (IsEnigmaBerryValid() == TRUE)
+        {
+            for (i = 0; i < BERRY_NAME_COUNT - 1; i++)
+            {
+                gEnigmaBerries[0].name[i] = gSaveBlock1Ptr->enigmaBerry.berry.name[i];
+                gEnigmaBerries[2].name[i] = gSaveBlock1Ptr->enigmaBerry.berry.name[i];
+            }
+            gEnigmaBerries[0].name[i] = EOS;
+            gEnigmaBerries[2].name[i] = EOS;
+
+            for (i = 0; i < BERRY_ITEM_EFFECT_COUNT; i++)
+            {
+                gEnigmaBerries[0].itemEffect[i] = gSaveBlock1Ptr->enigmaBerry.itemEffect[i];
+                gEnigmaBerries[2].itemEffect[i] = gSaveBlock1Ptr->enigmaBerry.itemEffect[i];
+            }
+
+            gEnigmaBerries[0].holdEffect = gSaveBlock1Ptr->enigmaBerry.holdEffect;
+            gEnigmaBerries[2].holdEffect = gSaveBlock1Ptr->enigmaBerry.holdEffect;
+            gEnigmaBerries[0].holdEffectParam = gSaveBlock1Ptr->enigmaBerry.holdEffectParam;
+            gEnigmaBerries[2].holdEffectParam = gSaveBlock1Ptr->enigmaBerry.holdEffectParam;
+        }
+        else
+        {
+            const struct Berry* berryData = GetBerryInfo(ItemIdToBerryType(ITEM_ENIGMA_BERRY));
+
+            for (i = 0; i < BERRY_NAME_COUNT - 1; i++)
+            {
+                gEnigmaBerries[0].name[i] = berryData->name[i];
+                gEnigmaBerries[2].name[i] = berryData->name[i];
+            }
+            gEnigmaBerries[0].name[i] = EOS;
+            gEnigmaBerries[2].name[i] = EOS;
+
+            for (i = 0; i < BERRY_ITEM_EFFECT_COUNT; i++)
+            {
+                gEnigmaBerries[0].itemEffect[i] = 0;
+                gEnigmaBerries[2].itemEffect[i] = 0;
+            }
+
+            gEnigmaBerries[0].holdEffect = 0;
+            gEnigmaBerries[2].holdEffect = 0;
+            gEnigmaBerries[0].holdEffectParam = 0;
+            gEnigmaBerries[2].holdEffectParam = 0;
+        }
+    }
+    else
+    {
+        s32 numPlayers;
+        struct BattleEnigmaBerry *src;
+        u8 r4;
+
+        if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+        {
+            if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+                numPlayers = 2;
+            else
+                numPlayers = 4;
+
+            for (i = 0; i < numPlayers; i++)
+            {
+                src = (struct BattleEnigmaBerry *)(gBlockRecvBuffer[i] + 2);
+                r4 = gLinkPlayers[i].lp_field_18;
+
+                for (j = 0; j < BERRY_NAME_COUNT - 1; j++)
+                    gEnigmaBerries[r4].name[j] = src->name[j];
+                gEnigmaBerries[r4].name[j] = EOS;
+
+                for (j = 0; j < BERRY_ITEM_EFFECT_COUNT; j++)
+                    gEnigmaBerries[r4].itemEffect[j] = src->itemEffect[j];
+
+                gEnigmaBerries[r4].holdEffect = src->holdEffect;
+                gEnigmaBerries[r4].holdEffectParam = src->holdEffectParam;
+            }
+        }
+        else
+        {
+            for (i = 0; i < 2; i++)
+            {
+                src = (struct BattleEnigmaBerry *)(gBlockRecvBuffer[i] + 2);
+
+                for (j = 0; j < BERRY_NAME_COUNT - 1; j++)
+                {
+                    gEnigmaBerries[i].name[j] = src->name[j];
+                    gEnigmaBerries[i + 2].name[j] = src->name[j];
+                }
+                gEnigmaBerries[i].name[j] = EOS;
+                gEnigmaBerries[i + 2].name[j] = EOS;
+
+                for (j = 0; j < BERRY_ITEM_EFFECT_COUNT; j++)
+                {
+                    gEnigmaBerries[i].itemEffect[j] = src->itemEffect[j];
+                    gEnigmaBerries[i + 2].itemEffect[j] = src->itemEffect[j];
+                }
+
+                gEnigmaBerries[i].holdEffect = src->holdEffect;
+                gEnigmaBerries[i + 2].holdEffect = src->holdEffect;
+                gEnigmaBerries[i].holdEffectParam = src->holdEffectParam;
+                gEnigmaBerries[i + 2].holdEffectParam = src->holdEffectParam;
+            }
+        }
+    }
+}
+
+static void sub_8036EB8(u8 arg0, u8 arg1)
+{
+    u8 var = 0;
+
+    if (gBlockRecvBuffer[0][0] == 256)
+    {
+        if (arg1 == 0)
+            gBattleTypeFlags |= BATTLE_TYPE_WILD | BATTLE_TYPE_TRAINER;
+        else
+            gBattleTypeFlags |= BATTLE_TYPE_TRAINER;
+        var++;
+    }
+
+    if (var == 0)
+    {
+        s32 i;
+
+        for (i = 0; i < arg0; i++)
+        {
+            if (gBlockRecvBuffer[0][0] != gBlockRecvBuffer[i][0])
+                break;
+        }
+
+        if (i == arg0)
+        {
+            if (arg1 == 0)
+                gBattleTypeFlags |= BATTLE_TYPE_WILD | BATTLE_TYPE_TRAINER;
+            else
+                gBattleTypeFlags |= BATTLE_TYPE_TRAINER;
+            var++;
+        }
+
+        if (var == 0)
+        {
+            for (i = 0; i < arg0; i++)
+            {
+                if (gBlockRecvBuffer[i][0] == 0x300)
+                {
+                    if (i != arg1 && i < arg1)
+                        break;
+                }
+                if (gBlockRecvBuffer[i][0] > 0x300 && i != arg1)
+                    break;
+            }
+
+            if (i == arg0)
+                gBattleTypeFlags |= BATTLE_TYPE_WILD | BATTLE_TYPE_TRAINER;
+            else
+                gBattleTypeFlags |= BATTLE_TYPE_TRAINER;
+        }
+    }
+}
+
+static void CB2_HandleStartBattle(void)
+{
+    u8 playerMultiplayerId;
+    u8 enemyMultiplayerId;
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+
+    playerMultiplayerId = GetMultiplayerId();
+    gBattleScripting.multiplayerId = playerMultiplayerId;
+    enemyMultiplayerId = playerMultiplayerId ^ BIT_SIDE;
+
+    switch (gBattleCommunication[MULTIUSE_STATE])
+    {
+    case 0:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ShowBg(0);
+            ShowBg(1);
+            ShowBg(2);
+            ShowBg(3);
+            sub_805EF14();
+            gBattleCommunication[MULTIUSE_STATE] = 1;
+        }
+        if (gLinkVSyncDisabled)
+            sub_800E0E8();
+        break;
+    case 1:
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            if (gReceivedRemoteLinkPlayers != 0)
+            {
+                if (sub_800A520())
+                {
+                    *(&gBattleStruct->field_180) = 0;
+                    *(&gBattleStruct->field_181) = 3;
+                    sub_8036A5C();
+                    SetPlayerBerryDataInBattleStruct();
+
+                    if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00)
+                    {
+                        gLinkPlayers[0].lp_field_18 = 0;
+                        gLinkPlayers[1].lp_field_18 = 1;
+                    }
+
+                    SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_180, 32);
+                    gBattleCommunication[MULTIUSE_STATE] = 2;
+                }
+                if (gLinkVSyncDisabled)
+                    sub_800DFB4(0, 0);
+            }
+        }
+        else
+        {
+            if (!(gBattleTypeFlags & BATTLE_TYPE_RECORDED))
+                gBattleTypeFlags |= BATTLE_TYPE_WILD;
+            gBattleCommunication[MULTIUSE_STATE] = 15;
+            SetAllPlayersBerryData();
+        }
+        break;
+    case 2:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            u8 taskId;
+
+            ResetBlockReceivedFlags();
+            sub_8036EB8(2, playerMultiplayerId);
+            SetAllPlayersBerryData();
+            taskId = CreateTask(task00_0800F6FC, 0);
+            gTasks[taskId].data[1] = 0x10E;
+            gTasks[taskId].data[2] = 0x5A;
+            gTasks[taskId].data[5] = 0;
+            gTasks[taskId].data[3] = gBattleStruct->field_182 | (gBattleStruct->field_183 << 8);
+            gTasks[taskId].data[4] = gBlockRecvBuffer[enemyMultiplayerId][1];
+            sub_8185F90(gBlockRecvBuffer[playerMultiplayerId][1]);
+            sub_8185F90(gBlockRecvBuffer[enemyMultiplayerId][1]);
+            sub_8068AA4();
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 3:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 4:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            memcpy(gEnemyParty, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 7:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty + 2, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 8:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            memcpy(gEnemyParty + 2, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 11:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty + 4, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 12:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            memcpy(gEnemyParty + 4, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon) * 2);
+            shedinja_something(&gEnemyParty[0]);
+            shedinja_something(&gEnemyParty[1]);
+            shedinja_something(&gEnemyParty[2]);
+            shedinja_something(&gEnemyParty[3]);
+            shedinja_something(&gEnemyParty[4]);
+            shedinja_something(&gEnemyParty[5]);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 15:
+        sub_8032768();
+        sub_8184E58();
+        gBattleCommunication[SPRITES_INIT_STATE1] = 0;
+        gBattleCommunication[SPRITES_INIT_STATE2] = 0;
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            s32 i;
+
+            for (i = 0; i < 2 && (gLinkPlayers[i].version & 0xFF) == 3; i++);
+
+            if (i == 2)
+                gBattleCommunication[MULTIUSE_STATE] = 16;
+            else
+                gBattleCommunication[MULTIUSE_STATE] = 18;
+        }
+        else
+        {
+            gBattleCommunication[MULTIUSE_STATE] = 18;
+        }
+        break;
+    case 16:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), &gRecordedBattleRngSeed, sizeof(gRecordedBattleRngSeed));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 17:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (!(gBattleTypeFlags & BATTLE_TYPE_WILD))
+                memcpy(&gRecordedBattleRngSeed, gBlockRecvBuffer[enemyMultiplayerId], sizeof(gRecordedBattleRngSeed));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 18:
+        if (BattleInitAllSprites(&gBattleCommunication[SPRITES_INIT_STATE1], &gBattleCommunication[SPRITES_INIT_STATE2]))
+        {
+            gPreBattleCallback1 = gMain.callback1;
+            gMain.callback1 = BattleMainCB1;
+            SetMainCallback2(BattleMainCB2);
+            if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+            {
+                gBattleTypeFlags |= BATTLE_TYPE_20;
+            }
+        }
+        break;
+    case 5:
+    case 9:
+    case 13:
+        gBattleCommunication[MULTIUSE_STATE]++;
+        gBattleCommunication[1] = 1;
+    case 6:
+    case 10:
+    case 14:
+        if (--gBattleCommunication[1] == 0)
+            gBattleCommunication[MULTIUSE_STATE]++;
+        break;
+    }
+}
+
+static void CB2_HandleStartMultiPartnerBattle(void)
+{
+    u8 playerMultiplayerId;
+    u8 enemyMultiplayerId;
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+
+    playerMultiplayerId = GetMultiplayerId();
+    gBattleScripting.multiplayerId = playerMultiplayerId;
+    enemyMultiplayerId = playerMultiplayerId ^ BIT_SIDE;
+
+    switch (gBattleCommunication[MULTIUSE_STATE])
+    {
+    case 0:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ShowBg(0);
+            ShowBg(1);
+            ShowBg(2);
+            ShowBg(3);
+            sub_805EF14();
+            gBattleCommunication[MULTIUSE_STATE] = 1;
+        }
+        if (gLinkVSyncDisabled)
+            sub_800E0E8();
+        // fall through
+    case 1:
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            if (gReceivedRemoteLinkPlayers != 0)
+            {
+                u8 language;
+
+                gLinkPlayers[0].lp_field_18 = 0;
+                gLinkPlayers[1].lp_field_18 = 2;
+                gLinkPlayers[2].lp_field_18 = 1;
+                gLinkPlayers[3].lp_field_18 = 3;
+                GetFrontierTrainerName(gLinkPlayers[2].name, gTrainerBattleOpponent_A);
+                GetFrontierTrainerName(gLinkPlayers[3].name, gTrainerBattleOpponent_B);
+                sub_8165B88(&language, gTrainerBattleOpponent_A);
+                gLinkPlayers[2].language = language;
+                sub_8165B88(&language, gTrainerBattleOpponent_B);
+                gLinkPlayers[3].language = language;
+
+                if (sub_800A520())
+                {
+                    *(&gBattleStruct->field_180) = 0;
+                    *(&gBattleStruct->field_181) = 3;
+                    sub_8036A5C();
+                    SetPlayerBerryDataInBattleStruct();
+                    SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_180, 32);
+                    gBattleCommunication[MULTIUSE_STATE] = 2;
+                }
+
+                if (gLinkVSyncDisabled)
+                    sub_800DFB4(0, 0);
+            }
+        }
+        else
+        {
+            if (!(gBattleTypeFlags & BATTLE_TYPE_RECORDED))
+                gBattleTypeFlags |= BATTLE_TYPE_WILD;
+            gBattleCommunication[MULTIUSE_STATE] = 13;
+            SetAllPlayersBerryData();
+        }
+        break;
+    case 2:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            u8 taskId;
+
+            ResetBlockReceivedFlags();
+            sub_8036EB8(2, playerMultiplayerId);
+            SetAllPlayersBerryData();
+            taskId = CreateTask(task00_0800F6FC, 0);
+            gTasks[taskId].data[1] = 0x10E;
+            gTasks[taskId].data[2] = 0x5A;
+            gTasks[taskId].data[5] = 0;
+            gTasks[taskId].data[3] = 0x145;
+            gTasks[taskId].data[4] = 0x145;
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 3:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 4:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (gLinkPlayers[playerMultiplayerId].lp_field_18 != 0)
+            {
+                memcpy(gPlayerParty, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon) * 2);
+                memcpy(gPlayerParty + 3, gBlockRecvBuffer[playerMultiplayerId], sizeof(struct Pokemon) * 2);
+            }
+            else
+            {
+                memcpy(gPlayerParty, gBlockRecvBuffer[playerMultiplayerId], sizeof(struct Pokemon) * 2);
+                memcpy(gPlayerParty + 3, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon) * 2);
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 5:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty + 2, sizeof(struct Pokemon));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 6:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (gLinkPlayers[playerMultiplayerId].lp_field_18 != 0)
+            {
+                memcpy(gPlayerParty + 2, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon));
+                memcpy(gPlayerParty + 5, gBlockRecvBuffer[playerMultiplayerId], sizeof(struct Pokemon));
+            }
+            else
+            {
+                memcpy(gPlayerParty + 2, gBlockRecvBuffer[playerMultiplayerId], sizeof(struct Pokemon));
+                memcpy(gPlayerParty + 5, gBlockRecvBuffer[enemyMultiplayerId], sizeof(struct Pokemon));
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 7:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gEnemyParty, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 8:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (GetMultiplayerId() != 0)
+            {
+                memcpy(gEnemyParty, gBlockRecvBuffer[0], sizeof(struct Pokemon) * 2);
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 9:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gEnemyParty + 2, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 10:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (GetMultiplayerId() != 0)
+            {
+                memcpy(gEnemyParty + 2, gBlockRecvBuffer[0], sizeof(struct Pokemon) * 2);
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 11:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gEnemyParty + 4, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 12:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (GetMultiplayerId() != 0)
+                memcpy(gEnemyParty + 4, gBlockRecvBuffer[0], sizeof(struct Pokemon) * 2);
+            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]);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 13:
+        sub_8032768();
+        sub_8184E58();
+        gBattleCommunication[SPRITES_INIT_STATE1] = 0;
+        gBattleCommunication[SPRITES_INIT_STATE2] = 0;
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            gBattleCommunication[MULTIUSE_STATE] = 14;
+        }
+        else
+        {
+            gBattleCommunication[MULTIUSE_STATE] = 16;
+        }
+        break;
+    case 14:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), &gRecordedBattleRngSeed, sizeof(gRecordedBattleRngSeed));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 15:
+        if ((GetBlockReceivedStatus() & 3) == 3)
+        {
+            ResetBlockReceivedFlags();
+            if (!(gBattleTypeFlags & BATTLE_TYPE_WILD))
+                memcpy(&gRecordedBattleRngSeed, gBlockRecvBuffer[enemyMultiplayerId], sizeof(gRecordedBattleRngSeed));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 16:
+        if (BattleInitAllSprites(&gBattleCommunication[SPRITES_INIT_STATE1], &gBattleCommunication[SPRITES_INIT_STATE2]))
+        {
+            sub_8166188();
+            gPreBattleCallback1 = gMain.callback1;
+            gMain.callback1 = BattleMainCB1;
+            SetMainCallback2(BattleMainCB2);
+            if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+            {
+                gBattleTypeFlags |= BATTLE_TYPE_20;
+            }
+        }
+        break;
+    }
+}
+
+static void sub_80379F8(u8 arrayIdPlus)
+{
+    s32 i;
+
+    for (i = 0; i < 3; i++)
+    {
+        gUnknown_02022FF8[i].species     = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_SPECIES);
+        gUnknown_02022FF8[i].heldItem    = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_HELD_ITEM);
+        GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_NICKNAME, gUnknown_02022FF8[i].nickname);
+        gUnknown_02022FF8[i].level       = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_LEVEL);
+        gUnknown_02022FF8[i].hp          = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_HP);
+        gUnknown_02022FF8[i].maxhp       = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_MAX_HP);
+        gUnknown_02022FF8[i].status      = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_STATUS);
+        gUnknown_02022FF8[i].personality = GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_PERSONALITY);
+        gUnknown_02022FF8[i].gender      = GetMonGender(&gPlayerParty[arrayIdPlus + i]);
+        StripExtCtrlCodes(gUnknown_02022FF8[i].nickname);
+        if (GetMonData(&gPlayerParty[arrayIdPlus + i], MON_DATA_LANGUAGE) != LANGUAGE_JAPANESE)
+            sub_81DB4DC(gUnknown_02022FF8[i].nickname, 0);
+    }
+    memcpy(gUnknown_02023058, gUnknown_02022FF8, sizeof(gUnknown_02022FF8));
+}
+
+static void CB2_PreInitMultiBattle(void)
+{
+    s32 i;
+    u8 playerMultiplierId;
+    s32 numPlayers = 4;
+    u8 r4 = 0xF;
+    u32* savedBattleTypeFlags;
+    void (**savedCallback)(void);
+
+    if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
+    {
+        numPlayers = 2;
+        r4 = 3;
+    }
+
+    playerMultiplierId = GetMultiplayerId();
+    gBattleScripting.multiplayerId = playerMultiplierId;
+    savedCallback = &gBattleStruct->savedCallback;
+    savedBattleTypeFlags = &gBattleStruct->savedBattleTypeFlags;
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+
+    switch (gBattleCommunication[MULTIUSE_STATE])
+    {
+    case 0:
+        if (gReceivedRemoteLinkPlayers != 0 && sub_800A520())
+        {
+            gUnknown_02023058 = Alloc(sizeof(struct UnknownPokemonStruct2) * 3);
+            sub_80379F8(0);
+            SendBlock(bitmask_all_link_players_but_self(), gUnknown_02023058, sizeof(struct UnknownPokemonStruct2) * 3);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 1:
+        if ((GetBlockReceivedStatus() & r4) == r4)
+        {
+            ResetBlockReceivedFlags();
+            for (i = 0; i < numPlayers; i++)
+            {
+                if (i == playerMultiplierId)
+                    continue;
+
+                if (numPlayers == 4)
+                {
+                    if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[playerMultiplierId].lp_field_18 & 1))
+                        || (gLinkPlayers[i].lp_field_18 & 1 && gLinkPlayers[playerMultiplierId].lp_field_18 & 1))
+                    {
+                        memcpy(gUnknown_02022FF8, gBlockRecvBuffer[i], sizeof(struct UnknownPokemonStruct2) * 3);
+                    }
+                }
+                else
+                {
+                    memcpy(gUnknown_02022FF8, gBlockRecvBuffer[i], sizeof(struct UnknownPokemonStruct2) * 3);
+                }
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+            *savedCallback = gMain.savedCallback;
+            *savedBattleTypeFlags = gBattleTypeFlags;
+            gMain.savedCallback = CB2_PreInitMultiBattle;
+            sub_81B9150();
+        }
+        break;
+    case 2:
+        if (sub_800A520() && !gPaletteFade.active)
+        {
+            gBattleCommunication[MULTIUSE_STATE]++;
+            if (gLinkVSyncDisabled)
+                sub_800ADF8();
+            else
+                sub_800AC34();
+        }
+        break;
+    case 3:
+        if (gLinkVSyncDisabled)
+        {
+            if (sub_8010500())
+            {
+                gBattleTypeFlags = *savedBattleTypeFlags;
+                gMain.savedCallback = *savedCallback;
+                SetMainCallback2(CB2_InitBattleInternal);
+                Free(gUnknown_02023058);
+                gUnknown_02023058 = NULL;
+            }
+        }
+        else if (gReceivedRemoteLinkPlayers == 0)
+        {
+            gBattleTypeFlags = *savedBattleTypeFlags;
+            gMain.savedCallback = *savedCallback;
+            SetMainCallback2(CB2_InitBattleInternal);
+            Free(gUnknown_02023058);
+            gUnknown_02023058 = NULL;
+        }
+        break;
+    }
+}
+
+static void CB2_PreInitIngamePlayerPartnerBattle(void)
+{
+    u32* savedBattleTypeFlags;
+    void (**savedCallback)(void);
+
+    savedCallback = &gBattleStruct->savedCallback;
+    savedBattleTypeFlags = &gBattleStruct->savedBattleTypeFlags;
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+
+    switch (gBattleCommunication[MULTIUSE_STATE])
+    {
+    case 0:
+        gUnknown_02023058 = Alloc(sizeof(struct UnknownPokemonStruct2) * 3);
+        sub_80379F8(3);
+        gBattleCommunication[MULTIUSE_STATE]++;
+        *savedCallback = gMain.savedCallback;
+        *savedBattleTypeFlags = gBattleTypeFlags;
+        gMain.savedCallback = CB2_PreInitIngamePlayerPartnerBattle;
+        sub_81B9150();
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            gBattleCommunication[MULTIUSE_STATE] = 2;
+            gBattleTypeFlags = *savedBattleTypeFlags;
+            gMain.savedCallback = *savedCallback;
+            SetMainCallback2(CB2_InitBattleInternal);
+            Free(gUnknown_02023058);
+            gUnknown_02023058 = NULL;
+        }
+        break;
+    }
+}
+
+static void CB2_HandleStartMultiBattle(void)
+{
+    u8 playerMultiplayerId;
+    s32 id;
+    u8 var;
+
+    playerMultiplayerId = GetMultiplayerId();
+    gBattleScripting.multiplayerId = playerMultiplayerId;
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+
+    switch (gBattleCommunication[MULTIUSE_STATE])
+    {
+    case 0:
+        if (!IsDma3ManagerBusyWithBgCopy())
+        {
+            ShowBg(0);
+            ShowBg(1);
+            ShowBg(2);
+            ShowBg(3);
+            sub_805EF14();
+            gBattleCommunication[MULTIUSE_STATE] = 1;
+        }
+        if (gLinkVSyncDisabled)
+            sub_800E0E8();
+        break;
+    case 1:
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            if (gReceivedRemoteLinkPlayers != 0)
+            {
+                if (sub_800A520())
+                {
+                    *(&gBattleStruct->field_180) = 0;
+                    *(&gBattleStruct->field_181) = 3;
+                    sub_8036A5C();
+                    SetPlayerBerryDataInBattleStruct();
+
+                    SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_180, 32);
+                    gBattleCommunication[MULTIUSE_STATE]++;
+                }
+                if (gLinkVSyncDisabled)
+                    sub_800DFB4(0, 0);
+            }
+        }
+        else
+        {
+            if (!(gBattleTypeFlags & BATTLE_TYPE_RECORDED))
+                gBattleTypeFlags |= BATTLE_TYPE_WILD;
+            gBattleCommunication[MULTIUSE_STATE] = 7;
+            SetAllPlayersBerryData();
+        }
+        break;
+    case 2:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            sub_8036EB8(4, playerMultiplayerId);
+            SetAllPlayersBerryData();
+            sub_8068AA4();
+            var = CreateTask(task00_0800F6FC, 0);
+            gTasks[var].data[1] = 0x10E;
+            gTasks[var].data[2] = 0x5A;
+            gTasks[var].data[5] = 0;
+            gTasks[var].data[3] = 0;
+            gTasks[var].data[4] = 0;
+
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            {
+                sub_8185F90(gBlockRecvBuffer[id][1]);
+                switch (gLinkPlayers[id].lp_field_18)
+                {
+                case 0:
+                    gTasks[var].data[3] |= gBlockRecvBuffer[id][1] & 0x3F;
+                    break;
+                case 1:
+                    gTasks[var].data[4] |= gBlockRecvBuffer[id][1] & 0x3F;
+                    break;
+                case 2:
+                    gTasks[var].data[3] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
+                    break;
+                case 3:
+                    gTasks[var].data[4] |= (gBlockRecvBuffer[id][1] & 0x3F) << 6;
+                    break;
+                }
+            }
+            ZeroEnemyPartyMons();
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        else
+            break;
+        // fall through
+    case 3:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty, sizeof(struct Pokemon) * 2);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 4:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            {
+                if (id == playerMultiplayerId)
+                {
+                    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
+                {
+                    if ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerMultiplayerId].lp_field_18 & 1))
+                     || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerMultiplayerId].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)
+                        {
+                        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;
+                        }
+                    }
+                }
+            }
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 5:
+        if (sub_800A520())
+        {
+            SendBlock(bitmask_all_link_players_but_self(), gPlayerParty + 2, sizeof(struct Pokemon));
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 6:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            for (id = 0; id < MAX_LINK_PLAYERS; id++)
+            {
+                if (id == playerMultiplayerId)
+                {
+                    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 ((!(gLinkPlayers[id].lp_field_18 & 1) && !(gLinkPlayers[playerMultiplayerId].lp_field_18 & 1))
+                     || ((gLinkPlayers[id].lp_field_18 & 1) && (gLinkPlayers[playerMultiplayerId].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)
+                        {
+                        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(&gEnemyParty[0]);
+            shedinja_something(&gEnemyParty[1]);
+            shedinja_something(&gEnemyParty[2]);
+            shedinja_something(&gEnemyParty[3]);
+            shedinja_something(&gEnemyParty[4]);
+            shedinja_something(&gEnemyParty[5]);
+
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 7:
+        sub_8032768();
+        sub_8184E58();
+        gBattleCommunication[SPRITES_INIT_STATE1] = 0;
+        gBattleCommunication[SPRITES_INIT_STATE2] = 0;
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            for (id = 0; id < 4 && (gLinkPlayers[id].version & 0xFF) == 3; id++);
+
+            if (id == 4)
+                gBattleCommunication[MULTIUSE_STATE] = 8;
+            else
+                gBattleCommunication[MULTIUSE_STATE] = 10;
+        }
+        else
+        {
+            gBattleCommunication[MULTIUSE_STATE] = 10;
+        }
+        break;
+    case 8:
+        if (sub_800A520())
+        {
+            u32* ptr = (u32*)(&gBattleStruct->field_180);
+            ptr[0] = gBattleTypeFlags;
+            ptr[1] = gRecordedBattleRngSeed; // UB: overwrites berry data
+            SendBlock(bitmask_all_link_players_but_self(), ptr, 8);
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 9:
+        if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+        {
+            ResetBlockReceivedFlags();
+            for (var = 0; var < 4; var++)
+            {
+                u32 blockValue = gBlockRecvBuffer[var][0];
+                if (blockValue & 4)
+                {
+                    memcpy(&gRecordedBattleRngSeed, &gBlockRecvBuffer[var][2], sizeof(gRecordedBattleRngSeed));
+                    break;
+                }
+            }
+
+            gBattleCommunication[MULTIUSE_STATE]++;
+        }
+        break;
+    case 10:
+        if (BattleInitAllSprites(&gBattleCommunication[SPRITES_INIT_STATE1], &gBattleCommunication[SPRITES_INIT_STATE2]))
+        {
+            gPreBattleCallback1 = gMain.callback1;
+            gMain.callback1 = BattleMainCB1;
+            SetMainCallback2(BattleMainCB2);
+            if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+            {
+                gTrainerBattleOpponent_A = TRAINER_OPPONENT_800;
+                gBattleTypeFlags |= BATTLE_TYPE_20;
+            }
+        }
+        break;
+    }
+}
+
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index e0cb3e941..3b719b8ed 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -146,7 +146,6 @@ extern u8 sav1_map_get_light_level(void);
 extern u8 sub_813B21C(void);
 extern u16 get_unknown_box_id(void);
 extern void c2_berry_program_update_menu(void);
-extern void sub_8035AA4(void);
 
 // BattleScripts
 extern const u8 BattleScript_MoveEnd[];
@@ -11218,7 +11217,7 @@ static void atkF2_display_dex_info(void)
         break;
     case 3:
         c2_berry_program_update_menu();
-        sub_8035AA4();
+        LoadBattleTextboxAndBackground();
         gBattle_BG3_X = 0x100;
         gBattleCommunication[0]++;
         break;
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index 6d14e92f0..c5cee6357 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -64,7 +64,7 @@ extern void sub_806A068(u16, u8);
 extern void fade_screen(u8, u8);
 extern void overworld_free_bg_tilemaps(void);
 extern void sub_80AF168(void);
-extern void init_uns_table_pokemon_copy(void);
+extern void AllocateMonSpritesGfx(void);
 extern void sub_805F094(void);
 extern void remove_some_task(void);
 extern void reset_temp_tile_data_buffers(void);
@@ -439,7 +439,7 @@ static u8 EggHatchCreateMonSprite(u8 a0, u8 switchID, u8 pokeID, u16* speciesLoc
             u16 species = GetMonData(mon, MON_DATA_SPECIES);
             u32 pid = GetMonData(mon, MON_DATA_PERSONALITY);
             HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species],
-                                                      gBattleSpritesGfx->sprites[(a0 * 2) + 1],
+                                                      gMonSpritesGfxPtr->sprites[(a0 * 2) + 1],
                                                       species, pid);
             LoadCompressedObjectPalette(sub_806E794(mon));
             *speciesLoc = species;
@@ -488,7 +488,7 @@ static void CB2_EggHatch_0(void)
         SetGpuReg(REG_OFFSET_DISPCNT, 0);
 
         sEggHatchData = Alloc(sizeof(struct EggHatchData));
-        init_uns_table_pokemon_copy();
+        AllocateMonSpritesGfx();
         sEggHatchData->eggPartyID = gSpecialVar_0x8004;
         sEggHatchData->eggShardVelocityID = 0;
 
diff --git a/src/pokemon_2.c b/src/pokemon_2.c
index c5c36c793..8a16954a7 100644
--- a/src/pokemon_2.c
+++ b/src/pokemon_2.c
@@ -152,8 +152,8 @@ u8 GetGenderFromSpeciesAndPersonality(u16 species, u32 personality)
 
 void sub_806A068(u16 species, u8 bankIdentity)
 {
-    if (gBattleSpritesGfx != NULL)
-        gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+    if (gMonSpritesGfxPtr != NULL)
+        gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
     else if (gUnknown_020249B4[0])
         gUnknown_0202499C = gUnknown_020249B4[0]->templates[bankIdentity];
     else if (gUnknown_020249B4[1])
@@ -180,8 +180,8 @@ void sub_806A12C(u16 trainerSpriteId, u8 bankIdentity)
     }
     else
     {
-        if (gBattleSpritesGfx != NULL)
-            gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+        if (gMonSpritesGfxPtr != NULL)
+            gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
         else
             gUnknown_0202499C = gUnknown_08329D98[bankIdentity];
         gUnknown_0202499C.anims = gUnknown_0830536C[trainerSpriteId];
@@ -190,8 +190,8 @@ void sub_806A12C(u16 trainerSpriteId, u8 bankIdentity)
 
 void sub_806A1C0(u16 arg0, u8 bankIdentity)
 {
-    if (gBattleSpritesGfx != NULL)
-        gUnknown_0202499C = gBattleSpritesGfx->templates[bankIdentity];
+    if (gMonSpritesGfxPtr != NULL)
+        gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity];
     else
         gUnknown_0202499C = gUnknown_08329D98[bankIdentity];
     gUnknown_0202499C.paletteTag = arg0;
diff --git a/src/pokemon_3.c b/src/pokemon_3.c
index d44c0cb2f..e4934306c 100644
--- a/src/pokemon_3.c
+++ b/src/pokemon_3.c
@@ -486,8 +486,8 @@ u16 SpeciesToCryId(u16 species)
 void sub_806D544(u16 species, u32 personality, u8 *dest)
 {
     if (species == SPECIES_SPINDA
-        && dest != gBattleSpritesGfx->sprites[0]
-        && dest != gBattleSpritesGfx->sprites[2])
+        && dest != gMonSpritesGfxPtr->sprites[0]
+        && dest != gMonSpritesGfxPtr->sprites[2])
     {
         int i;
         for (i = 0; i < 4; i++)