summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/battle_2.c1343
-rw-r--r--src/battle_script_commands.c3
-rw-r--r--src/egg_hatch.c6
-rw-r--r--src/pokemon_2.c12
-rw-r--r--src/pokemon_3.c4
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++)
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-07 13:53:50 +0000