summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/battle_main.c1191
-rw-r--r--src/berry.c4
-rw-r--r--src/item.c2
-rw-r--r--src/link.c2
-rw-r--r--src/mystery_gift_menu.c4
-rw-r--r--src/quest_log_battle.c6
6 files changed, 1200 insertions, 9 deletions
diff --git a/src/battle_main.c b/src/battle_main.c
index a109afbba..ebf775d7f 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -29,6 +29,7 @@
#include "m4a.h"
#include "palette.h"
#include "party_menu.h"
+#include "help_system.h"
#include "pokeball.h"
#include "pokedex.h"
#include "pokemon.h"
@@ -76,6 +77,17 @@ void HandleEndTurn_BattleLost(void);
void HandleEndTurn_RanFromBattle(void);
void HandleEndTurn_MonFled(void);
void HandleEndTurn_FinishBattle(void);
+void CB2_InitBattleInternal(void);
+void CB2_PreInitMultiBattle(void);
+void CB2_HandleStartMultiBattle(void);
+u8 CreateNPCTrainerParty(struct Pokemon *party, u16 trainerNum);
+void CB2_HandleStartBattle(void);
+void TryCorrectShedinjaLanguage(struct Pokemon *mon);
+void BattleMainCB1(void);
+void CB2_QuitPokeDudeBattle(void);
+void sub_80111FC(struct Sprite *sprite);
+void sub_8011B94(void);
+void sub_8011BB0(void);
// TODO: put ewram variables here after resolving symbol ref in between
@@ -465,3 +477,1182 @@ const u8 *const gStatusConditionStringsTable[7][2] =
{gStatusConditionString_ConfusionJpn, gText_Confusion},
{gStatusConditionString_LoveJpn, gText_Love}
};
+
+void CB2_InitBattle(void)
+{
+ MoveSaveBlocks_ResetHeap();
+ AllocateBattleResources();
+ AllocateBattleSpritesData();
+ AllocateMonSpritesGfx();
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ {
+ HandleLinkBattleSetup();
+ SetMainCallback2(CB2_PreInitMultiBattle);
+ gBattleCommunication[MULTIUSE_STATE] = 0;
+ }
+ else
+ {
+ CB2_InitBattleInternal();
+ if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_TRAINER)
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+ HelpSystem_SetSomeVariable2(0x19);
+ else
+ HelpSystem_SetSomeVariable2(0x18);
+ }
+ else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ {
+ HelpSystem_SetSomeVariable2(0x1A);
+ }
+ else
+ {
+ HelpSystem_SetSomeVariable2(0x17);
+ }
+ }
+ }
+}
+
+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, WIN_RANGE(0, 0xF0));
+ SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(0x50, 0x51));
+ SetGpuReg(REG_OFFSET_WININ, 0);
+ SetGpuReg(REG_OFFSET_WINOUT, 0);
+ gBattle_WIN0H = WIN_RANGE(0, 0xF0);
+ gBattle_WIN0V = WIN_RANGE(0x50, 0x51);
+ ScanlineEffect_Clear();
+ for (i = 0; i < 80; ++i)
+ {
+ gScanlineEffectRegBuffers[0][i] = 0xF0;
+ gScanlineEffectRegBuffers[1][i] = 0xF0;
+ }
+ for (; i < 160; ++i)
+ {
+ gScanlineEffectRegBuffers[0][i] = 0xFF10;
+ gScanlineEffectRegBuffers[1][i] = 0xFF10;
+ }
+ ScanlineEffect_SetParams(sIntroScanlineParams16Bit);
+ 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();
+ sub_800F34C();
+ LoadBattleTextboxAndBackground();
+ ResetSpriteData();
+ ResetTasks();
+ DrawBattleEntryBackground();
+ FreeAllSpritePalettes();
+ gReservedSpritePaletteCount = 4;
+ SetVBlankCallback(VBlankCB_Battle);
+ SetUpBattleVars();
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ SetMainCallback2(CB2_HandleStartMultiBattle);
+ else
+ SetMainCallback2(CB2_HandleStartBattle);
+ if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
+ {
+ CreateNPCTrainerParty(&gEnemyParty[0], gTrainerBattleOpponent_A);
+ SetWildMonHeldItem();
+ }
+ gMain.inBattle = TRUE;
+ for (i = 0; i < PARTY_SIZE; ++i)
+ AdjustFriendship(&gPlayerParty[i], 3);
+ gBattleCommunication[MULTIUSE_STATE] = 0;
+}
+
+void sub_800FFEC(void)
+{
+ u16 r6 = 0;
+ u16 species = SPECIES_NONE;
+ u16 hp = 0;
+ u32 status = 0;
+ s32 i;
+
+ for (i = 0; i < PARTY_SIZE; ++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_186 = r6;
+ *(&gBattleStruct->field_187) = r6 >> 8;
+}
+
+void SetPlayerBerryDataInBattleStruct(void)
+{
+ s32 i;
+ struct BattleStruct *battleStruct = gBattleStruct;
+ struct BattleEnigmaBerry *battleBerry = &battleStruct->battleEnigmaBerry;
+
+ if (IsEnigmaBerryValid() == TRUE)
+ {
+ for (i = 0; i < BERRY_NAME_LENGTH; ++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_LENGTH; ++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;
+ }
+}
+
+void SetAllPlayersBerryData(void)
+{
+ s32 i, j;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
+ {
+ if (IsEnigmaBerryValid() == TRUE)
+ {
+ for (i = 0; i < BERRY_NAME_LENGTH; ++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_LENGTH; ++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 = HOLD_EFFECT_NONE;
+ gEnigmaBerries[2].holdEffect = HOLD_EFFECT_NONE;
+ gEnigmaBerries[0].holdEffectParam = 0;
+ gEnigmaBerries[2].holdEffectParam = 0;
+ }
+ }
+ else
+ {
+ s32 numPlayers;
+ struct BattleEnigmaBerry *src;
+ u8 battlerId;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ {
+ for (i = 0; i < 4; ++i)
+ {
+ src = (struct BattleEnigmaBerry *)(gBlockRecvBuffer[i] + 2);
+ battlerId = gLinkPlayers[i].id;
+ for (j = 0; j < BERRY_NAME_LENGTH; ++j)
+ gEnigmaBerries[battlerId].name[j] = src->name[j];
+ gEnigmaBerries[battlerId].name[j] = EOS;
+ for (j = 0; j < BERRY_ITEM_EFFECT_COUNT; ++j)
+ gEnigmaBerries[battlerId].itemEffect[j] = src->itemEffect[j];
+ gEnigmaBerries[battlerId].holdEffect = src->holdEffect;
+ gEnigmaBerries[battlerId].holdEffectParam = src->holdEffectParam;
+ }
+ }
+ else
+ {
+ for (i = 0; i < 2; ++i)
+ {
+ src = (struct BattleEnigmaBerry *)(gBlockRecvBuffer[i] + 2);
+ for (j = 0; j < BERRY_NAME_LENGTH; ++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;
+ }
+ }
+ }
+}
+
+void sub_8010414(u8 arg0, u8 arg1)
+{
+ u8 var = 0;
+
+ if (gBlockRecvBuffer[0][0] == 256)
+ {
+ if (arg1 == 0)
+ gBattleTypeFlags |= BATTLE_TYPE_IS_MASTER | 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_IS_MASTER | BATTLE_TYPE_TRAINER;
+ else
+ gBattleTypeFlags |= BATTLE_TYPE_TRAINER;
+ ++var;
+ }
+ if (var == 0)
+ {
+ for (i = 0; i < arg0; ++i)
+ {
+ if (gBlockRecvBuffer[i][0] == 0x201)
+ if (i != arg1 && i < arg1)
+ break;
+ if (gBlockRecvBuffer[i][0] > 0x201 && i != arg1)
+ break;
+ }
+ if (i == arg0)
+ gBattleTypeFlags |= BATTLE_TYPE_IS_MASTER | BATTLE_TYPE_TRAINER;
+ else
+ gBattleTypeFlags |= BATTLE_TYPE_TRAINER;
+ }
+ }
+}
+
+void CB2_HandleStartBattle(void)
+{
+ u8 playerMultiplayerId;
+ u8 enemyMultiplayerId;
+
+ RunTasks();
+ AnimateSprites();
+ BuildOamBuffer();
+ playerMultiplayerId = GetMultiplayerId();
+ gBattleStruct->multiplayerId = playerMultiplayerId;
+ enemyMultiplayerId = playerMultiplayerId ^ BIT_SIDE;
+ switch (gBattleCommunication[MULTIUSE_STATE])
+ {
+ case 0:
+ if (!IsDma3ManagerBusyWithBgCopy())
+ {
+ ShowBg(0);
+ ShowBg(1);
+ ShowBg(2);
+ ShowBg(3);
+ sub_80357C8();
+ gBattleCommunication[MULTIUSE_STATE] = 1;
+ }
+ if (gWirelessCommType)
+ LoadWirelessStatusIndicatorSpriteGfx();
+ break;
+ case 1:
+ if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+ {
+ if (gReceivedRemoteLinkPlayers != 0)
+ {
+ if (IsLinkTaskFinished())
+ {
+ *(&gBattleStruct->field_184) = 1;
+ *(&gBattleStruct->field_185) = 2;
+ sub_800FFEC();
+ SetPlayerBerryDataInBattleStruct();
+ SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_184, 32);
+ gBattleCommunication[MULTIUSE_STATE] = 2;
+ }
+ if (gWirelessCommType != 0)
+ CreateWirelessStatusIndicatorSprite(0, 0);
+ }
+ }
+ else
+ {
+ gBattleTypeFlags |= BATTLE_TYPE_IS_MASTER;
+ gBattleCommunication[MULTIUSE_STATE] = 15;
+ SetAllPlayersBerryData();
+ }
+ break;
+ case 2:
+ if ((GetBlockReceivedStatus() & 3) == 3)
+ {
+ u8 taskId;
+
+ ResetBlockReceivedFlags();
+ sub_8010414(2, playerMultiplayerId);
+ SetAllPlayersBerryData();
+ taskId = CreateTask(sub_800F6FC, 0);
+ gTasks[taskId].data[1] = 270;
+ gTasks[taskId].data[2] = 90;
+ gTasks[taskId].data[5] = 0;
+ gTasks[taskId].data[3] = gBattleStruct->field_186 | (gBattleStruct->field_187 << 8);
+ gTasks[taskId].data[4] = gBlockRecvBuffer[enemyMultiplayerId][1];
+ SetDeoxysStats();
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ break;
+ case 3:
+ if (IsLinkTaskFinished())
+ {
+ 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 (IsLinkTaskFinished())
+ {
+ 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 (IsLinkTaskFinished())
+ {
+ 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);
+ TryCorrectShedinjaLanguage(&gEnemyParty[0]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[1]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[2]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[3]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[4]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[5]);
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ break;
+ case 15:
+ sub_800D30C();
+ ++gBattleCommunication[MULTIUSE_STATE];
+ gBattleCommunication[SPRITES_INIT_STATE1] = 0;
+ gBattleCommunication[SPRITES_INIT_STATE2] = 0;
+ break;
+ case 16:
+ 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;
+ }
+}
+
+void sub_80108C4(void)
+{
+ s32 i, j;
+ u8 *nick, *cur;
+
+ for (i = 0; i < 3; ++i)
+ {
+ gUnknown_2022B58[i].species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES);
+ gUnknown_2022B58[i].heldItem = GetMonData(&gPlayerParty[i], MON_DATA_HELD_ITEM);
+ nick = gUnknown_2022B58[i].nickname;
+ GetMonData(&gPlayerParty[i], MON_DATA_NICKNAME, nick);
+ gUnknown_2022B58[i].level = GetMonData(&gPlayerParty[i], MON_DATA_LEVEL);
+ gUnknown_2022B58[i].hp = GetMonData(&gPlayerParty[i], MON_DATA_HP);
+ gUnknown_2022B58[i].maxhp = GetMonData(&gPlayerParty[i], MON_DATA_MAX_HP);
+ gUnknown_2022B58[i].status = GetMonData(&gPlayerParty[i], MON_DATA_STATUS);
+ gUnknown_2022B58[i].personality = GetMonData(&gPlayerParty[i], MON_DATA_PERSONALITY);
+ gUnknown_2022B58[i].gender = GetMonGender(&gPlayerParty[i]);
+ StripExtCtrlCodes(nick);
+ if (GetMonData(&gPlayerParty[i], MON_DATA_LANGUAGE) != LANGUAGE_JAPANESE)
+ {
+ for (cur = nick, j = 0; cur[j] != EOS; ++j)
+ ;
+ while (j < 6)
+ cur[j++] = 0;
+ cur[j] = EOS;
+ }
+ }
+ memcpy(&gBattleStruct->field_184, gUnknown_2022B58, sizeof(gUnknown_2022B58));
+}
+
+void CB2_PreInitMultiBattle(void)
+{
+ s32 i;
+ u8 playerMultiplierId;
+ u8 r4 = 0xF;
+ u16 *savedBattleTypeFlags; // ???
+ void (**savedCallback)(void);
+
+ playerMultiplierId = GetMultiplayerId();
+ gBattleStruct->multiplayerId = playerMultiplierId;
+ savedCallback = &gBattleStruct->savedCallback;
+ savedBattleTypeFlags = &gBattleStruct->savedBattleTypeFlags;
+
+ RunTasks();
+ AnimateSprites();
+ BuildOamBuffer();
+ switch (gBattleCommunication[MULTIUSE_STATE])
+ {
+ case 0:
+ if (gReceivedRemoteLinkPlayers != 0 && IsLinkTaskFinished())
+ {
+ sub_80108C4();
+ SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_184, sizeof(gUnknown_2022B58));
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ break;
+ case 1:
+ if ((GetBlockReceivedStatus() & r4) == r4)
+ {
+ ResetBlockReceivedFlags();
+ for (i = 0; i < 4; ++i)
+ {
+ if (i == playerMultiplierId)
+ continue;
+ if ((!(gLinkPlayers[i].id & 1) && !(gLinkPlayers[playerMultiplierId].id & 1))
+ || (gLinkPlayers[i].id & 1 && gLinkPlayers[playerMultiplierId].id & 1))
+ memcpy(gUnknown_2022B58, gBlockRecvBuffer[i], sizeof(gUnknown_2022B58));
+ }
+ ++gBattleCommunication[MULTIUSE_STATE];
+ *savedCallback = gMain.savedCallback;
+ *savedBattleTypeFlags = gBattleTypeFlags;
+ gMain.savedCallback = CB2_PreInitMultiBattle;
+ sub_8128198();
+ }
+ break;
+ case 2:
+ if (!gPaletteFade.active)
+ {
+ ++gBattleCommunication[MULTIUSE_STATE];
+ if (gWirelessCommType)
+ sub_800AB9C();
+ else
+ sub_800AAC0();
+ }
+ break;
+ case 3:
+ if (gWirelessCommType)
+ {
+ if (IsLinkRfuTaskFinished())
+ {
+ gBattleTypeFlags = *savedBattleTypeFlags;
+ gMain.savedCallback = *savedCallback;
+ SetMainCallback2(CB2_InitBattleInternal);
+ }
+ }
+ else if (gReceivedRemoteLinkPlayers == 0)
+ {
+ gBattleTypeFlags = *savedBattleTypeFlags;
+ gMain.savedCallback = *savedCallback;
+ SetMainCallback2(CB2_InitBattleInternal);
+ }
+ break;
+ }
+}
+
+void CB2_HandleStartMultiBattle(void)
+{
+ u8 playerMultiplayerId;
+ s32 id;
+ u8 taskId;
+
+ playerMultiplayerId = GetMultiplayerId();
+ gBattleStruct->multiplayerId = playerMultiplayerId;
+ RunTasks();
+ AnimateSprites();
+ BuildOamBuffer();
+ switch (gBattleCommunication[MULTIUSE_STATE])
+ {
+ case 0:
+ if (!IsDma3ManagerBusyWithBgCopy())
+ {
+ ShowBg(0);
+ ShowBg(1);
+ ShowBg(2);
+ ShowBg(3);
+ sub_80357C8();
+ gBattleCommunication[MULTIUSE_STATE] = 1;
+ }
+ if (gWirelessCommType)
+ LoadWirelessStatusIndicatorSpriteGfx();
+ break;
+ case 1:
+ if (gReceivedRemoteLinkPlayers != 0)
+ {
+ if (IsLinkTaskFinished())
+ {
+ *(&gBattleStruct->field_184) = 1;
+ *(&gBattleStruct->field_185) = 2;
+ sub_800FFEC();
+ SetPlayerBerryDataInBattleStruct();
+ SendBlock(bitmask_all_link_players_but_self(), &gBattleStruct->field_184, 32);
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ if (gWirelessCommType)
+ CreateWirelessStatusIndicatorSprite(0, 0);
+ }
+ break;
+ case 2:
+ if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+ {
+ ResetBlockReceivedFlags();
+ sub_8010414(4, playerMultiplayerId);
+ SetAllPlayersBerryData();
+ SetDeoxysStats();
+ memcpy(gDecompressionBuffer, gPlayerParty, sizeof(struct Pokemon) * 3);
+ taskId = CreateTask(sub_800F6FC, 0);
+ gTasks[taskId].data[1] = 270;
+ gTasks[taskId].data[2] = 90;
+ 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].id)
+ {
+ 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;
+ }
+ }
+ ZeroPlayerPartyMons();
+ ZeroEnemyPartyMons();
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ else
+ {
+ break;
+ }
+ // fall through
+ case 3:
+ if (IsLinkTaskFinished())
+ {
+ SendBlock(bitmask_all_link_players_but_self(), gDecompressionBuffer, 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].id)
+ {
+ 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].id & 1) && !(gLinkPlayers[playerMultiplayerId].id & 1))
+ || ((gLinkPlayers[id].id & 1) && (gLinkPlayers[playerMultiplayerId].id & 1)))
+ {
+ switch (gLinkPlayers[id].id)
+ {
+ 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].id)
+ {
+ 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 7:
+ if (IsLinkTaskFinished())
+ {
+ SendBlock(bitmask_all_link_players_but_self(), gDecompressionBuffer + sizeof(struct Pokemon) * 2, sizeof(struct Pokemon));
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ break;
+ case 8:
+ if ((GetBlockReceivedStatus() & 0xF) == 0xF)
+ {
+ ResetBlockReceivedFlags();
+ for (id = 0; id < MAX_LINK_PLAYERS; ++id)
+ {
+ if (id == playerMultiplayerId)
+ {
+ switch (gLinkPlayers[id].id)
+ {
+ 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].id & 1) && !(gLinkPlayers[playerMultiplayerId].id & 1))
+ || ((gLinkPlayers[id].id & 1) && (gLinkPlayers[playerMultiplayerId].id & 1)))
+ {
+ switch (gLinkPlayers[id].id)
+ {
+ 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].id)
+ {
+ 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;
+ }
+ }
+ }
+ }
+ TryCorrectShedinjaLanguage(&gPlayerParty[0]);
+ TryCorrectShedinjaLanguage(&gPlayerParty[1]);
+ TryCorrectShedinjaLanguage(&gPlayerParty[2]);
+ TryCorrectShedinjaLanguage(&gPlayerParty[3]);
+ TryCorrectShedinjaLanguage(&gPlayerParty[4]);
+ TryCorrectShedinjaLanguage(&gPlayerParty[5]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[0]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[1]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[2]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[3]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[4]);
+ TryCorrectShedinjaLanguage(&gEnemyParty[5]);
+ ++gBattleCommunication[MULTIUSE_STATE];
+ }
+ break;
+ case 11:
+ sub_800D30C();
+ ++gBattleCommunication[MULTIUSE_STATE];
+ gBattleCommunication[SPRITES_INIT_STATE1] = 0;
+ gBattleCommunication[SPRITES_INIT_STATE2] = 0;
+ break;
+ case 12:
+ 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:
+ ++gBattleCommunication[0];
+ gBattleCommunication[SPRITES_INIT_STATE1] = 1;
+ // fall through
+ case 6:
+ case 10:
+ if (--gBattleCommunication[SPRITES_INIT_STATE1] == 0)
+ ++gBattleCommunication[0];
+ break;
+ }
+}
+
+void BattleMainCB2(void)
+{
+ AnimateSprites();
+ BuildOamBuffer();
+ RunTextPrinters();
+ UpdatePaletteFade();
+ RunTasks();
+ if (JOY_HELD(B_BUTTON) && gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+ {
+ gSpecialVar_Result = gBattleOutcome = B_OUTCOME_DREW;
+ ResetPaletteFadeControl();
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK);
+ SetMainCallback2(CB2_QuitPokeDudeBattle);
+ }
+}
+
+void FreeRestoreBattleData(void)
+{
+ gMain.callback1 = gPreBattleCallback1;
+ gScanlineEffect.state = 3;
+ gMain.inBattle = FALSE;
+ ZeroEnemyPartyMons();
+ m4aSongNumStop(SE_HINSI);
+ FreeMonSpritesGfx();
+ FreeBattleSpritesData();
+ FreeBattleResources();
+}
+
+void CB2_QuitPokeDudeBattle(void)
+{
+ UpdatePaletteFade();
+ if (!gPaletteFade.active)
+ {
+ FreeRestoreBattleData();
+ FreeAllWindowBuffers();
+ SetMainCallback2(gMain.savedCallback);
+ }
+}
+
+void sub_80111EC(struct Sprite *sprite)
+{
+ sprite->data[0] = 0;
+ sprite->callback = sub_80111FC;
+}
+
+void sub_80111FC(struct Sprite *sprite)
+{
+ switch (sprite->data[0])
+ {
+ case 0:
+ gUnknown_2022BC0 = AllocZeroed(0x1000);
+ ++sprite->data[0];
+ sprite->data[1] = 0;
+ sprite->data[2] = 0x281;
+ sprite->data[3] = 0;
+ sprite->data[4] = 1;
+ // fall through
+ case 1:
+ if (--sprite->data[4] == 0)
+ {
+ s32 i, r2, r0;
+
+ sprite->data[4] = 2;
+ r2 = sprite->data[1] + sprite->data[3] * 32;
+ r0 = sprite->data[2] - sprite->data[3] * 32;
+ for (i = 0; i <= 29; i += 2)
+ {
+ *(&gUnknown_2022BC0[r2] + i) = 0x3D;
+ *(&gUnknown_2022BC0[r0] + i) = 0x3D;
+ }
+ if (++sprite->data[3] == 21)
+ {
+ ++sprite->data[0];
+ sprite->data[1] = 32;
+ }
+ }
+ break;
+ case 2:
+ if (--sprite->data[1] == 20)
+ {
+ if (gUnknown_2022BC0 != NULL)
+ {
+ memset(gUnknown_2022BC0, 0, 0x1000);
+ FREE_AND_SET_NULL(gUnknown_2022BC0);
+ }
+ SetMainCallback2(CB2_InitBattle);
+ }
+ break;
+ }
+}
+
+u8 CreateNPCTrainerParty(struct Pokemon *party, u16 trainerNum)
+{
+ u32 nameHash = 0;
+ u32 personalityValue;
+ u8 fixedIV;
+ s32 i, j;
+
+ if (trainerNum == TRAINER_SECRET_BASE)
+ return 0;
+ if (gBattleTypeFlags & BATTLE_TYPE_TRAINER
+ && !(gBattleTypeFlags & (BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_TRAINER_TOWER)))
+ {
+ ZeroEnemyPartyMons();
+ for (i = 0; i < gTrainers[trainerNum].partySize; ++i)
+ {
+
+ if (gTrainers[trainerNum].doubleBattle == TRUE)
+ personalityValue = 0x80;
+ else if (gTrainers[trainerNum].encounterMusic_gender & 0x80)
+ personalityValue = 0x78;
+ else
+ personalityValue = 0x88;
+ for (j = 0; gTrainers[trainerNum].trainerName[j] != EOS; ++j)
+ nameHash += gTrainers[trainerNum].trainerName[j];
+ switch (gTrainers[trainerNum].partyFlags)
+ {
+ case 0:
+ {
+ const struct TrainerMonNoItemDefaultMoves *partyData = gTrainers[trainerNum].party.NoItemDefaultMoves;
+
+ for (j = 0; gSpeciesNames[partyData[i].species][j] != EOS; ++j)
+ nameHash += gSpeciesNames[partyData[i].species][j];
+ personalityValue += nameHash << 8;
+ fixedIV = partyData[i].iv * 31 / 255;
+ CreateMon(&party[i], partyData[i].species, partyData[i].lvl, fixedIV, TRUE, personalityValue, OT_ID_RANDOM_NO_SHINY, 0);
+ break;
+ }
+ case F_TRAINER_PARTY_CUSTOM_MOVESET:
+ {
+ const struct TrainerMonNoItemCustomMoves *partyData = gTrainers[trainerNum].party.NoItemCustomMoves;
+
+ for (j = 0; gSpeciesNames[partyData[i].species][j] != EOS; ++j)
+ nameHash += gSpeciesNames[partyData[i].species][j];
+ personalityValue += nameHash << 8;
+ fixedIV = partyData[i].iv * 31 / 255;
+ CreateMon(&party[i], partyData[i].species, partyData[i].lvl, fixedIV, TRUE, personalityValue, OT_ID_RANDOM_NO_SHINY, 0);
+ for (j = 0; j < MAX_MON_MOVES; ++j)
+ {
+ SetMonData(&party[i], MON_DATA_MOVE1 + j, &partyData[i].moves[j]);
+ SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
+ }
+ break;
+ }
+ case F_TRAINER_PARTY_HELD_ITEM:
+ {
+ const struct TrainerMonItemDefaultMoves *partyData = gTrainers[trainerNum].party.ItemDefaultMoves;
+
+ for (j = 0; gSpeciesNames[partyData[i].species][j] != EOS; ++j)
+ nameHash += gSpeciesNames[partyData[i].species][j];
+ personalityValue += nameHash << 8;
+ fixedIV = partyData[i].iv * 31 / 255;
+ CreateMon(&party[i], partyData[i].species, partyData[i].lvl, fixedIV, TRUE, personalityValue, OT_ID_RANDOM_NO_SHINY, 0);
+
+ SetMonData(&party[i], MON_DATA_HELD_ITEM, &partyData[i].heldItem);
+ break;
+ }
+ case F_TRAINER_PARTY_CUSTOM_MOVESET | F_TRAINER_PARTY_HELD_ITEM:
+ {
+ const struct TrainerMonItemCustomMoves *partyData = gTrainers[trainerNum].party.ItemCustomMoves;
+
+ for (j = 0; gSpeciesNames[partyData[i].species][j] != EOS; ++j)
+ nameHash += gSpeciesNames[partyData[i].species][j];
+ personalityValue += nameHash << 8;
+ fixedIV = partyData[i].iv * 31 / 255;
+ CreateMon(&party[i], partyData[i].species, partyData[i].lvl, fixedIV, TRUE, personalityValue, OT_ID_RANDOM_NO_SHINY, 0);
+ SetMonData(&party[i], MON_DATA_HELD_ITEM, &partyData[i].heldItem);
+ for (j = 0; j < MAX_MON_MOVES; ++j)
+ {
+ SetMonData(&party[i], MON_DATA_MOVE1 + j, &partyData[i].moves[j]);
+ SetMonData(&party[i], MON_DATA_PP1 + j, &gBattleMoves[partyData[i].moves[j]].pp);
+ }
+ break;
+ }
+ }
+ }
+ gBattleTypeFlags |= gTrainers[trainerNum].doubleBattle;
+ }
+ return gTrainers[trainerNum].partySize;
+}
+
+// not used
+void sub_80116CC(void)
+{
+ if (REG_VCOUNT < 0xA0 && REG_VCOUNT >= 0x6F)
+ REG_BG0CNT = BGCNT_PRIORITY(0) | BGCNT_CHARBASE(0) | BGCNT_SCREENBASE(24) | BGCNT_16COLOR | BGCNT_TXT256x512;
+}
+
+void VBlankCB_Battle(void)
+{
+ // Change gRngSeed every vblank.
+ Random();
+ SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_X);
+ SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_Y);
+ SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
+ SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
+ SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
+ SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
+ SetGpuReg(REG_OFFSET_BG3HOFS, gBattle_BG3_X);
+ SetGpuReg(REG_OFFSET_BG3VOFS, gBattle_BG3_Y);
+ SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H);
+ SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V);
+ SetGpuReg(REG_OFFSET_WIN1H, gBattle_WIN1H);
+ SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN1V);
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ TransferPlttBuffer();
+ ScanlineEffect_InitHBlankDmaTransfer();
+}
+
+void nullsub_9(struct Sprite *sprite)
+{
+}
+
+void sub_80117BC(struct Sprite *sprite)
+{
+ if (sprite->data[0] != 0)
+ sprite->pos1.x = sprite->data[1] + ((sprite->data[2] & 0xFF00) >> 8);
+ else
+ sprite->pos1.x = sprite->data[1] - ((sprite->data[2] & 0xFF00) >> 8);
+ sprite->data[2] += 0x180;
+ if (sprite->affineAnimEnded)
+ {
+ FreeSpriteTilesByTag(ANIM_SPRITES_START);
+ FreeSpritePaletteByTag(ANIM_SPRITES_START);
+ FreeSpriteOamMatrix(sprite);
+ DestroySprite(sprite);
+ }
+}
+
+void sub_801182C(struct Sprite *sprite)
+{
+ StartSpriteAffineAnim(sprite, 1);
+ sprite->callback = sub_80117BC;
+ PlaySE(SE_BT_START);
+}
+
+void sub_801184C(u8 taskId)
+{
+ struct Pokemon *party1 = NULL;
+ struct Pokemon *party2 = NULL;
+ u8 multiplayerId = gBattleStruct->multiplayerId;
+ u32 r7;
+ s32 i;
+
+ if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
+ {
+ switch (gLinkPlayers[multiplayerId].id)
+ {
+ case 0:
+ case 2:
+ party1 = gPlayerParty;
+ party2 = gEnemyParty;
+ break;
+ case 1:
+ case 3:
+ party1 = gEnemyParty;
+ party2 = gPlayerParty;
+ break;
+ }
+ }
+ else
+ {
+ party1 = gPlayerParty;
+ party2 = gEnemyParty;
+ }
+ r7 = 0;
+ for (i = 0; i < PARTY_SIZE; ++i)
+ {
+ u16 species = GetMonData(&party1[i], MON_DATA_SPECIES2);
+ u16 hp = GetMonData(&party1[i], MON_DATA_HP);
+ u32 status = GetMonData(&party1[i], MON_DATA_STATUS);
+
+ if (species == SPECIES_NONE)
+ continue;
+ if (species != SPECIES_EGG && hp != 0 && status == 0)
+ r7 |= 1 << i * 2;
+
+ if (species == SPECIES_NONE)
+ continue;
+ if (hp != 0 && (species == SPECIES_EGG || status != 0))
+ r7 |= 2 << i * 2;
+
+ if (species == SPECIES_NONE)
+ continue;
+ if (species != SPECIES_EGG && hp == 0)
+ r7 |= 3 << i * 2;
+ }
+ gTasks[taskId].data[3] = r7;
+ r7 = 0;
+ for (i = 0; i < PARTY_SIZE; ++i)
+ {
+ u16 species = GetMonData(&party2[i], MON_DATA_SPECIES2);
+ u16 hp = GetMonData(&party2[i], MON_DATA_HP);
+ u32 status = GetMonData(&party2[i], MON_DATA_STATUS);
+
+ if (species == SPECIES_NONE)
+ continue;
+ if (species != SPECIES_EGG && hp != 0 && status == 0)
+ r7 |= 1 << i * 2;
+ if (species == SPECIES_NONE)
+ continue;
+ if (hp != 0 && (species == SPECIES_EGG || status != 0))
+ r7 |= 2 << i * 2;
+ if (species == SPECIES_NONE)
+ continue;
+ if (species != SPECIES_EGG && hp == 0)
+ r7 |= 3 << i * 2;
+ }
+ gTasks[taskId].data[4] = r7;
+}
+
+void sub_8011A1C(void)
+{
+ s32 i;
+ u8 taskId;
+
+ SetHBlankCallback(NULL);
+ SetVBlankCallback(NULL);
+ CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+ SetGpuReg(REG_OFFSET_MOSAIC, 0);
+ SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 0xF0));
+ SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(0x50, 0x51));
+ SetGpuReg(REG_OFFSET_WININ, 0);
+ SetGpuReg(REG_OFFSET_WINOUT, 0);
+ gBattle_WIN0H = WIN_RANGE(0, 0xF0);
+ gBattle_WIN0V = WIN_RANGE(0x50, 0x51);
+ ScanlineEffect_Clear();
+
+ for (i = 0; i < 80; ++i)
+ {
+ gScanlineEffectRegBuffers[0][i] = 0xF0;
+ gScanlineEffectRegBuffers[1][i] = 0xF0;
+ }
+
+ for (; i < 160; ++i)
+ {
+ gScanlineEffectRegBuffers[0][i] = 0xFF10;
+ gScanlineEffectRegBuffers[1][i] = 0xFF10;
+ }
+ 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;
+ sub_800F34C();
+ LoadCompressedPalette(gBattleTextboxPalette, 0, 64);
+ LoadBattleMenuWindowGfx();
+ ResetSpriteData();
+ ResetTasks();
+ DrawBattleEntryBackground();
+ SetGpuReg(REG_OFFSET_WINOUT, WININ_WIN0_BG0 | WININ_WIN0_BG1 | WININ_WIN0_BG2 | WININ_WIN0_OBJ | WININ_WIN0_CLR);
+ FreeAllSpritePalettes();
+ gReservedSpritePaletteCount = 4;
+ SetVBlankCallback(VBlankCB_Battle);
+ taskId = CreateTask(sub_800F6FC, 0);
+ gTasks[taskId].data[1] = 270;
+ gTasks[taskId].data[2] = 90;
+ gTasks[taskId].data[5] = 1;
+ sub_801184C(taskId);
+ SetMainCallback2(sub_8011B94);
+ gBattleCommunication[MULTIUSE_STATE] = 0;
+}
+
+void sub_8011B94(void)
+{
+ sub_8011BB0();
+ AnimateSprites();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+ RunTasks();
+}
diff --git a/src/berry.c b/src/berry.c
index 91d83f40c..d349109d2 100644
--- a/src/berry.c
+++ b/src/berry.c
@@ -134,7 +134,7 @@ bool32 IsEnigmaBerryValid(void)
return TRUE;
}
-const struct Berry * sub_809C8A0(u8 berryIdx)
+const struct Berry * GetBerryInfo(u8 berryIdx)
{
if (berryIdx == ITEM_TO_BERRY(ITEM_ENIGMA_BERRY) && IsEnigmaBerryValid())
return (struct Berry *)&gSaveBlock1Ptr->enigmaBerry.berry;
@@ -163,7 +163,7 @@ u16 BerryTypeToItemId(u16 berryType)
void GetBerryNameByBerryType(u8 berryType, u8 * dest)
{
- const struct Berry * berry = sub_809C8A0(berryType);
+ const struct Berry * berry = GetBerryInfo(berryType);
memcpy(dest, berry->name, 6);
dest[6] = EOS;
}
diff --git a/src/item.c b/src/item.c
index 42dfd334e..750c4481d 100644
--- a/src/item.c
+++ b/src/item.c
@@ -73,7 +73,7 @@ void CopyItemName(u16 itemId, u8 * dest)
{
if (itemId == ITEM_ENIGMA_BERRY)
{
- StringCopy(dest, sub_809C8A0(43)->name);
+ StringCopy(dest, GetBerryInfo(43)->name);
StringAppend(dest, gUnknown_84162BD);
}
else
diff --git a/src/link.c b/src/link.c
index 52f5aeddb..bb0401907 100644
--- a/src/link.c
+++ b/src/link.c
@@ -1025,7 +1025,7 @@ bool8 IsLinkTaskFinished(void)
{
if (gWirelessCommType == 1)
{
- return IsRfuTaskFinished();
+ return IsLinkRfuTaskFinished();
}
return gLinkCallback == NULL;
}
diff --git a/src/mystery_gift_menu.c b/src/mystery_gift_menu.c
index 395c4e374..0af851edb 100644
--- a/src/mystery_gift_menu.c
+++ b/src/mystery_gift_menu.c
@@ -1374,7 +1374,7 @@ void task00_mystery_gift(u8 taskId)
}
break;
case 13:
- if (IsRfuTaskFinished())
+ if (IsLinkRfuTaskFinished())
{
DestroyWirelessStatusIndicatorSprite();
data->state = 14;
@@ -1650,7 +1650,7 @@ void task00_mystery_gift(u8 taskId)
data->state = 34;
break;
case 34:
- if (IsRfuTaskFinished())
+ if (IsLinkRfuTaskFinished())
{
DestroyWirelessStatusIndicatorSprite();
data->state = 35;
diff --git a/src/quest_log_battle.c b/src/quest_log_battle.c
index 2687e4ea5..c7c7d1f53 100644
--- a/src/quest_log_battle.c
+++ b/src/quest_log_battle.c
@@ -141,7 +141,7 @@ void sub_812C224(void)
}
for (r3 = 0; r3 < 7; r3++)
{
- r5->v1[0][r3] = gLinkPlayers[gBattleStruct->field_B5 ^ 1].name[r3];
+ r5->v1[0][r3] = gLinkPlayers[gBattleStruct->multiplayerId ^ 1].name[r3];
}
}
sub_8113550(r8, (const u16 *)r5);
@@ -153,12 +153,12 @@ void sub_812C334(s32 * a0, s32 * a1)
{
s32 r5;
s32 _optimized_out = 0;
- u8 r2 = gLinkPlayers[gBattleStruct->field_B5].id ^ 2;
+ u8 r2 = gLinkPlayers[gBattleStruct->multiplayerId].id ^ 2;
for (r5 = 0; r5 < 4; r5++)
{
if (r2 == gLinkPlayers[r5].id)
a0[0] = r5;
- else if (r5 != gBattleStruct->field_B5)
+ else if (r5 != gBattleStruct->multiplayerId)
a1[_optimized_out++] = r5;
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-19 05:09:37 +0000