From 3d1c16523e277b0b4044e685aa118c15aaaeffe9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 21 Oct 2017 17:32:35 +0200 Subject: start working on battle controllers, especially player --- src/battle_2.c | 10 +- src/battle_controller_linkopponent.c | 143 +++ src/battle_controller_opponent.c | 146 ++++ src/battle_controller_player.c | 1600 ++++++++++++++++++++++++++++++++++ src/battle_controller_wally.c | 147 ++++ src/battle_interface.c | 6 - src/battle_script_commands.c | 44 +- src/pokemon_2.c | 2 +- 8 files changed, 2064 insertions(+), 34 deletions(-) create mode 100644 src/battle_controller_linkopponent.c create mode 100644 src/battle_controller_opponent.c create mode 100644 src/battle_controller_player.c create mode 100644 src/battle_controller_wally.c (limited to 'src') diff --git a/src/battle_2.c b/src/battle_2.c index 16c07114a..c50295eba 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -2257,7 +2257,7 @@ static void sub_803939C(void) sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); sub_814F9EC(gText_BattleYesNoChoice, 0xC); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); gBattleCommunication[MULTIUSE_STATE]++; } break; @@ -2267,9 +2267,9 @@ static void sub_803939C(void) if (gBattleCommunication[CURSOR_POSITION] != 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); } } else if (gMain.newKeys & DPAD_DOWN) @@ -2277,9 +2277,9 @@ static void sub_803939C(void) if (gBattleCommunication[CURSOR_POSITION] == 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); } } else if (gMain.newKeys & A_BUTTON) diff --git a/src/battle_controller_linkopponent.c b/src/battle_controller_linkopponent.c new file mode 100644 index 000000000..fdb9ee10d --- /dev/null +++ b/src/battle_controller_linkopponent.c @@ -0,0 +1,143 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "link.h" + +extern u8 gActiveBank; +extern bool8 gDoingBattleAnim; +extern u8 gUnknown_020244CC; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); + +// this file's functions +void LinkOpponentHandleGetMonData(void); +void LinkOpponentHandleGetRawMonData(void); +void LinkOpponentHandleSetMonData(void); +void LinkOpponentHandleSetRawMonData(void); +void LinkOpponentHandleLoadMonSprite(void); +void LinkOpponentHandleSwitchInAnim(void); +void LinkOpponentHandleReturnMonToBall(void); +void LinkOpponentHandleDrawTrainerPic(void); +void LinkOpponentHandleTrainerSlide(void); +void LinkOpponentHandleTrainerSlideBack(void); +void LinkOpponentHandleFaintAnimation(void); +void LinkOpponentHandleCmd11(void); +void LinkOpponentHandleCmd12(void); +void LinkOpponentHandleBallThrow(void); +void LinkOpponentHandlePause(void); +void LinkOpponentHandleMoveAnimation(void); +void LinkOpponentHandlePrintString(void); +void LinkOpponentHandlePrintStringPlayerOnly(void); +void LinkOpponentHandleChooseAction(void); +void LinkOpponentHandleCmd19(void); +void LinkOpponentHandleChooseMove(void); +void LinkOpponentHandleOpenBag(void); +void LinkOpponentHandleChoosePokemon(void); +void LinkOpponentHandleCmd23(void); +void LinkOpponentHandleHealthBarUpdate(void); +void LinkOpponentHandleExpUpdate(void); +void LinkOpponentHandleStatusIconUpdate(void); +void LinkOpponentHandleStatusAnimation(void); +void LinkOpponentHandleStatusXor(void); +void LinkOpponentHandleDataTransfer(void); +void LinkOpponentHandleDMA3Transfer(void); +void LinkOpponentHandlePlayBGM(void); +void LinkOpponentHandleCmd32(void); +void LinkOpponentHandleCmd33(void); +void LinkOpponentHandleCmd34(void); +void LinkOpponentHandleCmd35(void); +void LinkOpponentHandleCmd36(void); +void LinkOpponentHandleCmd37(void); +void LinkOpponentHandleCmd38(void); +void LinkOpponentHandleCmd39(void); +void LinkOpponentHandleCmd40(void); +void LinkOpponentHandleHitAnimation(void); +void LinkOpponentHandleCmd42(void); +void LinkOpponentHandleEffectivenessSound(void); +void LinkOpponentHandlePlayFanfareOrBGM(void); +void LinkOpponentHandleFaintingCry(void); +void LinkOpponentHandleIntroSlide(void); +void LinkOpponentHandleIntroTrainerBallThrow(void); +void LinkOpponentHandleDrawPartyStatusSummary(void); +void LinkOpponentHandleCmd49(void); +void LinkOpponentHandleCmd50(void); +void LinkOpponentHandleSpriteInvisibility(void); +void LinkOpponentHandleBattleAnimation(void); +void LinkOpponentHandleLinkStandbyMsg(void); +void LinkOpponentHandleResetActionMoveSelection(void); +void LinkOpponentHandleCmd55(void); +void nullsub_92(void); + +void LinkOpponentBufferRunCommand(void); + +void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) = +{ + LinkOpponentHandleGetMonData, + LinkOpponentHandleGetRawMonData, + LinkOpponentHandleSetMonData, + LinkOpponentHandleSetRawMonData, + LinkOpponentHandleLoadMonSprite, + LinkOpponentHandleSwitchInAnim, + LinkOpponentHandleReturnMonToBall, + LinkOpponentHandleDrawTrainerPic, + LinkOpponentHandleTrainerSlide, + LinkOpponentHandleTrainerSlideBack, + LinkOpponentHandleFaintAnimation, + LinkOpponentHandleCmd11, + LinkOpponentHandleCmd12, + LinkOpponentHandleBallThrow, + LinkOpponentHandlePause, + LinkOpponentHandleMoveAnimation, + LinkOpponentHandlePrintString, + LinkOpponentHandlePrintStringPlayerOnly, + LinkOpponentHandleChooseAction, + LinkOpponentHandleCmd19, + LinkOpponentHandleChooseMove, + LinkOpponentHandleOpenBag, + LinkOpponentHandleChoosePokemon, + LinkOpponentHandleCmd23, + LinkOpponentHandleHealthBarUpdate, + LinkOpponentHandleExpUpdate, + LinkOpponentHandleStatusIconUpdate, + LinkOpponentHandleStatusAnimation, + LinkOpponentHandleStatusXor, + LinkOpponentHandleDataTransfer, + LinkOpponentHandleDMA3Transfer, + LinkOpponentHandlePlayBGM, + LinkOpponentHandleCmd32, + LinkOpponentHandleCmd33, + LinkOpponentHandleCmd34, + LinkOpponentHandleCmd35, + LinkOpponentHandleCmd36, + LinkOpponentHandleCmd37, + LinkOpponentHandleCmd38, + LinkOpponentHandleCmd39, + LinkOpponentHandleCmd40, + LinkOpponentHandleHitAnimation, + LinkOpponentHandleCmd42, + LinkOpponentHandleEffectivenessSound, + LinkOpponentHandlePlayFanfareOrBGM, + LinkOpponentHandleFaintingCry, + LinkOpponentHandleIntroSlide, + LinkOpponentHandleIntroTrainerBallThrow, + LinkOpponentHandleDrawPartyStatusSummary, + LinkOpponentHandleCmd49, + LinkOpponentHandleCmd50, + LinkOpponentHandleSpriteInvisibility, + LinkOpponentHandleBattleAnimation, + LinkOpponentHandleLinkStandbyMsg, + LinkOpponentHandleResetActionMoveSelection, + LinkOpponentHandleCmd55, + nullsub_92 +}; + +void nullsub_28(void) +{ +} + +void SetBankFuncToLinkOpponentBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand; +} diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c new file mode 100644 index 000000000..9c72b19dc --- /dev/null +++ b/src/battle_controller_opponent.c @@ -0,0 +1,146 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "link.h" + +extern u8 gActiveBank; +extern bool8 gDoingBattleAnim; +extern u8 gUnknown_020244CC; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); + +// this file's functions +void OpponentHandleGetMonData(void); +void OpponentHandleGetRawMonData(void); +void OpponentHandleSetMonData(void); +void OpponentHandleSetRawMonData(void); +void OpponentHandleLoadMonSprite(void); +void OpponentHandleSwitchInAnim(void); +void OpponentHandleReturnMonToBall(void); +void OpponentHandleDrawTrainerPic(void); +void OpponentHandleTrainerSlide(void); +void OpponentHandleTrainerSlideBack(void); +void OpponentHandleFaintAnimation(void); +void OpponentHandleCmd11(void); +void OpponentHandleCmd12(void); +void OpponentHandleBallThrow(void); +void OpponentHandlePause(void); +void OpponentHandleMoveAnimation(void); +void OpponentHandlePrintString(void); +void OpponentHandlePrintStringPlayerOnly(void); +void OpponentHandleChooseAction(void); +void OpponentHandleCmd19(void); +void OpponentHandleChooseMove(void); +void OpponentHandleOpenBag(void); +void OpponentHandleChoosePokemon(void); +void OpponentHandleCmd23(void); +void OpponentHandleHealthBarUpdate(void); +void OpponentHandleExpUpdate(void); +void OpponentHandleStatusIconUpdate(void); +void OpponentHandleStatusAnimation(void); +void OpponentHandleStatusXor(void); +void OpponentHandleDataTransfer(void); +void OpponentHandleDMA3Transfer(void); +void OpponentHandlePlayBGM(void); +void OpponentHandleCmd32(void); +void OpponentHandleCmd33(void); +void OpponentHandleCmd34(void); +void OpponentHandleCmd35(void); +void OpponentHandleCmd36(void); +void OpponentHandleCmd37(void); +void OpponentHandleCmd38(void); +void OpponentHandleCmd39(void); +void OpponentHandleCmd40(void); +void OpponentHandleHitAnimation(void); +void OpponentHandleCmd42(void); +void OpponentHandleEffectivenessSound(void); +void OpponentHandlePlayFanfareOrBGM(void); +void OpponentHandleFaintingCry(void); +void OpponentHandleIntroSlide(void); +void OpponentHandleIntroTrainerBallThrow(void); +void OpponentHandleDrawPartyStatusSummary(void); +void OpponentHandleCmd49(void); +void OpponentHandleCmd50(void); +void OpponentHandleSpriteInvisibility(void); +void OpponentHandleBattleAnimation(void); +void OpponentHandleLinkStandbyMsg(void); +void OpponentHandleResetActionMoveSelection(void); +void OpponentHandleCmd55(void); +void nullsub_91(void); + +void OpponentBufferRunCommand(void); + +void (*const gOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) = +{ + OpponentHandleGetMonData, + OpponentHandleGetRawMonData, + OpponentHandleSetMonData, + OpponentHandleSetRawMonData, + OpponentHandleLoadMonSprite, + OpponentHandleSwitchInAnim, + OpponentHandleReturnMonToBall, + OpponentHandleDrawTrainerPic, + OpponentHandleTrainerSlide, + OpponentHandleTrainerSlideBack, + OpponentHandleFaintAnimation, + OpponentHandleCmd11, + OpponentHandleCmd12, + OpponentHandleBallThrow, + OpponentHandlePause, + OpponentHandleMoveAnimation, + OpponentHandlePrintString, + OpponentHandlePrintStringPlayerOnly, + OpponentHandleChooseAction, + OpponentHandleCmd19, + OpponentHandleChooseMove, + OpponentHandleOpenBag, + OpponentHandleChoosePokemon, + OpponentHandleCmd23, + OpponentHandleHealthBarUpdate, + OpponentHandleExpUpdate, + OpponentHandleStatusIconUpdate, + OpponentHandleStatusAnimation, + OpponentHandleStatusXor, + OpponentHandleDataTransfer, + OpponentHandleDMA3Transfer, + OpponentHandlePlayBGM, + OpponentHandleCmd32, + OpponentHandleCmd33, + OpponentHandleCmd34, + OpponentHandleCmd35, + OpponentHandleCmd36, + OpponentHandleCmd37, + OpponentHandleCmd38, + OpponentHandleCmd39, + OpponentHandleCmd40, + OpponentHandleHitAnimation, + OpponentHandleCmd42, + OpponentHandleEffectivenessSound, + OpponentHandlePlayFanfareOrBGM, + OpponentHandleFaintingCry, + OpponentHandleIntroSlide, + OpponentHandleIntroTrainerBallThrow, + OpponentHandleDrawPartyStatusSummary, + OpponentHandleCmd49, + OpponentHandleCmd50, + OpponentHandleSpriteInvisibility, + OpponentHandleBattleAnimation, + OpponentHandleLinkStandbyMsg, + OpponentHandleResetActionMoveSelection, + OpponentHandleCmd55, + nullsub_91 +}; + +// unknown unused data +static const u8 gUnknown_0831C7AC[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; + +void nullsub_26(void) +{ +} + +void SetBankFuncToOpponentBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; +} diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c new file mode 100644 index 000000000..33807b39a --- /dev/null +++ b/src/battle_controller_player.c @@ -0,0 +1,1600 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "item.h" +#include "items.h" +#include "songs.h" +#include "sound.h" +#include "moves.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gAbsentBankFlags; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern u8 gUnknown_020244CC; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern u8 gMultiUsePlayerCursor; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct MusicPlayerInfo gMPlay_BGM; + +extern const struct BattleMove gBattleMoves[]; + +extern void dp11b_obj_instanciate(u8, u8, s8, s8); +extern void dp11b_obj_free(u8, u8); +extern void sub_800AC34(void); + +// this file's functions +void PlayerHandleGetMonData(void); +void PlayerHandleGetRawMonData(void); +void PlayerHandleSetMonData(void); +void PlayerHandleSetRawMonData(void); +void PlayerHandleLoadMonSprite(void); +void PlayerHandleSwitchInAnim(void); +void PlayerHandleReturnMonToBall(void); +void PlayerHandleDrawTrainerPic(void); +void PlayerHandleTrainerSlide(void); +void PlayerHandleTrainerSlideBack(void); +void PlayerHandleFaintAnimation(void); +void PlayerHandleCmd11(void); +void PlayerHandleCmd12(void); +void PlayerHandleBallThrow(void); +void PlayerHandlePause(void); +void PlayerHandleMoveAnimation(void); +void PlayerHandlePrintString(void); +void PlayerHandlePrintStringPlayerOnly(void); +void PlayerHandleChooseAction(void); +void PlayerHandleCmd19(void); +void PlayerHandleChooseMove(void); +void PlayerHandleOpenBag(void); +void PlayerHandleChoosePokemon(void); +void PlayerHandleCmd23(void); +void PlayerHandleHealthBarUpdate(void); +void PlayerHandleExpUpdate(void); +void PlayerHandleStatusIconUpdate(void); +void PlayerHandleStatusAnimation(void); +void PlayerHandleStatusXor(void); +void PlayerHandleDataTransfer(void); +void PlayerHandleDMA3Transfer(void); +void PlayerHandlePlayBGM(void); +void PlayerHandleCmd32(void); +void PlayerHandleCmd33(void); +void PlayerHandleCmd34(void); +void PlayerHandleCmd35(void); +void PlayerHandleCmd36(void); +void PlayerHandleCmd37(void); +void PlayerHandleCmd38(void); +void PlayerHandleCmd39(void); +void PlayerHandleCmd40(void); +void PlayerHandleHitAnimation(void); +void PlayerHandleCmd42(void); +void PlayerHandleEffectivenessSound(void); +void PlayerHandlePlayFanfareOrBGM(void); +void PlayerHandleFaintingCry(void); +void PlayerHandleIntroSlide(void); +void PlayerHandleIntroTrainerBallThrow(void); +void PlayerHandleDrawPartyStatusSummary(void); +void PlayerHandleCmd49(void); +void PlayerHandleCmd50(void); +void PlayerHandleSpriteInvisibility(void); +void PlayerHandleBattleAnimation(void); +void PlayerHandleLinkStandbyMsg(void); +void PlayerHandleResetActionMoveSelection(void); +void PlayerHandleCmd55(void); +void nullsub_22(void); + +void PlayerBufferRunCommand(void); +void HandleInputChooseTarget(void); +void HandleInputChooseMove(void); +void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1); +void MoveSelectionDestroyCursorAt(u8 cursorPos); +void MoveSelectionDisplayPpNumber(void); +void MoveSelectionDisplayPpString(void); +void MoveSelectionDisplayMoveType(void); +void MoveSelectionDisplayMoveNames(void); +void HandleMoveSwitchting(void); +void sub_8058FC0(void); +void sub_8059828(void); +void sub_80598E0(void); +void sub_8059544(u8 taskId); +void sub_8059330(u8 taskId); +void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); +void sub_8059400(u8 taskId); +void sub_80595A4(u8 taskId); +void PrintLinkStandbyMsg(void); + +void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + PlayerHandleGetMonData, + PlayerHandleGetRawMonData, + PlayerHandleSetMonData, + PlayerHandleSetRawMonData, + PlayerHandleLoadMonSprite, + PlayerHandleSwitchInAnim, + PlayerHandleReturnMonToBall, + PlayerHandleDrawTrainerPic, + PlayerHandleTrainerSlide, + PlayerHandleTrainerSlideBack, + PlayerHandleFaintAnimation, + PlayerHandleCmd11, + PlayerHandleCmd12, + PlayerHandleBallThrow, + PlayerHandlePause, + PlayerHandleMoveAnimation, + PlayerHandlePrintString, + PlayerHandlePrintStringPlayerOnly, + PlayerHandleChooseAction, + PlayerHandleCmd19, + PlayerHandleChooseMove, + PlayerHandleOpenBag, + PlayerHandleChoosePokemon, + PlayerHandleCmd23, + PlayerHandleHealthBarUpdate, + PlayerHandleExpUpdate, + PlayerHandleStatusIconUpdate, + PlayerHandleStatusAnimation, + PlayerHandleStatusXor, + PlayerHandleDataTransfer, + PlayerHandleDMA3Transfer, + PlayerHandlePlayBGM, + PlayerHandleCmd32, + PlayerHandleCmd33, + PlayerHandleCmd34, + PlayerHandleCmd35, + PlayerHandleCmd36, + PlayerHandleCmd37, + PlayerHandleCmd38, + PlayerHandleCmd39, + PlayerHandleCmd40, + PlayerHandleHitAnimation, + PlayerHandleCmd42, + PlayerHandleEffectivenessSound, + PlayerHandlePlayFanfareOrBGM, + PlayerHandleFaintingCry, + PlayerHandleIntroSlide, + PlayerHandleIntroTrainerBallThrow, + PlayerHandleDrawPartyStatusSummary, + PlayerHandleCmd49, + PlayerHandleCmd50, + PlayerHandleSpriteInvisibility, + PlayerHandleBattleAnimation, + PlayerHandleLinkStandbyMsg, + PlayerHandleResetActionMoveSelection, + PlayerHandleCmd55, + nullsub_22 +}; + +static const u8 sTargetIdentities[] = {IDENTITY_PLAYER_MON1, IDENTITY_PLAYER_MON2, IDENTITY_OPPONENT_MON2, IDENTITY_OPPONENT_MON1}; + +// unknown unused data +static const u8 gUnknown_0831C5FC[] = {0x48, 0x48, 0x20, 0x5a, 0x50, 0x50, 0x50, 0x58}; + +void nullsub_21(void) +{ +} + +void SetBankFuncToPlayerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + gDoingBattleAnim = FALSE; + gUnknown_020244CC = 0; +} + +void PlayerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void PlayerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gPlayerBufferCommands)) + gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + PlayerBufferExecCompleted(); + } +} + +void CompleteOnBankSpritePosX_0(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + PlayerBufferExecCompleted(); +} + +void HandleInputChooseAction(void) +{ + u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + + if (gMain.newAndRepeatedKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) + gUnknown_020244CC++; + else + gUnknown_020244CC = 0; + + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + + switch (gActionSelectionCursor[gActiveBank]) + { + case ACTION_USE_MOVE: + EmitCmd33(1, ACTION_USE_MOVE, 0); + break; + case ACTION_USE_ITEM: + EmitCmd33(1, ACTION_USE_ITEM, 0); + break; + case ACTION_SWITCH: + EmitCmd33(1, ACTION_SWITCH, 0); + break; + case ACTION_RUN: + EmitCmd33(1, ACTION_RUN, 0); + break; + } + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gActionSelectionCursor[gActiveBank] & 1) // if is ACTION_USE_ITEM or ACTION_RUN + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gActionSelectionCursor[gActiveBank] & 1)) // if is ACTION_USE_MOVE or ACTION_SWITCH + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gActionSelectionCursor[gActiveBank] & 2) // if is ACTION_SWITCH or ACTION_RUN + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gActionSelectionCursor[gActiveBank] & 2)) // if is ACTION_USE_MOVE or ACTION_USE_ITEM + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + { + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON2 + && !(gAbsentBankFlags & gBitTable[GetBankByIdentity(IDENTITY_PLAYER_MON1)]) + && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if (gBattleBufferA[gActiveBank][1] == ACTION_USE_ITEM) + { + // Add item to bag if it is a ball + if (itemId <= ITEM_PREMIER_BALL) + AddBagItem(itemId, 1); + else + return; + } + PlaySE(SE_SELECT); + EmitCmd33(1, ACTION_CANCEL_PARTNER, 0); + PlayerBufferExecCompleted(); + } + } + else if (gMain.newKeys & START_BUTTON) + { + SwapHpBarsWithHpText(); + } +} + +void sub_80577F0(void) // unused +{ + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + gBattleBankFunc[gActiveBank] = HandleInputChooseTarget; +} + +void HandleInputChooseTarget(void) +{ + s32 i; + u8 identities[4]; + memcpy(identities, sTargetIdentities, ARRAY_COUNT(sTargetIdentities)); + + dp11b_obj_instanciate(gMultiUsePlayerCursor, 1, 0xF, 1); + + // what a weird loop + i = 0; + if (gNoOfAllBanks != 0) + { + do + { + if (i != gMultiUsePlayerCursor) + dp11b_obj_free(i, 1); + i++; + } while (i < gNoOfAllBanks); + } + + if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) + gUnknown_020244CC++; + else + gUnknown_020244CC = 0; + + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; + EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + dp11b_obj_free(gMultiUsePlayerCursor, 1); + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + { + PlaySE(SE_SELECT); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; + gBattleBankFunc[gActiveBank] = HandleInputChooseMove; + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + dp11b_obj_free(gMultiUsePlayerCursor, 1); + } + else if (gMain.newKeys & (DPAD_LEFT | DPAD_UP)) + { + PlaySE(SE_SELECT); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; + + do + { + u8 currSelIdentity = GetBankIdentity(gMultiUsePlayerCursor); + + for (i = 0; i < BATTLE_BANKS_COUNT; i++) + { + if (currSelIdentity == identities[i]) + break; + } + do + { + if (--i < 0) + i = 4; // UB: array out of range + gMultiUsePlayerCursor = GetBankByIdentity(identities[i]); + } while (gMultiUsePlayerCursor == gNoOfAllBanks); + + i = 0; + switch (GetBankIdentity(gMultiUsePlayerCursor)) + { + case IDENTITY_PLAYER_MON1: + case IDENTITY_PLAYER_MON2: + if (gActiveBank != gMultiUsePlayerCursor) + i++; + else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank])].target & MOVE_TARGET_USER) + i++; + break; + case IDENTITY_OPPONENT_MON1: + case IDENTITY_OPPONENT_MON2: + i++; + break; + } + + if (gAbsentBankFlags & gBitTable[gMultiUsePlayerCursor]) + i = 0; + } while (i == 0); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8; + } + else if (gMain.newKeys & (DPAD_RIGHT | DPAD_DOWN)) + { + PlaySE(SE_SELECT); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; + + do + { + u8 currSelIdentity = GetBankIdentity(gMultiUsePlayerCursor); + + for (i = 0; i < BATTLE_BANKS_COUNT; i++) + { + if (currSelIdentity == identities[i]) + break; + } + do + { + if (++i > 3) + i = 0; + gMultiUsePlayerCursor = GetBankByIdentity(identities[i]); + } while (gMultiUsePlayerCursor == gNoOfAllBanks); + + i = 0; + switch (GetBankIdentity(gMultiUsePlayerCursor)) + { + case IDENTITY_PLAYER_MON1: + case IDENTITY_PLAYER_MON2: + if (gActiveBank != gMultiUsePlayerCursor) + i++; + else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank])].target & MOVE_TARGET_USER) + i++; + break; + case IDENTITY_OPPONENT_MON1: + case IDENTITY_OPPONENT_MON2: + i++; + break; + } + + if (gAbsentBankFlags & gBitTable[gMultiUsePlayerCursor]) + i = 0; + } while (i == 0); + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8; + } +} + +extern u8 gNumberOfMovesToChoose; +extern const u8 gText_BattleSwitchWhich[]; + +void HandleInputChooseMove(void) +{ + bool32 canSelectTarget = FALSE; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + + if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) + gUnknown_020244CC++; + else + gUnknown_020244CC = 0; + + if (gMain.newKeys & A_BUTTON) + { + u8 moveTarget; + + PlaySE(SE_SELECT); + if (moveInfo->moves[gMoveSelectionCursor[gActiveBank]] == MOVE_CURSE) + { + if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST) + moveTarget = MOVE_TARGET_x10; + else + moveTarget = MOVE_TARGET_SELECTED; + } + else + { + moveTarget = gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBank]]].target; + } + + if (moveTarget & MOVE_TARGET_x10) + gMultiUsePlayerCursor = gActiveBank; + else + gMultiUsePlayerCursor = GetBankByIdentity((GetBankIdentity(gActiveBank) & BIT_SIDE) ^ BIT_SIDE); + + if (!gBattleBufferA[gActiveBank][1]) // not a double battle + { + if (moveTarget & MOVE_TARGET_USER && !gBattleBufferA[gActiveBank][2]) + canSelectTarget++; + } + else // double battle + { + if (!(moveTarget & (MOVE_TARGET_RANDOM | MOVE_TARGET_BOTH | MOVE_TARGET_DEPENDS | MOVE_TARGET_FOES_AND_ALLY | MOVE_TARGET_OPPONENTS_FIELD | MOVE_TARGET_x10))) + canSelectTarget++; // either selected or user + + if (moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]] == 0) + { + canSelectTarget = FALSE; + } + else if (!(moveTarget & (MOVE_TARGET_x10 | MOVE_TARGET_USER)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) <= 1) + { + gMultiUsePlayerCursor = GetDefaultMoveTarget(gActiveBank); + canSelectTarget = FALSE; + } + } + + if (!canSelectTarget) + { + EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + PlayerBufferExecCompleted(); + } + else + { + gBattleBankFunc[gActiveBank] = HandleInputChooseTarget; + + if (moveTarget & (MOVE_TARGET_x10 | MOVE_TARGET_USER)) + gMultiUsePlayerCursor = gActiveBank; + else if (gAbsentBankFlags & gBitTable[GetBankByIdentity(IDENTITY_OPPONENT_MON1)]) + gMultiUsePlayerCursor = GetBankByIdentity(IDENTITY_OPPONENT_MON2); + else + gMultiUsePlayerCursor = GetBankByIdentity(IDENTITY_OPPONENT_MON1); + + gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8; + } + } + else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + { + PlaySE(SE_SELECT); + EmitCmd33(1, 10, 0xFFFF); + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gMoveSelectionCursor[gActiveBank] & 1) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gMoveSelectionCursor[gActiveBank] & 1) + && (gMoveSelectionCursor[gActiveBank] ^ 1) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gMoveSelectionCursor[gActiveBank] & 2) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gMoveSelectionCursor[gActiveBank] & 2) + && (gMoveSelectionCursor[gActiveBank] ^ 2) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + } + else if (gMain.newKeys & SELECT_BUTTON) + { + if (gNumberOfMovesToChoose > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) + { + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29); + + if (gMoveSelectionCursor[gActiveBank] != 0) + gMultiUsePlayerCursor = 0; + else + gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBank] + 1; + + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + sub_814F9EC(gText_BattleSwitchWhich, 0xB); + gBattleBankFunc[gActiveBank] = HandleMoveSwitchting; + } + } +} + +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; + +u32 sub_8057FBC(void) // unused +{ + u32 var = 0; + + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + var = 1; + } + if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0x140; + var = 0xFF; + } + if (gMain.newKeys & DPAD_LEFT && gMoveSelectionCursor[gActiveBank] & 1) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + } + if (gMain.newKeys & DPAD_RIGHT && !(gMoveSelectionCursor[gActiveBank] & 1) + && (gMoveSelectionCursor[gActiveBank] ^ 1) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + } + if (gMain.newKeys & DPAD_UP && gMoveSelectionCursor[gActiveBank] & 2) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + } + if (gMain.newKeys & DPAD_DOWN && !(gMoveSelectionCursor[gActiveBank] & 2) + && (gMoveSelectionCursor[gActiveBank] ^ 2) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + } + + return var; +} + +void HandleMoveSwitchting(void) +{ + u8 perMovePPBonuses[4]; + struct ChooseMoveStruct moveStruct; + u8 totalPPBonuses; + + if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + + if (gMoveSelectionCursor[gActiveBank] != gMultiUsePlayerCursor) + { + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + s32 i; + + // swap moves and pp + i = moveInfo->moves[gMoveSelectionCursor[gActiveBank]]; + moveInfo->moves[gMoveSelectionCursor[gActiveBank]] = moveInfo->moves[gMultiUsePlayerCursor]; + moveInfo->moves[gMultiUsePlayerCursor] = i; + + i = moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]]; + moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]] = moveInfo->currentPp[gMultiUsePlayerCursor]; + moveInfo->currentPp[gMultiUsePlayerCursor] = i; + + i = moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]]; + moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]] = moveInfo->maxPp[gMultiUsePlayerCursor]; + moveInfo->maxPp[gMultiUsePlayerCursor] = i; + + if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) + { + gDisableStructs[gActiveBank].unk18_b &= (~gBitTable[gMoveSelectionCursor[gActiveBank]]); + gDisableStructs[gActiveBank].unk18_b |= gBitTable[gMultiUsePlayerCursor]; + } + + MoveSelectionDisplayMoveNames(); + + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); + + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gMultiUsePlayerCursor]; + perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; + + for (i = 0; i < 4; i++) + { + gBattleMons[gActiveBank].moves[i] = moveInfo->moves[i]; + gBattleMons[gActiveBank].pp[i] = moveInfo->currentPp[i]; + } + + if (!(gBattleMons[gActiveBank].status2 & STATUS2_TRANSFORMED)) + { + for (i = 0; i < 4; i++) + { + moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); + moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); + } + + totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); + + i = moveStruct.moves[gMoveSelectionCursor[gActiveBank]]; + moveStruct.moves[gMoveSelectionCursor[gActiveBank]] = moveStruct.moves[gMultiUsePlayerCursor]; + moveStruct.moves[gMultiUsePlayerCursor] = i; + + i = moveStruct.currentPp[gMoveSelectionCursor[gActiveBank]]; + moveStruct.currentPp[gMoveSelectionCursor[gActiveBank]] = moveStruct.currentPp[gMultiUsePlayerCursor]; + moveStruct.currentPp[gMultiUsePlayerCursor] = i; + + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gMultiUsePlayerCursor]; + perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]); + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]); + } + + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); + } + } + + gBattleBankFunc[gActiveBank] = HandleInputChooseMove; + gMoveSelectionCursor[gActiveBank] = gMultiUsePlayerCursor; + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + else if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + gBattleBankFunc[gActiveBank] = HandleInputChooseMove; + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gMultiUsePlayerCursor & 1) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + + gMultiUsePlayerCursor ^= 1; + PlaySE(SE_SELECT); + + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gMultiUsePlayerCursor & 1) && (gMultiUsePlayerCursor ^ 1) < gNumberOfMovesToChoose) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + + gMultiUsePlayerCursor ^= 1; + PlaySE(SE_SELECT); + + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gMultiUsePlayerCursor & 2) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + + gMultiUsePlayerCursor ^= 2; + PlaySE(SE_SELECT); + + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gMultiUsePlayerCursor & 2) && (gMultiUsePlayerCursor ^ 2) < gNumberOfMovesToChoose) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + + gMultiUsePlayerCursor ^= 2; + PlaySE(SE_SELECT); + + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } +} + +extern u8 gBattleOutcome; +extern void sub_817E3F4(void); // battle_link_817C95C + +void sub_80586F8(void) +{ + if (gLinkVSyncDisabled == 0) + { + if (gReceivedRemoteLinkPlayers == 0) + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(sub_8038D64); + if (gBattleOutcome == BATTLE_WON) + sub_817E3F4(); + FreeAllWindowBuffers(); + } + } + else + { + if (sub_800A520()) + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(sub_8038D64); + if (gBattleOutcome == BATTLE_WON) + sub_817E3F4(); + FreeAllWindowBuffers(); + } + } +} + +void sub_80587B0(void) +{ + if (!gPaletteFade.active) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (sub_800A520()) + { + if (gLinkVSyncDisabled == 0) + sub_800AC34(); + else + sub_800ADF8(); + + gBattleBankFunc[gActiveBank] = sub_80586F8; + } + } + else + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + } +} + +void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +void CompleteOnBankSpriteCallbackDummy2(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +void sub_80588B4(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_25(gSaveBlock2Ptr->playerGender); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + PlayerBufferExecCompleted(); + } +} + +void sub_8058924(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + PlayerBufferExecCompleted(); + } +} + +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; + +extern bool8 IsDoubleBattle(void); + +void sub_805896C(void) +{ + bool8 var = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + var = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + var = TRUE; + } + + if (var && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + + if (IsDoubleBattle()) + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], gActiveBank ^ BIT_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_8058924; + } +} + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_8076918(u8 bank); +extern u8 gUnknown_03005D7C[]; + +void sub_8058B40(void) +{ + bool32 r9 = FALSE; + bool32 r8 = FALSE; + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + sub_8172EF0(gActiveBank ^ BIT_MON, &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1; + } + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40 + && !IsCryPlayingOrClearCrySongs()) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) + m4aMPlayContinue(&gMPlay_BGM); + else + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1; + r9 = TRUE; + } + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + r8 = TRUE; + } + } + else + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r8 = TRUE; + } + } + + if (r9 && r8) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0; + + gBattleBankFunc[gActiveBank] = sub_805896C; + } +} + +extern void sub_805E408(u8 bank); +extern void move_anim_start_t4(u8 arg0, u8 atkBank, u8 defBank, u8 tableId); + +void sub_8058EDC(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + sub_805E408(gActiveBank); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + + gBattleBankFunc[gActiveBank] = sub_8058FC0; + } +} + +void sub_8058FC0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40 + && !IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void sub_805902C(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + gBattleBankFunc[gActiveBank] = sub_8058EDC; + } +} + +void c3_0802FDF4(u8 taskId) +{ + if (!IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + DestroyTask(taskId); + } +} + +void bx_t1_healthbar_update(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + PlayerBufferExecCompleted(); +} + +void sub_80591B8(u8 taskId) +{ + u32 monId = (u8)(gTasks[taskId].data[0]); + u8 bank = gTasks[taskId].data[2]; + s16 gainedExp = gTasks[taskId].data[1]; + + if (IsDoubleBattle() == TRUE || monId != gBattlePartyID[bank]) + { + struct Pokemon *mon = &gPlayerParty[monId]; + u16 species = GetMonData(mon, MON_DATA_SPECIES); + u8 level = GetMonData(mon, MON_DATA_LEVEL); + u32 currExp = GetMonData(mon, MON_DATA_EXP); + u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= nextLvlExp) + { + u8 savedActiveBank; + + SetMonData(mon, MON_DATA_EXP, &nextLvlExp); + CalculateMonStats(mon); + gainedExp -= nextLvlExp - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + EmitCmd33(1, 11, gainedExp); + gActiveBank = savedActiveBank; + + if (IsDoubleBattle() == TRUE + && ((u16)(monId) == gBattlePartyID[bank] || (u16)(monId) == gBattlePartyID[bank ^ BIT_MON])) + gTasks[taskId].func = sub_8059544; + else + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } + else + { + currExp += gainedExp; + SetMonData(mon, MON_DATA_EXP, &currExp); + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } + } + else + { + gTasks[taskId].func = sub_8059330; + } +} + +void sub_8059330(u8 taskId) +{ + u8 monIndex = gTasks[taskId].data[0]; + s32 gainedExp = gTasks[taskId].data[1]; + u8 bank = gTasks[taskId].data[2]; + struct Pokemon *mon = &gPlayerParty[monIndex]; + u8 level = GetMonData(mon, MON_DATA_LEVEL); + u16 species = GetMonData(mon, MON_DATA_SPECIES); + u32 exp = GetMonData(mon, MON_DATA_EXP); + u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level]; + u32 expToNextLvl; + + exp -= currLvlExp; + expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp; + SetBattleBarStruct(bank, gHealthBoxesIds[bank], expToNextLvl, exp, -gainedExp); + PlaySE(SE_EXP); + gTasks[taskId].func = sub_8059400; +} + +void sub_8059400(u8 taskId) +{ + if (gTasks[taskId].data[10] < 13) + { + gTasks[taskId].data[10]++; + } + else + { + u8 monId = gTasks[taskId].data[0]; + s16 gainedExp = gTasks[taskId].data[1]; + u8 bank = gTasks[taskId].data[2]; + s16 r4; + + r4 = sub_8074AA0(bank, gHealthBoxesIds[bank], 1, 0); + SetHealthboxSpriteVisible(gHealthBoxesIds[bank]); + if (r4 == -1) + { + u8 level; + s32 currExp; + u16 species; + s32 expOnNextLvl; + + m4aSongNumStop(SE_EXP); + level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + currExp = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + expOnNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= expOnNextLvl) + { + u8 savedActiveBank; + + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &expOnNextLvl); + CalculateMonStats(&gPlayerParty[monId]); + gainedExp -= expOnNextLvl - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + EmitCmd33(1, 11, gainedExp); + gActiveBank = savedActiveBank; + gTasks[taskId].func = sub_8059544; + } + else + { + currExp += gainedExp; + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp); + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } + } + } +} + +void sub_8059544(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + u8 monIndex = gTasks[taskId].data[0]; + + if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON]) + bank ^= BIT_MON; + + move_anim_start_t4(bank, bank, bank, 0); + gTasks[taskId].func = sub_80595A4; +} + +void sub_80595A4(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + + if (!gBattleSpritesDataPtr->healthBoxesData[bank].flag_x40) + { + u8 monIndex = gTasks[taskId].data[0]; + + GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value + + if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON]) + UpdateHealthboxAttribute(gHealthBoxesIds[bank ^ BIT_MON], &gPlayerParty[monIndex], HEALTHBOX_ALL); + else + UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[monIndex], HEALTHBOX_ALL); + + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } +} + +void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId) +{ + u8 monIndex; + u8 bank; + + monIndex = gTasks[taskId].data[0]; + GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value + bank = gTasks[taskId].data[2]; + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); +} + +void sub_80596A8(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_24(species); + FreeOamMatrix(gSprites[gBankSpriteIds[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void sub_8059744(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void CompleteOnInactiveTextPrinter2(void) +{ + if (!IsTextPrinterActive(0)) + PlayerBufferExecCompleted(); +} + +extern void sub_81B89AC(u8 arg0); + +void sub_80597CC(void) +{ + if (!gPaletteFade.active) + { + u8 r4; + + gBattleBankFunc[gActiveBank] = sub_8059828; + r4 = gTasks[gUnknown_03005D7C[gActiveBank]].data[0]; + DestroyTask(gUnknown_03005D7C[gActiveBank]); + FreeAllWindowBuffers(); + sub_81B89AC(r4); + } +} + +extern u8 gUnknown_0203CEE8; +extern u8 gUnknown_0203CEE9; +extern u8 gUnknown_0203CF00[]; + +void sub_8059828(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + if (gUnknown_0203CEE8 == 1) + EmitCmd34(1, gUnknown_0203CEE9, gUnknown_0203CF00); + else + EmitCmd34(1, 6, NULL); + + if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1) + PrintLinkStandbyMsg(); + + PlayerBufferExecCompleted(); + } +} + +extern void sub_81AABB0(void); +extern void nullsub_35(void); + +void sub_80598A4(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = sub_80598E0; + nullsub_35(); + FreeAllWindowBuffers(); + sub_81AABB0(); + } +} + +extern u16 gScriptItemId; + +void sub_80598E0(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + EmitCmd35(1, gScriptItemId); + PlayerBufferExecCompleted(); + } +} + +void sub_805991C(void) +{ + if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + PlayerBufferExecCompleted(); +} + +void DoHitAnimBlinkEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + PlayerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_80599D4(void) +{ + if (gMain.newKeys & DPAD_UP && gMultiUsePlayerCursor != 0) + { + PlaySE(SE_SELECT); + BattleDestroyYesNoCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor = 0; + BattleCreateYesNoCursorAt(0); + } + if (gMain.newKeys & DPAD_DOWN && gMultiUsePlayerCursor == 0) + { + PlaySE(SE_SELECT); + BattleDestroyYesNoCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor = 1; + BattleCreateYesNoCursorAt(1); + } + if (gMain.newKeys & A_BUTTON) + { + sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + PlaySE(SE_SELECT); + + if (gMultiUsePlayerCursor != 0) + EmitCmd33(1, 0xE, 0); + else + EmitCmd33(1, 0xD, 0); + + PlayerBufferExecCompleted(); + } + if (gMain.newKeys & B_BUTTON) + { + sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + PlaySE(SE_SELECT); + PlayerBufferExecCompleted(); + } +} + +extern const u8 gText_MoveInterfacePP[]; +extern const u8 gText_MoveInterfaceType[]; + +void MoveSelectionDisplayMoveNames(void) +{ + s32 i; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + gNumberOfMovesToChoose = 0; + + for (i = 0; i < 4; i++) + { + MoveSelectionDestroyCursorAt(i); + StringCopy(gDisplayedStringBattle, gMoveNames[moveInfo->moves[i]]); + sub_814F9EC(gDisplayedStringBattle, i + 3); + if (moveInfo->moves[i] != MOVE_NONE) + gNumberOfMovesToChoose++; + } +} + +void MoveSelectionDisplayPpString(void) +{ + StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); + sub_814F9EC(gDisplayedStringBattle, 7); +} + +void MoveSelectionDisplayPpNumber(void) +{ + u8 *txtPtr; + struct ChooseMoveStruct *moveInfo; + + if (gBattleBufferA[gActiveBank][2] == TRUE) // check if we didn't want to display pp number + return; + + SetPpNumbersPaletteInMoveSelection(); + moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]], STR_CONV_MODE_RIGHT_ALIGN, 2); + txtPtr[0] = CHAR_SLASH; + txtPtr++; + ConvertIntToDecimalStringN(txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]], STR_CONV_MODE_RIGHT_ALIGN, 2); + + sub_814F9EC(gDisplayedStringBattle, 9); +} + +extern const u8 gTypeNames[][7]; + +void MoveSelectionDisplayMoveType(void) +{ + u8 *txtPtr; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + + txtPtr = StringCopy(gDisplayedStringBattle, gText_MoveInterfaceType); + txtPtr[0] = EXT_CTRL_CODE_BEGIN; + txtPtr++; + txtPtr[0] = 6; + txtPtr++; + txtPtr[0] = 1; + txtPtr++; + + StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBank]]].type]); + sub_814F9EC(gDisplayedStringBattle, 10); +} + +void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) +{ + u16 src[2]; + src[0] = arg1 + 1; + src[1] = arg1 + 2; + + CopyToBgTilemapBufferRect_ChangePalette(0, src, 9 * (cursorPosition & 1) + 1, 55 + (cursorPosition & 2), 1, 2, 0x11); + CopyBgTilemapBufferToVram(0); +} + +void MoveSelectionDestroyCursorAt(u8 cursorPosition) +{ + u16 src[2]; + src[0] = 0x1016; + src[1] = 0x1016; + + CopyToBgTilemapBufferRect_ChangePalette(0, src, 9 * (cursorPosition & 1) + 1, 55 + (cursorPosition & 2), 1, 2, 0x11); + CopyBgTilemapBufferToVram(0); +} + +void ActionSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) +{ + u16 src[2]; + src[0] = 1; + src[1] = 2; + + CopyToBgTilemapBufferRect_ChangePalette(0, src, 7 * (cursorPosition & 1) + 16, 35 + (cursorPosition & 2), 1, 2, 0x11); + CopyBgTilemapBufferToVram(0); +} + +void ActionSelectionDestroyCursorAt(u8 cursorPosition) +{ + u16 src[2]; + src[0] = 0x1016; + src[1] = 0x1016; + + CopyToBgTilemapBufferRect_ChangePalette(0, src, 7 * (cursorPosition & 1) + 16, 35 + (cursorPosition & 2), 1, 2, 0x11); + CopyBgTilemapBufferToVram(0); +} + +void SetCB2ToReshowScreenAfterMenu(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void SetCB2ToReshowScreenAfterMenu2(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void sub_8059D60(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x10) + PlayerBufferExecCompleted(); +} + +void sub_8059D90(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x20) + PlayerBufferExecCompleted(); +} + +extern const u8 gText_LinkStandby[]; + +void PrintLinkStandbyMsg(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + sub_814F9EC(gText_LinkStandby, 0); + } +} diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c new file mode 100644 index 000000000..e7594a2f0 --- /dev/null +++ b/src/battle_controller_wally.c @@ -0,0 +1,147 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "link.h" + +extern u8 gActiveBank; +extern bool8 gDoingBattleAnim; +extern u8 gUnknown_020244CC; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); + +// this file's functions +void WallyHandleGetMonData(void); +void WallyHandleGetRawMonData(void); +void WallyHandleSetMonData(void); +void WallyHandleSetRawMonData(void); +void WallyHandleLoadMonSprite(void); +void WallyHandleSwitchInAnim(void); +void WallyHandleReturnMonToBall(void); +void WallyHandleDrawTrainerPic(void); +void WallyHandleTrainerSlide(void); +void WallyHandleTrainerSlideBack(void); +void WallyHandleFaintAnimation(void); +void WallyHandleCmd11(void); +void WallyHandleCmd12(void); +void WallyHandleBallThrow(void); +void WallyHandlePause(void); +void WallyHandleMoveAnimation(void); +void WallyHandlePrintString(void); +void WallyHandlePrintStringPlayerOnly(void); +void WallyHandleChooseAction(void); +void WallyHandleCmd19(void); +void WallyHandleChooseMove(void); +void WallyHandleOpenBag(void); +void WallyHandleChoosePokemon(void); +void WallyHandleCmd23(void); +void WallyHandleHealthBarUpdate(void); +void WallyHandleExpUpdate(void); +void WallyHandleStatusIconUpdate(void); +void WallyHandleStatusAnimation(void); +void WallyHandleStatusXor(void); +void WallyHandleDataTransfer(void); +void WallyHandleDMA3Transfer(void); +void WallyHandlePlayBGM(void); +void WallyHandleCmd32(void); +void WallyHandleCmd33(void); +void WallyHandleCmd34(void); +void WallyHandleCmd35(void); +void WallyHandleCmd36(void); +void WallyHandleCmd37(void); +void WallyHandleCmd38(void); +void WallyHandleCmd39(void); +void WallyHandleCmd40(void); +void WallyHandleHitAnimation(void); +void WallyHandleCmd42(void); +void WallyHandleEffectivenessSound(void); +void WallyHandlePlayFanfareOrBGM(void); +void WallyHandleFaintingCry(void); +void WallyHandleIntroSlide(void); +void WallyHandleIntroTrainerBallThrow(void); +void WallyHandleDrawPartyStatusSummary(void); +void WallyHandleCmd49(void); +void WallyHandleCmd50(void); +void WallyHandleSpriteInvisibility(void); +void WallyHandleBattleAnimation(void); +void WallyHandleLinkStandbyMsg(void); +void WallyHandleResetActionMoveSelection(void); +void WallyHandleCmd55(void); +void nullsub_118(void); + +void WallyBufferRunCommand(void); + +void (*const gWallyBufferCommands[CONTOLLER_CMDS_CONT])(void) = +{ + WallyHandleGetMonData, + WallyHandleGetRawMonData, + WallyHandleSetMonData, + WallyHandleSetRawMonData, + WallyHandleLoadMonSprite, + WallyHandleSwitchInAnim, + WallyHandleReturnMonToBall, + WallyHandleDrawTrainerPic, + WallyHandleTrainerSlide, + WallyHandleTrainerSlideBack, + WallyHandleFaintAnimation, + WallyHandleCmd11, + WallyHandleCmd12, + WallyHandleBallThrow, + WallyHandlePause, + WallyHandleMoveAnimation, + WallyHandlePrintString, + WallyHandlePrintStringPlayerOnly, + WallyHandleChooseAction, + WallyHandleCmd19, + WallyHandleChooseMove, + WallyHandleOpenBag, + WallyHandleChoosePokemon, + WallyHandleCmd23, + WallyHandleHealthBarUpdate, + WallyHandleExpUpdate, + WallyHandleStatusIconUpdate, + WallyHandleStatusAnimation, + WallyHandleStatusXor, + WallyHandleDataTransfer, + WallyHandleDMA3Transfer, + WallyHandlePlayBGM, + WallyHandleCmd32, + WallyHandleCmd33, + WallyHandleCmd34, + WallyHandleCmd35, + WallyHandleCmd36, + WallyHandleCmd37, + WallyHandleCmd38, + WallyHandleCmd39, + WallyHandleCmd40, + WallyHandleHitAnimation, + WallyHandleCmd42, + WallyHandleEffectivenessSound, + WallyHandlePlayFanfareOrBGM, + WallyHandleFaintingCry, + WallyHandleIntroSlide, + WallyHandleIntroTrainerBallThrow, + WallyHandleDrawPartyStatusSummary, + WallyHandleCmd49, + WallyHandleCmd50, + WallyHandleSpriteInvisibility, + WallyHandleBattleAnimation, + WallyHandleLinkStandbyMsg, + WallyHandleResetActionMoveSelection, + WallyHandleCmd55, + nullsub_118 +}; + +void nullsub_117(void) +{ +} + +void SetBankFuncToWallyBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; + gBattleStruct->field_94 = 0; + gBattleStruct->field_95 = 0; + gBattleStruct->field_96 = 0; + gBattleStruct->field_97 = 0; +} diff --git a/src/battle_interface.c b/src/battle_interface.c index 9241db1d9..2318517f5 100644 --- a/src/battle_interface.c +++ b/src/battle_interface.c @@ -27,12 +27,6 @@ enum EXP_BAR }; -enum -{ - HP_CURRENT, - HP_MAX -}; - struct TestingBar { s32 maxValue; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index a1e5767ad..4ba86775e 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -6118,22 +6118,22 @@ static void atk5A_yesnoboxlearnmove(void) sub_814F9EC(gText_BattleYesNoChoice, 0xC); gBattleScripting.learnMoveState++; gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); break; case 1: if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); } if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); } if (gMain.newKeys & A_BUTTON) { @@ -6235,22 +6235,22 @@ static void atk5B_yesnoboxstoplearningmove(void) sub_814F9EC(gText_BattleYesNoChoice, 0xC); gBattleScripting.learnMoveState++; gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); break; case 1: if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); } if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); } if (gMain.newKeys & A_BUTTON) { @@ -6531,22 +6531,22 @@ static void atk67_yesnobox(void) sub_814F9EC(gText_BattleYesNoChoice, 0xC); gBattleCommunication[0]++; gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); break; case 1: if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); } if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); } if (gMain.newKeys & B_BUTTON) { @@ -11286,7 +11286,7 @@ void sub_8056A3C(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags) } } -void BattleCreateCursorAt(u8 cursorPosition) +void BattleCreateYesNoCursorAt(u8 cursorPosition) { u16 src[2]; src[0] = 1; @@ -11296,7 +11296,7 @@ void BattleCreateCursorAt(u8 cursorPosition) CopyBgTilemapBufferToVram(0); } -void BattleDestroyCursorAt(u8 cursorPosition) +void BattleDestroyYesNoCursorAt(u8 cursorPosition) { u16 src[2]; src[0] = 0x1016; @@ -11315,22 +11315,22 @@ static void atkF3_nickname_caught_poke(void) sub_814F9EC(gText_BattleYesNoChoice, 0xC); gBattleCommunication[MULTIUSE_STATE]++; gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); break; case 1: if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 0; - BattleCreateCursorAt(0); + BattleCreateYesNoCursorAt(0); } if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0) { PlaySE(SE_SELECT); - BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]); + BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]); gBattleCommunication[CURSOR_POSITION] = 1; - BattleCreateCursorAt(1); + BattleCreateYesNoCursorAt(1); } if (gMain.newKeys & A_BUTTON) { diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 27441f952..972e1943a 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -84,7 +84,7 @@ bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 bank) return FALSE; } -u8 sub_8069F34(u8 bank) +u8 GetDefaultMoveTarget(u8 bank) { u8 status = GetBankIdentity(bank) & 1; -- cgit v1.2.3 From 813b1bfd4a8f0fc316e78b39abaaafd09a42f0c4 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 22 Oct 2017 01:04:02 +0200 Subject: label and do more work at player controller --- src/battle_2.c | 24 +- src/battle_ai_switch_items.c | 18 +- src/battle_controller_linkopponent.c | 2 +- src/battle_controller_opponent.c | 2 +- src/battle_controller_player.c | 1110 +++++++++++++++++++++++++++++++++- src/battle_controller_wally.c | 2 +- src/battle_controllers.c | 36 +- src/battle_message.c | 2 +- src/battle_script_commands.c | 48 +- src/pokemon_2.c | 5 +- src/pokemon_3.c | 2 +- src/reshow_battle_screen.c | 4 +- 12 files changed, 1159 insertions(+), 96 deletions(-) (limited to 'src') diff --git a/src/battle_2.c b/src/battle_2.c index c50295eba..f2a5508e0 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -2121,7 +2121,7 @@ static void sub_8038F34(void) if (sub_800A520() == TRUE) { sub_800ADF8(); - sub_814F9EC(gText_LinkStandby3, 0); + BattleHandleAddTextPrinter(gText_LinkStandby3, 0); gBattleCommunication[MULTIUSE_STATE]++; } break; @@ -2247,15 +2247,15 @@ static void sub_803939C(void) case 3: if (!gPaletteFade.active) { - sub_814F9EC(gText_RecordBattleToPass, 0); + BattleHandleAddTextPrinter(gText_RecordBattleToPass, 0); gBattleCommunication[MULTIUSE_STATE]++; } break; case 4: if (!IsTextPrinterActive(0)) { - sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); - sub_814F9EC(gText_BattleYesNoChoice, 0xC); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 0xC); gBattleCommunication[CURSOR_POSITION] = 1; BattleCreateYesNoCursorAt(1); gBattleCommunication[MULTIUSE_STATE]++; @@ -2287,7 +2287,7 @@ static void sub_803939C(void) PlaySE(SE_SELECT); if (gBattleCommunication[CURSOR_POSITION] == 0) { - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); gBattleCommunication[1] = MoveRecordedBattleToSaveData(); gBattleCommunication[MULTIUSE_STATE] = 10; } @@ -2305,11 +2305,11 @@ static void sub_803939C(void) case 6: if (sub_800A520() == TRUE) { - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); if (gMain.field_439_x4) { sub_800ADF8(); - sub_814F9EC(gText_LinkStandby3, 0); + BattleHandleAddTextPrinter(gText_LinkStandby3, 0); } gBattleCommunication[MULTIUSE_STATE]++; } @@ -2340,14 +2340,14 @@ static void sub_803939C(void) { PlaySE(SE_SAVE); BattleStringExpandPlaceholdersToDisplayedString(gText_BattleRecordedOnPass); - sub_814F9EC(gDisplayedStringBattle, 0); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); gBattleCommunication[1] = 0x80; gBattleCommunication[MULTIUSE_STATE]++; } else { BattleStringExpandPlaceholdersToDisplayedString(gText_BattleRecordCouldntBeSaved); - sub_814F9EC(gDisplayedStringBattle, 0); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); gBattleCommunication[1] = 0x80; gBattleCommunication[MULTIUSE_STATE]++; } @@ -2358,7 +2358,7 @@ static void sub_803939C(void) if (gMain.field_439_x4) { sub_800ADF8(); - sub_814F9EC(gText_LinkStandby3, 0); + BattleHandleAddTextPrinter(gText_LinkStandby3, 0); } gBattleCommunication[MULTIUSE_STATE]++; } @@ -3690,7 +3690,7 @@ static void TryDoEventsBeforeFirstTurn(void) TurnValuesCleanUp(FALSE); SpecialStatusesClear(); *(&gBattleStruct->field_91) = gAbsentBankFlags; - sub_814F9EC(gText_EmptyString3, 0); + BattleHandleAddTextPrinter(gText_EmptyString3, 0); gBattleMainFunc = HandleTurnActionSelectionState; ResetSentPokesToOpponentValue(); @@ -3797,7 +3797,7 @@ void BattleTurnPassed(void) *(gBattleStruct->field_5C + i) = 6; *(&gBattleStruct->field_91) = gAbsentBankFlags; - sub_814F9EC(gText_EmptyString3, 0); + BattleHandleAddTextPrinter(gText_EmptyString3, 0); gBattleMainFunc = HandleTurnActionSelectionState; gRandomTurnNumber = Random(); diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index d86be6fad..3f97c59a5 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -39,7 +39,7 @@ static bool8 ShouldSwitchIfPerishSong(void) && gDisableStructs[gActiveBank].perishSong1 == 0) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } @@ -121,7 +121,7 @@ static bool8 ShouldSwitchIfWonderGuard(void) { // we found a mon *(gBattleStruct->field_294 + gActiveBank) = i; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } } @@ -221,7 +221,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) { // we found a mon *(gBattleStruct->field_294 + gActiveBank) = i; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } } @@ -241,13 +241,13 @@ static bool8 ShouldSwitchIfNaturalCure(void) if ((gUnknown_02024250[gActiveBank] == 0 || gUnknown_02024250[gActiveBank] == 0xFFFF) && Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } else if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0 && Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } @@ -258,7 +258,7 @@ static bool8 ShouldSwitchIfNaturalCure(void) if (Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } @@ -426,7 +426,7 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent) if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % moduloPercent == 0) { *(gBattleStruct->field_294 + gActiveBank) = i; - EmitCmd33(1, 2, 0); + EmitChoiceReturnValue(1, 2, 0); return TRUE; } } @@ -611,7 +611,7 @@ void AI_TrySwitchOrUseItem(void) } } - EmitCmd33(1, 0, (gActiveBank ^ BIT_SIDE) << 8); + EmitChoiceReturnValue(1, 0, (gActiveBank ^ BIT_SIDE) << 8); } #define TYPE_FORESIGHT 0xFE @@ -940,7 +940,7 @@ static bool8 ShouldUseItem(void) if (shouldUse) { - EmitCmd33(1, 1, 0); + EmitChoiceReturnValue(1, 1, 0); *(gBattleStruct->field_C0 + (gActiveBank / 2) * 2) = item; gBattleResources->battleHistory->trainerItems[i] = 0; return shouldUse; diff --git a/src/battle_controller_linkopponent.c b/src/battle_controller_linkopponent.c index fdb9ee10d..fb21865ca 100644 --- a/src/battle_controller_linkopponent.c +++ b/src/battle_controller_linkopponent.c @@ -72,7 +72,7 @@ void nullsub_92(void); void LinkOpponentBufferRunCommand(void); -void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) = +void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { LinkOpponentHandleGetMonData, LinkOpponentHandleGetRawMonData, diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 9c72b19dc..e55d78912 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -72,7 +72,7 @@ void nullsub_91(void); void OpponentBufferRunCommand(void); -void (*const gOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) = +void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { OpponentHandleGetMonData, OpponentHandleGetRawMonData, diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 33807b39a..03b67c28f 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -58,7 +58,7 @@ void PlayerHandleDrawTrainerPic(void); void PlayerHandleTrainerSlide(void); void PlayerHandleTrainerSlideBack(void); void PlayerHandleFaintAnimation(void); -void PlayerHandleCmd11(void); +void PlayerHandlePaletteFade(void); void PlayerHandleCmd12(void); void PlayerHandleBallThrow(void); void PlayerHandlePause(void); @@ -124,6 +124,11 @@ void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); void sub_8059400(u8 taskId); void sub_80595A4(u8 taskId); void PrintLinkStandbyMsg(void); +u32 CopyPlayerMonData(u8 monId, u8 *dst); +void SetPlayerMonData(u8 monId); +void sub_805B258(u8 bank, bool8 dontClearSubstituteBit); +void sub_805B464(void); +void PlayerDoMoveAnimation(void); void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { @@ -138,7 +143,7 @@ void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = PlayerHandleTrainerSlide, PlayerHandleTrainerSlideBack, PlayerHandleFaintAnimation, - PlayerHandleCmd11, + PlayerHandlePaletteFade, PlayerHandleCmd12, PlayerHandleBallThrow, PlayerHandlePause, @@ -254,16 +259,16 @@ void HandleInputChooseAction(void) switch (gActionSelectionCursor[gActiveBank]) { case ACTION_USE_MOVE: - EmitCmd33(1, ACTION_USE_MOVE, 0); + EmitChoiceReturnValue(1, ACTION_USE_MOVE, 0); break; case ACTION_USE_ITEM: - EmitCmd33(1, ACTION_USE_ITEM, 0); + EmitChoiceReturnValue(1, ACTION_USE_ITEM, 0); break; case ACTION_SWITCH: - EmitCmd33(1, ACTION_SWITCH, 0); + EmitChoiceReturnValue(1, ACTION_SWITCH, 0); break; case ACTION_RUN: - EmitCmd33(1, ACTION_RUN, 0); + EmitChoiceReturnValue(1, ACTION_RUN, 0); break; } PlayerBufferExecCompleted(); @@ -324,7 +329,7 @@ void HandleInputChooseAction(void) return; } PlaySE(SE_SELECT); - EmitCmd33(1, ACTION_CANCEL_PARTNER, 0); + EmitChoiceReturnValue(1, ACTION_CANCEL_PARTNER, 0); PlayerBufferExecCompleted(); } } @@ -370,7 +375,7 @@ void HandleInputChooseTarget(void) { PlaySE(SE_SELECT); gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; - EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + EmitChoiceReturnValue(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); dp11b_obj_free(gMultiUsePlayerCursor, 1); PlayerBufferExecCompleted(); } @@ -527,7 +532,7 @@ void HandleInputChooseMove(void) if (!canSelectTarget) { - EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + EmitChoiceReturnValue(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); PlayerBufferExecCompleted(); } else @@ -547,7 +552,7 @@ void HandleInputChooseMove(void) else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) { PlaySE(SE_SELECT); - EmitCmd33(1, 10, 0xFFFF); + EmitChoiceReturnValue(1, 10, 0xFFFF); PlayerBufferExecCompleted(); } else if (gMain.newKeys & DPAD_LEFT) @@ -612,7 +617,7 @@ void HandleInputChooseMove(void) gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBank] + 1; MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); - sub_814F9EC(gText_BattleSwitchWhich, 0xB); + BattleHandleAddTextPrinter(gText_BattleSwitchWhich, 0xB); gBattleBankFunc[gActiveBank] = HandleMoveSwitchting; } } @@ -988,7 +993,7 @@ void sub_805896C(void) extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_8076918(u8 bank); -extern u8 gUnknown_03005D7C[]; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; void sub_8058B40(void) { @@ -1173,7 +1178,7 @@ void sub_80591B8(u8 taskId) gainedExp -= nextLvlExp - currExp; savedActiveBank = gActiveBank; gActiveBank = bank; - EmitCmd33(1, 11, gainedExp); + EmitChoiceReturnValue(1, 11, gainedExp); gActiveBank = savedActiveBank; if (IsDoubleBattle() == TRUE @@ -1252,7 +1257,7 @@ void sub_8059400(u8 taskId) gainedExp -= expOnNextLvl - currExp; savedActiveBank = gActiveBank; gActiveBank = bank; - EmitCmd33(1, 11, gainedExp); + EmitChoiceReturnValue(1, 11, gainedExp); gActiveBank = savedActiveBank; gTasks[taskId].func = sub_8059544; } @@ -1427,7 +1432,7 @@ void DoHitAnimBlinkEffect(void) } } -void sub_80599D4(void) +void PlayerHandleYesNoInput(void) { if (gMain.newKeys & DPAD_UP && gMultiUsePlayerCursor != 0) { @@ -1445,19 +1450,19 @@ void sub_80599D4(void) } if (gMain.newKeys & A_BUTTON) { - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); PlaySE(SE_SELECT); if (gMultiUsePlayerCursor != 0) - EmitCmd33(1, 0xE, 0); + EmitChoiceReturnValue(1, 0xE, 0); else - EmitCmd33(1, 0xD, 0); + EmitChoiceReturnValue(1, 0xD, 0); PlayerBufferExecCompleted(); } if (gMain.newKeys & B_BUTTON) { - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); PlaySE(SE_SELECT); PlayerBufferExecCompleted(); } @@ -1476,7 +1481,7 @@ void MoveSelectionDisplayMoveNames(void) { MoveSelectionDestroyCursorAt(i); StringCopy(gDisplayedStringBattle, gMoveNames[moveInfo->moves[i]]); - sub_814F9EC(gDisplayedStringBattle, i + 3); + BattleHandleAddTextPrinter(gDisplayedStringBattle, i + 3); if (moveInfo->moves[i] != MOVE_NONE) gNumberOfMovesToChoose++; } @@ -1485,7 +1490,7 @@ void MoveSelectionDisplayMoveNames(void) void MoveSelectionDisplayPpString(void) { StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); - sub_814F9EC(gDisplayedStringBattle, 7); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 7); } void MoveSelectionDisplayPpNumber(void) @@ -1503,7 +1508,7 @@ void MoveSelectionDisplayPpNumber(void) txtPtr++; ConvertIntToDecimalStringN(txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]], STR_CONV_MODE_RIGHT_ALIGN, 2); - sub_814F9EC(gDisplayedStringBattle, 9); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 9); } extern const u8 gTypeNames[][7]; @@ -1522,7 +1527,7 @@ void MoveSelectionDisplayMoveType(void) txtPtr++; StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBank]]].type]); - sub_814F9EC(gDisplayedStringBattle, 10); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 10); } void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) @@ -1595,6 +1600,1063 @@ void PrintLinkStandbyMsg(void) { gBattle_BG0_X = 0; gBattle_BG0_Y = 0; - sub_814F9EC(gText_LinkStandby, 0); + BattleHandleAddTextPrinter(gText_LinkStandby, 0); + } +} + +void PlayerHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyPlayerMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyPlayerMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + PlayerBufferExecCompleted(); +} + +u32 CopyPlayerMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gPlayerParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gPlayerParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +void PlayerHandleGetRawMonData(void) +{ + struct BattlePokemon battleMon; + u8 *src = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = src[i]; + + EmitDataTransfer(1, gBattleBufferA[gActiveBank][2], dst); + PlayerBufferExecCompleted(); +} + +void PlayerHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetPlayerMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetPlayerMonData(i); + monsToCheck >>= 1; + } + } + PlayerBufferExecCompleted(); +} + +void SetPlayerMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +void PlayerHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + PlayerBufferExecCompleted(); +} + +void PlayerHandleLoadMonSprite(void) +{ + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gBattleBankFunc[gActiveBank] = CompleteOnBankSpritePosX_0; +} + +void PlayerHandleSwitchInAnim(void) +{ + ClearTemporarySpeciesSpriteData(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + gActionSelectionCursor[gActiveBank] = 0; + gMoveSelectionCursor[gActiveBank] = 0; + sub_805B258(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_805902C; +} + +extern struct SpriteTemplate gUnknown_0202499C; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; + +extern u8 sub_80A5C6C(u16, u8); +extern u8 sub_80A6138(u8 bank); +extern u8 sub_80A82E4(u8 bank); +extern u8 sub_80753E8(u16, u8); +extern void sub_806A068(u16, u8); + +void sub_805B258(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite( + &gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); +} + +void PlayerHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + gBattleBankFunc[gActiveBank] = sub_805B464; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void sub_805B464(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); + gBattleBankFunc[gActiveBank] = sub_8059744; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; + +extern u16 gPartnerTrainerId; + +// some explanation here +// in emerald it's possible to have a tag battle in the battle frontier facilities with AI +// which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it +void PlayerHandleDrawTrainerPic(void) +{ + s16 xPos, yPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_LEAF_GREEN) + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + BACK_PIC_RED; + } + else if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_SAPPHIRE) + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + BACK_PIC_RS_BRENDAN; + } + else + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender; + } + } + else + { + trainerPicId = gSaveBlock2Ptr->playerGender; + } + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 90; + else // first mon + xPos = 32; + + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId != STEVEN_PARTNER_ID) + { + xPos = 90; + yPos = (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 80; + } + else + { + yPos = (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80; + } + + } + else + { + xPos = 80; + yPos = (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80; + } + + // Use front pic table for any tag battles unless your partner is Steven. + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && gPartnerTrainerId != STEVEN_PARTNER_ID) + { + trainerPicId = PlayerGenderToFrontTrainerPicId(gSaveBlock2Ptr->playerGender); + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A1C0(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].pos2.y = 48; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gSprites[gBankSpriteIds[gActiveBank]].oam.affineMode = 0; + gSprites[gBankSpriteIds[gActiveBank]].hFlip = 1; + } + // use the back pic in any other scenario + else + { + DecompressTrainerBackPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + } + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +void PlayerHandleTrainerSlide(void) +{ + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_LEAF_GREEN) + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + BACK_PIC_RED; + } + else if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_SAPPHIRE) + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + BACK_PIC_RS_BRENDAN; + } + else + { + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender; + } + } + else + { + trainerPicId = gSaveBlock2Ptr->playerGender; + } + + DecompressTrainerBackPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, 80, (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80, 30); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -96; + gSprites[gBankSpriteIds[gActiveBank]].data0 = 2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; +} + +extern void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*spriteCallback)(struct Sprite*)); +extern void oamt_add_pos2_onto_pos1(struct Sprite *sprite); +extern void sub_80A6EEC(struct Sprite *sprite); +extern void sub_8039C00(struct Sprite *sprite); + +void PlayerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + gBattleBankFunc[gActiveBank] = sub_80588B4; +} + +void PlayerHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; + gBattleBankFunc[gActiveBank] = sub_80596A8; + } + } +} + +void PlayerHandlePaletteFade(void) +{ + BeginNormalPaletteFade(-1, 2, 0, 16, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandleCmd12(void) +{ + gBattleSpritesDataPtr->animationData->field_8 = 4; + gDoingBattleAnim = TRUE; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), 3); + gBattleBankFunc[gActiveBank] = sub_805991C; +} + +void PlayerHandleBallThrow(void) +{ + u8 var = gBattleBufferA[gActiveBank][1]; + + gBattleSpritesDataPtr->animationData->field_8 = var; + gDoingBattleAnim = TRUE; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), 3); + gBattleBankFunc[gActiveBank] = sub_805991C; +} + +void PlayerHandlePause(void) +{ + u8 var = gBattleBufferA[gActiveBank][1]; + + // WTF is this?? + while (var != 0) + var--; + + PlayerBufferExecCompleted(); +} + +extern void sub_817E0FC(u16 move, u16 weatherFlags, struct DisableStruct *disableStructPtr); +extern bool8 mplay_80342A4(u8 bank); + +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; + +void PlayerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always return FALSE + { + PlayerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + gBattleBankFunc[gActiveBank] = PlayerDoMoveAnimation; + sub_817E0FC(move, gWeatherMoveAnim, gAnimDisableStructPtr); + } + } +} + +void PlayerDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + PlayerBufferExecCompleted(); + } + break; + } +} + +extern void sub_817C95C(u16 stringId); +extern void sub_81A57E4(u8 bank, u16 stringId); + +void PlayerHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter2; + sub_817C95C(*stringId); + sub_81A57E4(gActiveBank, *stringId); +} + +void PlayerHandlePrintStringPlayerOnly(void) +{ + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + PlayerHandlePrintString(); + else + PlayerBufferExecCompleted(); +} + +void HandleChooseActionAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 160; + gBattleBankFunc[gActiveBank] = HandleInputChooseAction; + } +} + +extern void sub_817F2A8(void); +extern const u8 gText_BattleMenu[]; +extern const u8 gText_WhatWillPkmnDo[]; +extern const u8 gText_BattleYesNoChoice[]; + +void PlayerHandleChooseAction(void) +{ + s32 i; + + gBattleBankFunc[gActiveBank] = HandleChooseActionAfterDma3; + sub_817F2A8(); + BattleHandleAddTextPrinter(gText_BattleMenu, 2); + + for (i = 0; i < 4; i++) + ActionSelectionDestroyCursorAt(i); + + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 1); +} + +void PlayerHandleCmd19(void) +{ + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + { + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 12); + gMultiUsePlayerCursor = 1; + BattleCreateYesNoCursorAt(1); + gBattleBankFunc[gActiveBank] = PlayerHandleYesNoInput; + } + else + { + PlayerBufferExecCompleted(); } } diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index e7594a2f0..ce38ca882 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -72,7 +72,7 @@ void nullsub_118(void); void WallyBufferRunCommand(void); -void (*const gWallyBufferCommands[CONTOLLER_CMDS_CONT])(void) = +void (*const gWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { WallyHandleGetMonData, WallyHandleGetRawMonData, diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 9ac18c72f..1086c6955 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -939,11 +939,11 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId) } } -void EmitGetMonData(u8 bufferId, u8 arg1, u8 arg2) +void EmitGetMonData(u8 bufferId, u8 requestId, u8 monsToCheck) { gBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA; - gBattleBuffersTransferData[1] = arg1; - gBattleBuffersTransferData[2] = arg2; + gBattleBuffersTransferData[1] = requestId; + gBattleBuffersTransferData[2] = monsToCheck; gBattleBuffersTransferData[3] = 0; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -957,13 +957,13 @@ void EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitSetMonData(u8 bufferId, u8 request, u8 c, u8 bytes, void *data) +void EmitSetMonData(u8 bufferId, u8 requestId, u8 monsToCheck, u8 bytes, void *data) { s32 i; gBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA; - gBattleBuffersTransferData[1] = request; - gBattleBuffersTransferData[2] = c; + gBattleBuffersTransferData[1] = requestId; + gBattleBuffersTransferData[2] = monsToCheck; for (i = 0; i < bytes; i++) gBattleBuffersTransferData[3 + i] = *(u8*)(data++); PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 3 + bytes); @@ -1042,12 +1042,12 @@ void EmitFaintAnimation(u8 bufferId) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitCmd11(u8 bufferId) +void EmitPaletteFade(u8 bufferId) { - gBattleBuffersTransferData[0] = CONTROLLER_11; - gBattleBuffersTransferData[1] = 11; - gBattleBuffersTransferData[2] = 11; - gBattleBuffersTransferData[3] = 11; + gBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE; + gBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE; + gBattleBuffersTransferData[2] = CONTROLLER_PALETTEFADE; + gBattleBuffersTransferData[3] = CONTROLLER_PALETTEFADE; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1178,12 +1178,12 @@ void EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitCmd19(u8 bufferId) +void EmitYesNoBox(u8 bufferId) { - gBattleBuffersTransferData[0] = CONTROLLER_19; - gBattleBuffersTransferData[1] = 19; - gBattleBuffersTransferData[2] = 19; - gBattleBuffersTransferData[3] = 19; + gBattleBuffersTransferData[0] = CONTROLLER_YESNOBOX; + gBattleBuffersTransferData[1] = CONTROLLER_YESNOBOX; + gBattleBuffersTransferData[2] = CONTROLLER_YESNOBOX; + gBattleBuffersTransferData[3] = CONTROLLER_YESNOBOX; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1337,9 +1337,9 @@ void EmitCmd32(u8 bufferId, u16 size, void *data) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 3); } -void EmitCmd33(u8 bufferId, u8 arg1, u16 arg2) +void EmitChoiceReturnValue(u8 bufferId, u8 arg1, u16 arg2) { - gBattleBuffersTransferData[0] = CONTROLLER_33; + gBattleBuffersTransferData[0] = CONTROLLER_CHOICERETURNVALUE; gBattleBuffersTransferData[1] = arg1; gBattleBuffersTransferData[2] = arg2; gBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8; diff --git a/src/battle_message.c b/src/battle_message.c index aeff721d6..d0c7b118d 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -2209,7 +2209,7 @@ static void sub_814F950(u8* dst) } } -void sub_814F9EC(const u8 *text, u8 arg1) +void BattleHandleAddTextPrinter(const u8 *text, u8 arg1) { const u8 *r8 = gUnknown_085CD660[gBattleScripting.field_24]; bool32 r9; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 4ba86775e..a112cd7b9 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -6114,8 +6114,8 @@ static void atk5A_yesnoboxlearnmove(void) switch (gBattleScripting.learnMoveState) { case 0: - sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); - sub_814F9EC(gText_BattleYesNoChoice, 0xC); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 0xC); gBattleScripting.learnMoveState++; gBattleCommunication[CURSOR_POSITION] = 0; BattleCreateYesNoCursorAt(0); @@ -6140,7 +6140,7 @@ static void atk5A_yesnoboxlearnmove(void) PlaySE(SE_SELECT); if (gBattleCommunication[1] == 0) { - sub_8056A3C(0x18, 0x8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 0x8, 0x1D, 0xD, WINDOW_CLEAR); BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); gBattleScripting.learnMoveState++; } @@ -6214,7 +6214,7 @@ static void atk5A_yesnoboxlearnmove(void) } break; case 5: - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); gBattlescriptCurrInstr += 5; break; case 6: @@ -6231,8 +6231,8 @@ static void atk5B_yesnoboxstoplearningmove(void) switch (gBattleScripting.learnMoveState) { case 0: - sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); - sub_814F9EC(gText_BattleYesNoChoice, 0xC); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 0xC); gBattleScripting.learnMoveState++; gBattleCommunication[CURSOR_POSITION] = 0; BattleCreateYesNoCursorAt(0); @@ -6261,13 +6261,13 @@ static void atk5B_yesnoboxstoplearningmove(void) else gBattlescriptCurrInstr += 5; - sub_8056A3C(0x18, 0x8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 0x8, 0x1D, 0xD, WINDOW_CLEAR); } else if (gMain.newKeys & B_BUTTON) { PlaySE(SE_SELECT); gBattlescriptCurrInstr = BSScriptReadPtr(gBattlescriptCurrInstr + 1); - sub_8056A3C(0x18, 0x8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 0x8, 0x1D, 0xD, WINDOW_CLEAR); } break; } @@ -6527,8 +6527,8 @@ static void atk67_yesnobox(void) switch (gBattleCommunication[0]) { case 0: - sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); - sub_814F9EC(gText_BattleYesNoChoice, 0xC); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 0xC); gBattleCommunication[0]++; gBattleCommunication[CURSOR_POSITION] = 0; BattleCreateYesNoCursorAt(0); @@ -6552,13 +6552,13 @@ static void atk67_yesnobox(void) { gBattleCommunication[CURSOR_POSITION] = 1; PlaySE(SE_SELECT); - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); gBattlescriptCurrInstr++; } else if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - sub_8056A3C(0x18, 8, 0x1D, 0xD, 1); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, WINDOW_CLEAR); gBattlescriptCurrInstr++; } break; @@ -6674,7 +6674,7 @@ static void atk6C_draw_lvlupbox(void) SetBgAttribute(1, BG_CTRL_ATTR_MOSAIC, 0); ShowBg(0); ShowBg(1); - sub_8056A3C(0x12, 7, 0x1D, 0x13, 0x80); + HandleBattleWindow(0x12, 7, 0x1D, 0x13, WINDOW_x80); gBattleScripting.atk6C_state = 4; break; case 4: @@ -6704,7 +6704,7 @@ static void atk6C_draw_lvlupbox(void) if (gMain.newKeys != 0) { PlaySE(SE_SELECT); - sub_8056A3C(0x12, 7, 0x1D, 0x13, 0x81); + HandleBattleWindow(0x12, 7, 0x1D, 0x13, WINDOW_x80 | WINDOW_CLEAR); gBattleScripting.atk6C_state++; } break; @@ -7136,8 +7136,8 @@ static void atk76_various(void) gDisableStructs[0].truantUnknownBit = 1; gDisableStructs[1].truantUnknownBit = 1; break; - case 13: - EmitCmd19(0); + case VARIOUS_EMIT_YESNOBOX: + EmitYesNoBox(0); MarkBufferBankForExecution(gActiveBank); break; case 14: @@ -7148,7 +7148,7 @@ static void atk76_various(void) break; case 16: BattleStringExpandPlaceholdersToDisplayedString(gRefereeStringsTable[gBattlescriptCurrInstr[1]]); - sub_814F9EC(gDisplayedStringBattle, 0x16); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0x16); break; case 17: if (IsTextPrinterActive(0x16)) @@ -8443,7 +8443,7 @@ static void atk9B_transformdataexecution(void) gBattleMons[gBankAttacker].status2 |= STATUS2_TRANSFORMED; gDisableStructs[gBankAttacker].disabledMove = 0; gDisableStructs[gBankAttacker].disableTimer1 = 0; - gDisableStructs[gBankAttacker].unk0 = gBattleMons[gBankTarget].personality; + gDisableStructs[gBankAttacker].transformedMonPersonality = gBattleMons[gBankTarget].personality; gDisableStructs[gBankAttacker].unk18_b = 0; PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBankTarget].species) @@ -9152,7 +9152,7 @@ static void atkA8_copymovepermanently(void) // sketch for (i = 0; i < 4; i++) { - movePpData.move[i] = gBattleMons[gBankAttacker].moves[i]; + movePpData.moves[i] = gBattleMons[gBankAttacker].moves[i]; movePpData.pp[i] = gBattleMons[gBankAttacker].pp[i]; } movePpData.ppBonuses = gBattleMons[gBankAttacker].ppBonuses; @@ -11238,7 +11238,7 @@ static void atkF2_display_dex_info(void) } } -void sub_8056A3C(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags) +void HandleBattleWindow(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags) { s32 destY, destX; u16 var = 0; @@ -11275,10 +11275,10 @@ void sub_8056A3C(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags) var = 0x1026; } - if (flags & 1) + if (flags & WINDOW_CLEAR) var = 0; - if (flags & 0x80) + if (flags & WINDOW_x80) CopyToBgTilemapBufferRect_ChangePalette(1, &var, destX, destY, 1, 1, 0x11); else CopyToBgTilemapBufferRect_ChangePalette(0, &var, destX, destY, 1, 1, 0x11); @@ -11311,8 +11311,8 @@ static void atkF3_nickname_caught_poke(void) switch (gBattleCommunication[MULTIUSE_STATE]) { case 0: - sub_8056A3C(0x18, 8, 0x1D, 0xD, 0); - sub_814F9EC(gText_BattleYesNoChoice, 0xC); + HandleBattleWindow(0x18, 8, 0x1D, 0xD, 0); + BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 0xC); gBattleCommunication[MULTIUSE_STATE]++; gBattleCommunication[CURSOR_POSITION] = 0; BattleCreateYesNoCursorAt(0); diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 972e1943a..78c205517 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -194,6 +194,7 @@ void sub_806A1C0(u16 arg0, u8 bankIdentity) gUnknown_0202499C = gMonSpritesGfxPtr->templates[bankIdentity]; else gUnknown_0202499C = gUnknown_08329D98[bankIdentity]; + gUnknown_0202499C.paletteTag = arg0; gUnknown_0202499C.anims = gUnknown_0830536C[arg0]; } @@ -1304,7 +1305,7 @@ void RemoveBattleMonPPBonus(struct BattlePokemon *mon, u8 moveIndex) } void sub_803FA70(u8 bank); -void sub_805EF84(u8 bank, bool8); +void ClearTemporarySpeciesSpriteData(u8 bank, bool8); extern struct BattlePokemon gBattleMons[4]; @@ -1360,5 +1361,5 @@ void CopyPlayerPartyMonToBattleData(u8 bank, u8 partyIndex) gBattleMons[bank].status2 = 0; sub_803FA70(bank); - sub_805EF84(bank, FALSE); + ClearTemporarySpeciesSpriteData(bank, FALSE); } diff --git a/src/pokemon_3.c b/src/pokemon_3.c index 5ff99aee2..aa45c3d24 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -1659,7 +1659,7 @@ u16 sub_806EFF0(u16 arg0) return gUnknown_0831F578[arg0]; } -u16 sub_806F000(u8 playerGender) +u16 PlayerGenderToFrontTrainerPicId(u8 playerGender) { if (playerGender) return sub_806EFF0(0x3F); diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c index 343ddb9c0..002f4f069 100644 --- a/src/reshow_battle_screen.c +++ b/src/reshow_battle_screen.c @@ -220,9 +220,9 @@ static bool8 LoadBankSpriteGfx(u8 bank) BattleLoadSubstituteSpriteGfx(bank, FALSE); } else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0) - LoadBackTrainerBankSpriteGfx(gSaveBlock2Ptr->playerGender, bank); + DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, bank); else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0) - LoadBackTrainerBankSpriteGfx(BACK_PIC_WALLY, bank); + DecompressTrainerBackPic(BACK_PIC_WALLY, bank); else if (!gBattleSpritesDataPtr->bankData[bank].behindSubstitute) BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[bank]], bank); else -- cgit v1.2.3 From df4e32a307c17163e9a64e5ea615ab9eb18afc4b Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 22 Oct 2017 18:43:15 +0200 Subject: player battle controller is done --- src/battle_2.c | 5 +- src/battle_ai_switch_items.c | 18 +- src/battle_anim.c | 20 +- src/battle_controller_player.c | 1114 +++++++++++++++++++++++++++++----------- src/battle_controllers.c | 94 ++-- src/battle_interface.c | 53 +- src/battle_script_commands.c | 16 +- 7 files changed, 899 insertions(+), 421 deletions(-) (limited to 'src') diff --git a/src/battle_2.c b/src/battle_2.c index f2a5508e0..fd1b88b48 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -238,7 +238,6 @@ static void sub_8038F34(void); static void sub_80392A8(void); static void sub_803937C(void); static void sub_803939C(void); -void oac_poke_opponent(struct Sprite *sprite); static void sub_803980C(struct Sprite *sprite); static void sub_8039838(struct Sprite *sprite); static void sub_8039894(struct Sprite *sprite); @@ -4025,7 +4024,7 @@ static void HandleTurnActionSelectionState(void) } else { - EmitOpenBag(0, gBattleStruct->field_60[gActiveBank]); + EmitChooseItem(0, gBattleStruct->field_60[gActiveBank]); MarkBufferBankForExecution(gActiveBank); } break; @@ -4070,7 +4069,7 @@ static void HandleTurnActionSelectionState(void) } break; case ACTION_POKEBLOCK_CASE: - EmitOpenBag(0, gBattleStruct->field_60[gActiveBank]); + EmitChooseItem(0, gBattleStruct->field_60[gActiveBank]); MarkBufferBankForExecution(gActiveBank); break; case ACTION_CANCEL_PARTNER: diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index 3f97c59a5..de440054c 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -39,7 +39,7 @@ static bool8 ShouldSwitchIfPerishSong(void) && gDisableStructs[gActiveBank].perishSong1 == 0) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } @@ -121,7 +121,7 @@ static bool8 ShouldSwitchIfWonderGuard(void) { // we found a mon *(gBattleStruct->field_294 + gActiveBank) = i; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } } @@ -221,7 +221,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) { // we found a mon *(gBattleStruct->field_294 + gActiveBank) = i; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } } @@ -241,13 +241,13 @@ static bool8 ShouldSwitchIfNaturalCure(void) if ((gUnknown_02024250[gActiveBank] == 0 || gUnknown_02024250[gActiveBank] == 0xFFFF) && Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } else if (gBattleMoves[gUnknown_02024250[gActiveBank]].power == 0 && Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } @@ -258,7 +258,7 @@ static bool8 ShouldSwitchIfNaturalCure(void) if (Random() & 1) { *(gBattleStruct->field_294 + gActiveBank) = 6; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } @@ -426,7 +426,7 @@ static bool8 FindMonWithFlagsAndSuperEffective(u8 flags, u8 moduloPercent) if (moveFlags & MOVESTATUS_SUPEREFFECTIVE && Random() % moduloPercent == 0) { *(gBattleStruct->field_294 + gActiveBank) = i; - EmitChoiceReturnValue(1, 2, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); return TRUE; } } @@ -611,7 +611,7 @@ void AI_TrySwitchOrUseItem(void) } } - EmitChoiceReturnValue(1, 0, (gActiveBank ^ BIT_SIDE) << 8); + EmitTwoReturnValues(1, ACTION_USE_MOVE, (gActiveBank ^ BIT_SIDE) << 8); } #define TYPE_FORESIGHT 0xFE @@ -940,7 +940,7 @@ static bool8 ShouldUseItem(void) if (shouldUse) { - EmitChoiceReturnValue(1, 1, 0); + EmitTwoReturnValues(1, ACTION_USE_ITEM, 0); *(gBattleStruct->field_C0 + (gActiveBank / 2) * 2) = item; gBattleResources->battleHistory->trainerItems[i] = 0; return shouldUse; diff --git a/src/battle_anim.c b/src/battle_anim.c index 023272017..d41dc77c4 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -47,18 +47,6 @@ extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; extern const struct BattleAnimBackground gBattleAnimBackgroundTable[]; -extern void sub_80A8278(void); // rom_80A5C6C.s -extern void sub_80A6B30(struct UnknownAnimStruct2*); // rom_80A5C6C.s -extern void sub_80A6B90(struct UnknownAnimStruct2*, u32 arg1); // rom_80A5C6C.s -extern u8 sub_80A82E4(u8 bank); // rom_80A5C6C.s -extern u8 sub_80A5C6C(u8 bank, u8 attributeId); // rom_80A5C6C.s -extern bool8 AnimBankSpriteExists(u8 bank); // rom_80A5C6C.s -extern void sub_80A6C68(u8 arg0); // rom_80A5C6C.s -extern u8 GetAnimBankSpriteId(u8 wantedBank); // rom_80A5C6C.s -extern u8 sub_80A6D94(void); -extern u8 sub_80A8364(u8); -extern bool8 IsDoubleBattle(void); - // this file's functions static void ScriptCmd_loadspritegfx(void); static void ScriptCmd_unloadspritegfx(void); @@ -234,10 +222,10 @@ void DoMoveAnim(u16 move) { gAnimBankAttacker = gBankAttacker; gAnimBankTarget = gBankTarget; - DoBattleAnim(gBattleAnims_Moves, move, TRUE); + LaunchBattleAnimation(gBattleAnims_Moves, move, TRUE); } -void DoBattleAnim(const u8 *const animsTable[], u16 tableId, bool8 isMoveAnim) +void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMoveAnim) { s32 i; @@ -1281,7 +1269,7 @@ static void ScriptCmd_changebg(void) s8 BattleAnimAdjustPanning(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].flag_x10) + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].statusAnimActive) { if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER) pan = PAN_SIDE_OPPONENT; @@ -1323,7 +1311,7 @@ s8 BattleAnimAdjustPanning(s8 pan) s8 BattleAnimAdjustPanning2(s8 pan) { - if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].flag_x10) + if (!IsContest() && gBattleSpritesDataPtr->healthBoxesData[gAnimBankAttacker].statusAnimActive) { if (GetBankSide(gAnimBankAttacker) != SIDE_PLAYER) pan = PAN_SIDE_OPPONENT; diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 03b67c28f..b41dbf0bc 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -4,6 +4,7 @@ #include "battle_message.h" #include "battle_interface.h" #include "battle_anim.h" +#include "battle_link_817C95C.h" #include "pokemon.h" #include "link.h" #include "util.h" @@ -21,6 +22,8 @@ #include "string_util.h" #include "bg.h" #include "reshow_battle_screen.h" +#include "rng.h" +#include "pokeball.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -39,98 +42,134 @@ extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; extern u8 gMultiUsePlayerCursor; extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; extern struct MusicPlayerInfo gMPlay_BGM; +extern u16 gPartnerTrainerId; +extern struct SpriteTemplate gUnknown_0202499C; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gScriptItemId; +extern u8 gUnknown_0203CEE8; +extern u8 gUnknown_0203CEE9; +extern u8 gUnknown_0203CF00[]; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u8 gNumberOfMovesToChoose; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern s32 gUnknown_0203CD70; +extern u8 gBankInMenu; +extern u32 gBattlePalaceMoveSelectionRngValue; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern u8 gUnknown_020244B4[]; +extern u16 gUnknown_020243FC; +extern struct UnusedControllerStruct gUnknown_02022D0C; +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const u8 gTypeNames[][7]; extern const struct BattleMove gBattleMoves[]; -extern void dp11b_obj_instanciate(u8, u8, s8, s8); -extern void dp11b_obj_free(u8, u8); -extern void sub_800AC34(void); +extern const u8 gText_BattleSwitchWhich[]; +extern const u8 gText_MoveInterfacePP[]; +extern const u8 gText_MoveInterfaceType[]; +extern const u8 gText_LinkStandby[]; +extern const u8 gText_BattleMenu[]; +extern const u8 gText_WhatWillPkmnDo[]; +extern const u8 gText_BattleYesNoChoice[]; + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_81B89AC(u8 arg0); +extern void sub_81AABB0(void); +extern void sub_806A068(u16, u8); +extern void sub_81A57E4(u8 bank, u16 stringId); +extern void sub_81851A8(u8 *); // this file's functions -void PlayerHandleGetMonData(void); +static void PlayerHandleGetMonData(void); void PlayerHandleGetRawMonData(void); -void PlayerHandleSetMonData(void); -void PlayerHandleSetRawMonData(void); -void PlayerHandleLoadMonSprite(void); -void PlayerHandleSwitchInAnim(void); -void PlayerHandleReturnMonToBall(void); -void PlayerHandleDrawTrainerPic(void); -void PlayerHandleTrainerSlide(void); -void PlayerHandleTrainerSlideBack(void); -void PlayerHandleFaintAnimation(void); -void PlayerHandlePaletteFade(void); -void PlayerHandleCmd12(void); -void PlayerHandleBallThrow(void); -void PlayerHandlePause(void); -void PlayerHandleMoveAnimation(void); -void PlayerHandlePrintString(void); -void PlayerHandlePrintStringPlayerOnly(void); -void PlayerHandleChooseAction(void); -void PlayerHandleCmd19(void); -void PlayerHandleChooseMove(void); -void PlayerHandleOpenBag(void); -void PlayerHandleChoosePokemon(void); -void PlayerHandleCmd23(void); -void PlayerHandleHealthBarUpdate(void); -void PlayerHandleExpUpdate(void); -void PlayerHandleStatusIconUpdate(void); -void PlayerHandleStatusAnimation(void); -void PlayerHandleStatusXor(void); -void PlayerHandleDataTransfer(void); -void PlayerHandleDMA3Transfer(void); -void PlayerHandlePlayBGM(void); -void PlayerHandleCmd32(void); -void PlayerHandleCmd33(void); -void PlayerHandleCmd34(void); -void PlayerHandleCmd35(void); -void PlayerHandleCmd36(void); -void PlayerHandleCmd37(void); -void PlayerHandleCmd38(void); -void PlayerHandleCmd39(void); -void PlayerHandleCmd40(void); -void PlayerHandleHitAnimation(void); -void PlayerHandleCmd42(void); -void PlayerHandleEffectivenessSound(void); -void PlayerHandlePlayFanfareOrBGM(void); -void PlayerHandleFaintingCry(void); -void PlayerHandleIntroSlide(void); -void PlayerHandleIntroTrainerBallThrow(void); -void PlayerHandleDrawPartyStatusSummary(void); -void PlayerHandleCmd49(void); -void PlayerHandleCmd50(void); -void PlayerHandleSpriteInvisibility(void); -void PlayerHandleBattleAnimation(void); -void PlayerHandleLinkStandbyMsg(void); -void PlayerHandleResetActionMoveSelection(void); -void PlayerHandleCmd55(void); -void nullsub_22(void); - -void PlayerBufferRunCommand(void); -void HandleInputChooseTarget(void); -void HandleInputChooseMove(void); -void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1); -void MoveSelectionDestroyCursorAt(u8 cursorPos); -void MoveSelectionDisplayPpNumber(void); -void MoveSelectionDisplayPpString(void); -void MoveSelectionDisplayMoveType(void); -void MoveSelectionDisplayMoveNames(void); -void HandleMoveSwitchting(void); -void sub_8058FC0(void); -void sub_8059828(void); -void sub_80598E0(void); -void sub_8059544(u8 taskId); -void sub_8059330(u8 taskId); -void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); -void sub_8059400(u8 taskId); -void sub_80595A4(u8 taskId); -void PrintLinkStandbyMsg(void); -u32 CopyPlayerMonData(u8 monId, u8 *dst); -void SetPlayerMonData(u8 monId); -void sub_805B258(u8 bank, bool8 dontClearSubstituteBit); -void sub_805B464(void); -void PlayerDoMoveAnimation(void); - -void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void PlayerHandleSetMonData(void); +static void PlayerHandleSetRawMonData(void); +static void PlayerHandleLoadMonSprite(void); +static void PlayerHandleSwitchInAnim(void); +static void PlayerHandleReturnMonToBall(void); +static void PlayerHandleDrawTrainerPic(void); +static void PlayerHandleTrainerSlide(void); +static void PlayerHandleTrainerSlideBack(void); +static void PlayerHandleFaintAnimation(void); +static void PlayerHandlePaletteFade(void); +static void PlayerHandleSuccessBallThrowAnim(void); +static void PlayerHandleBallThrowAnim(void); +static void PlayerHandlePause(void); +static void PlayerHandleMoveAnimation(void); +static void PlayerHandlePrintString(void); +static void PlayerHandlePrintStringPlayerOnly(void); +static void PlayerHandleChooseAction(void); +static void PlayerHandleUnknownYesNoBox(void); +static void PlayerHandleChooseMove(void); +static void PlayerHandleChooseItem(void); +static void PlayerHandleChoosePokemon(void); +static void PlayerHandleCmd23(void); +static void PlayerHandleHealthBarUpdate(void); +static void PlayerHandleExpUpdate(void); +static void PlayerHandleStatusIconUpdate(void); +static void PlayerHandleStatusAnimation(void); +static void PlayerHandleStatusXor(void); +static void PlayerHandleDataTransfer(void); +static void PlayerHandleDMA3Transfer(void); +static void PlayerHandlePlayBGM(void); +static void PlayerHandleCmd32(void); +static void PlayerHandleTwoReturnValues(void); +static void PlayerHandleChosenMonReturnValue(void); +static void PlayerHandleOneReturnValue(void); +static void PlayerHandleOneReturnValue_Duplicate(void); +static void PlayerHandleCmd37(void); +static void PlayerHandleCmd38(void); +static void PlayerHandleCmd39(void); +static void PlayerHandleCmd40(void); +static void PlayerHandleHitAnimation(void); +static void PlayerHandleCmd42(void); +static void PlayerHandleEffectivenessSound(void); +static void PlayerHandlePlayFanfareOrBGM(void); +static void PlayerHandleFaintingCry(void); +static void PlayerHandleIntroSlide(void); +static void PlayerHandleIntroTrainerBallThrow(void); +static void PlayerHandleDrawPartyStatusSummary(void); +static void PlayerHandleCmd49(void); +static void PlayerHandleCmd50(void); +static void PlayerHandleSpriteInvisibility(void); +static void PlayerHandleBattleAnimation(void); +static void PlayerHandleLinkStandbyMsg(void); +static void PlayerHandleResetActionMoveSelection(void); +static void PlayerHandleCmd55(void); +static void nullsub_22(void); + +static void PlayerBufferRunCommand(void); +static void HandleInputChooseTarget(void); +static void HandleInputChooseMove(void); +static void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1); +static void MoveSelectionDestroyCursorAt(u8 cursorPos); +static void MoveSelectionDisplayPpNumber(void); +static void MoveSelectionDisplayPpString(void); +static void MoveSelectionDisplayMoveType(void); +static void MoveSelectionDisplayMoveNames(void); +static void HandleMoveSwitchting(void); +static void sub_8058FC0(void); +static void sub_8059828(void); +static void sub_80598E0(void); +static void sub_8059544(u8 taskId); +static void Task_PrepareToGiveExpWithExpBar(u8 taskId); +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); +static void sub_8059400(u8 taskId); +static void sub_80595A4(u8 taskId); +static void PrintLinkStandbyMsg(void); +static u32 CopyPlayerMonData(u8 monId, u8 *dst); +static void SetPlayerMonData(u8 monId); +static void sub_805B258(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void PlayerDoMoveAnimation(void); +static void task05_08033660(u8 taskId); +static void sub_805CE38(void); + +static void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { PlayerHandleGetMonData, PlayerHandleGetRawMonData, @@ -144,16 +183,16 @@ void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = PlayerHandleTrainerSlideBack, PlayerHandleFaintAnimation, PlayerHandlePaletteFade, - PlayerHandleCmd12, - PlayerHandleBallThrow, + PlayerHandleSuccessBallThrowAnim, + PlayerHandleBallThrowAnim, PlayerHandlePause, PlayerHandleMoveAnimation, PlayerHandlePrintString, PlayerHandlePrintStringPlayerOnly, PlayerHandleChooseAction, - PlayerHandleCmd19, + PlayerHandleUnknownYesNoBox, PlayerHandleChooseMove, - PlayerHandleOpenBag, + PlayerHandleChooseItem, PlayerHandleChoosePokemon, PlayerHandleCmd23, PlayerHandleHealthBarUpdate, @@ -165,10 +204,10 @@ void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = PlayerHandleDMA3Transfer, PlayerHandlePlayBGM, PlayerHandleCmd32, - PlayerHandleCmd33, - PlayerHandleCmd34, - PlayerHandleCmd35, - PlayerHandleCmd36, + PlayerHandleTwoReturnValues, + PlayerHandleChosenMonReturnValue, + PlayerHandleOneReturnValue, + PlayerHandleOneReturnValue_Duplicate, PlayerHandleCmd37, PlayerHandleCmd38, PlayerHandleCmd39, @@ -207,7 +246,7 @@ void SetBankFuncToPlayerBufferRunCommand(void) gUnknown_020244CC = 0; } -void PlayerBufferExecCompleted(void) +static void PlayerBufferExecCompleted(void) { gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -223,7 +262,7 @@ void PlayerBufferExecCompleted(void) } } -void PlayerBufferRunCommand(void) +static void PlayerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { @@ -234,13 +273,13 @@ void PlayerBufferRunCommand(void) } } -void CompleteOnBankSpritePosX_0(void) +static void CompleteOnBankSpritePosX_0(void) { if (gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) PlayerBufferExecCompleted(); } -void HandleInputChooseAction(void) +static void HandleInputChooseAction(void) { u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); @@ -259,16 +298,16 @@ void HandleInputChooseAction(void) switch (gActionSelectionCursor[gActiveBank]) { case ACTION_USE_MOVE: - EmitChoiceReturnValue(1, ACTION_USE_MOVE, 0); + EmitTwoReturnValues(1, ACTION_USE_MOVE, 0); break; case ACTION_USE_ITEM: - EmitChoiceReturnValue(1, ACTION_USE_ITEM, 0); + EmitTwoReturnValues(1, ACTION_USE_ITEM, 0); break; case ACTION_SWITCH: - EmitChoiceReturnValue(1, ACTION_SWITCH, 0); + EmitTwoReturnValues(1, ACTION_SWITCH, 0); break; case ACTION_RUN: - EmitChoiceReturnValue(1, ACTION_RUN, 0); + EmitTwoReturnValues(1, ACTION_RUN, 0); break; } PlayerBufferExecCompleted(); @@ -329,7 +368,7 @@ void HandleInputChooseAction(void) return; } PlaySE(SE_SELECT); - EmitChoiceReturnValue(1, ACTION_CANCEL_PARTNER, 0); + EmitTwoReturnValues(1, ACTION_CANCEL_PARTNER, 0); PlayerBufferExecCompleted(); } } @@ -339,14 +378,14 @@ void HandleInputChooseAction(void) } } -void sub_80577F0(void) // unused +static void sub_80577F0(void) // unused { dp11b_obj_free(gActiveBank, 1); dp11b_obj_free(gActiveBank, 0); gBattleBankFunc[gActiveBank] = HandleInputChooseTarget; } -void HandleInputChooseTarget(void) +static void HandleInputChooseTarget(void) { s32 i; u8 identities[4]; @@ -375,7 +414,7 @@ void HandleInputChooseTarget(void) { PlaySE(SE_SELECT); gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; - EmitChoiceReturnValue(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); dp11b_obj_free(gMultiUsePlayerCursor, 1); PlayerBufferExecCompleted(); } @@ -474,10 +513,7 @@ void HandleInputChooseTarget(void) } } -extern u8 gNumberOfMovesToChoose; -extern const u8 gText_BattleSwitchWhich[]; - -void HandleInputChooseMove(void) +static void HandleInputChooseMove(void) { bool32 canSelectTarget = FALSE; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); @@ -532,7 +568,7 @@ void HandleInputChooseMove(void) if (!canSelectTarget) { - EmitChoiceReturnValue(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); + EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8)); PlayerBufferExecCompleted(); } else @@ -552,7 +588,7 @@ void HandleInputChooseMove(void) else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) { PlaySE(SE_SELECT); - EmitChoiceReturnValue(1, 10, 0xFFFF); + EmitTwoReturnValues(1, 10, 0xFFFF); PlayerBufferExecCompleted(); } else if (gMain.newKeys & DPAD_LEFT) @@ -623,9 +659,6 @@ void HandleInputChooseMove(void) } } -extern u16 gBattle_BG0_X; -extern u16 gBattle_BG0_Y; - u32 sub_8057FBC(void) // unused { u32 var = 0; @@ -676,7 +709,7 @@ u32 sub_8057FBC(void) // unused return var; } -void HandleMoveSwitchting(void) +static void HandleMoveSwitchting(void) { u8 perMovePPBonuses[4]; struct ChooseMoveStruct moveStruct; @@ -860,10 +893,7 @@ void HandleMoveSwitchting(void) } } -extern u8 gBattleOutcome; -extern void sub_817E3F4(void); // battle_link_817C95C - -void sub_80586F8(void) +static void sub_80586F8(void) { if (gLinkVSyncDisabled == 0) { @@ -919,19 +949,19 @@ void sub_80587B0(void) } } -void CompleteOnBankSpriteCallbackDummy(void) +static void CompleteOnBankSpriteCallbackDummy(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) PlayerBufferExecCompleted(); } -void CompleteOnBankSpriteCallbackDummy2(void) +static void CompleteOnBankSpriteCallbackDummy2(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) PlayerBufferExecCompleted(); } -void sub_80588B4(void) +static void sub_80588B4(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) { @@ -942,7 +972,7 @@ void sub_80588B4(void) } } -void sub_8058924(void) +static void sub_8058924(void) { if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) { @@ -951,11 +981,7 @@ void sub_8058924(void) } } -extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; - -extern bool8 IsDoubleBattle(void); - -void sub_805896C(void) +static void sub_805896C(void) { bool8 var = FALSE; @@ -991,11 +1017,7 @@ void sub_805896C(void) } } -extern void sub_8172EF0(u8 bank, struct Pokemon *mon); -extern void sub_8076918(u8 bank); -extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; - -void sub_8058B40(void) +static void sub_8058B40(void) { bool32 r9 = FALSE; bool32 r8 = FALSE; @@ -1071,31 +1093,28 @@ void sub_8058B40(void) } } -extern void sub_805E408(u8 bank); -extern void move_anim_start_t4(u8 arg0, u8 atkBank, u8 defBank, u8 tableId); - -void sub_8058EDC(void) +static void sub_8058EDC(void) { if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) { - sub_805E408(gActiveBank); + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; FreeSpriteTilesByTag(0x27F9); FreeSpritePaletteByTag(0x27F9); if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); gBattleBankFunc[gActiveBank] = sub_8058FC0; } } -void sub_8058FC0(void) +static void sub_8058FC0(void) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40 + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); @@ -1104,7 +1123,7 @@ void sub_8058FC0(void) } } -void sub_805902C(void) +static void sub_805902C(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) @@ -1132,7 +1151,7 @@ void c3_0802FDF4(u8 taskId) } } -void bx_t1_healthbar_update(void) +static void CompleteOnHealthbarDone(void) { s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); @@ -1149,19 +1168,24 @@ void bx_t1_healthbar_update(void) } } -void CompleteOnInactiveTextPrinter(void) +static void CompleteOnInactiveTextPrinter(void) { if (!IsTextPrinterActive(0)) PlayerBufferExecCompleted(); } -void sub_80591B8(u8 taskId) +#define tExpTask_monId data[0] +#define tExpTask_gainedExp data[1] +#define tExpTask_bank data[2] +#define tExpTask_frames data[10] + +static void Task_GiveExpToMon(u8 taskId) { - u32 monId = (u8)(gTasks[taskId].data[0]); - u8 bank = gTasks[taskId].data[2]; - s16 gainedExp = gTasks[taskId].data[1]; + u32 monId = (u8)(gTasks[taskId].tExpTask_monId); + u8 bank = gTasks[taskId].tExpTask_bank; + s16 gainedExp = gTasks[taskId].tExpTask_gainedExp; - if (IsDoubleBattle() == TRUE || monId != gBattlePartyID[bank]) + if (IsDoubleBattle() == TRUE || monId != gBattlePartyID[bank]) // give exp without the expbar { struct Pokemon *mon = &gPlayerParty[monId]; u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1178,7 +1202,7 @@ void sub_80591B8(u8 taskId) gainedExp -= nextLvlExp - currExp; savedActiveBank = gActiveBank; gActiveBank = bank; - EmitChoiceReturnValue(1, 11, gainedExp); + EmitTwoReturnValues(1, RET_VALUE_LEVELLED_UP, gainedExp); gActiveBank = savedActiveBank; if (IsDoubleBattle() == TRUE @@ -1197,15 +1221,15 @@ void sub_80591B8(u8 taskId) } else { - gTasks[taskId].func = sub_8059330; + gTasks[taskId].func = Task_PrepareToGiveExpWithExpBar; } } -void sub_8059330(u8 taskId) +static void Task_PrepareToGiveExpWithExpBar(u8 taskId) { - u8 monIndex = gTasks[taskId].data[0]; - s32 gainedExp = gTasks[taskId].data[1]; - u8 bank = gTasks[taskId].data[2]; + u8 monIndex = gTasks[taskId].tExpTask_monId; + s32 gainedExp = gTasks[taskId].tExpTask_gainedExp; + u8 bank = gTasks[taskId].tExpTask_bank; struct Pokemon *mon = &gPlayerParty[monIndex]; u8 level = GetMonData(mon, MON_DATA_LEVEL); u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1220,20 +1244,20 @@ void sub_8059330(u8 taskId) gTasks[taskId].func = sub_8059400; } -void sub_8059400(u8 taskId) +static void sub_8059400(u8 taskId) { - if (gTasks[taskId].data[10] < 13) + if (gTasks[taskId].tExpTask_frames < 13) { - gTasks[taskId].data[10]++; + gTasks[taskId].tExpTask_frames++; } else { - u8 monId = gTasks[taskId].data[0]; - s16 gainedExp = gTasks[taskId].data[1]; - u8 bank = gTasks[taskId].data[2]; + u8 monId = gTasks[taskId].tExpTask_monId; + s16 gainedExp = gTasks[taskId].tExpTask_gainedExp; + u8 bank = gTasks[taskId].tExpTask_bank; s16 r4; - r4 = sub_8074AA0(bank, gHealthBoxesIds[bank], 1, 0); + r4 = sub_8074AA0(bank, gHealthBoxesIds[bank], EXP_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[bank]); if (r4 == -1) { @@ -1257,7 +1281,7 @@ void sub_8059400(u8 taskId) gainedExp -= expOnNextLvl - currExp; savedActiveBank = gActiveBank; gActiveBank = bank; - EmitChoiceReturnValue(1, 11, gainedExp); + EmitTwoReturnValues(1, RET_VALUE_LEVELLED_UP, gainedExp); gActiveBank = savedActiveBank; gTasks[taskId].func = sub_8059544; } @@ -1272,25 +1296,25 @@ void sub_8059400(u8 taskId) } } -void sub_8059544(u8 taskId) +static void sub_8059544(u8 taskId) { - u8 bank = gTasks[taskId].data[2]; - u8 monIndex = gTasks[taskId].data[0]; + u8 bank = gTasks[taskId].tExpTask_bank; + u8 monIndex = gTasks[taskId].tExpTask_monId; if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON]) bank ^= BIT_MON; - move_anim_start_t4(bank, bank, bank, 0); + DoSpecialBattleAnimation(bank, bank, bank, B_ANIM_LVL_UP); gTasks[taskId].func = sub_80595A4; } -void sub_80595A4(u8 taskId) +static void sub_80595A4(u8 taskId) { - u8 bank = gTasks[taskId].data[2]; + u8 bank = gTasks[taskId].tExpTask_bank; - if (!gBattleSpritesDataPtr->healthBoxesData[bank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[bank].specialAnimActive) { - u8 monIndex = gTasks[taskId].data[0]; + u8 monIndex = gTasks[taskId].tExpTask_monId; GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value @@ -1303,19 +1327,19 @@ void sub_80595A4(u8 taskId) } } -void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId) +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId) { u8 monIndex; u8 bank; - monIndex = gTasks[taskId].data[0]; + monIndex = gTasks[taskId].tExpTask_monId; GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value - bank = gTasks[taskId].data[2]; + bank = gTasks[taskId].tExpTask_bank; gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; DestroyTask(taskId); } -void sub_80596A8(void) +static void sub_80596A8(void) { if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT) { @@ -1329,9 +1353,9 @@ void sub_80596A8(void) } } -void sub_8059744(void) +static void sub_8059744(void) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); @@ -1340,15 +1364,13 @@ void sub_8059744(void) } } -void CompleteOnInactiveTextPrinter2(void) +static void CompleteOnInactiveTextPrinter2(void) { if (!IsTextPrinterActive(0)) PlayerBufferExecCompleted(); } -extern void sub_81B89AC(u8 arg0); - -void sub_80597CC(void) +static void sub_80597CC(void) { if (!gPaletteFade.active) { @@ -1362,18 +1384,14 @@ void sub_80597CC(void) } } -extern u8 gUnknown_0203CEE8; -extern u8 gUnknown_0203CEE9; -extern u8 gUnknown_0203CF00[]; - -void sub_8059828(void) +static void sub_8059828(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { if (gUnknown_0203CEE8 == 1) - EmitCmd34(1, gUnknown_0203CEE9, gUnknown_0203CF00); + EmitChosenMonReturnValue(1, gUnknown_0203CEE9, gUnknown_0203CF00); else - EmitCmd34(1, 6, NULL); + EmitChosenMonReturnValue(1, 6, NULL); if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1) PrintLinkStandbyMsg(); @@ -1382,10 +1400,7 @@ void sub_8059828(void) } } -extern void sub_81AABB0(void); -extern void nullsub_35(void); - -void sub_80598A4(void) +static void sub_80598A4(void) { if (!gPaletteFade.active) { @@ -1396,24 +1411,22 @@ void sub_80598A4(void) } } -extern u16 gScriptItemId; - -void sub_80598E0(void) +static void sub_80598E0(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - EmitCmd35(1, gScriptItemId); + EmitOneReturnValue(1, gScriptItemId); PlayerBufferExecCompleted(); } } -void sub_805991C(void) +static void CompleteOnSpecialAnimDone(void) { - if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) PlayerBufferExecCompleted(); } -void DoHitAnimBlinkEffect(void) +static void DoHitAnimBlinkSpriteEffect(void) { u8 spriteId = gBankSpriteIds[gActiveBank]; @@ -1432,7 +1445,7 @@ void DoHitAnimBlinkEffect(void) } } -void PlayerHandleYesNoInput(void) +static void PlayerHandleUnknownYesNoInput(void) { if (gMain.newKeys & DPAD_UP && gMultiUsePlayerCursor != 0) { @@ -1454,9 +1467,9 @@ void PlayerHandleYesNoInput(void) PlaySE(SE_SELECT); if (gMultiUsePlayerCursor != 0) - EmitChoiceReturnValue(1, 0xE, 0); + EmitTwoReturnValues(1, 0xE, 0); else - EmitChoiceReturnValue(1, 0xD, 0); + EmitTwoReturnValues(1, 0xD, 0); PlayerBufferExecCompleted(); } @@ -1468,10 +1481,7 @@ void PlayerHandleYesNoInput(void) } } -extern const u8 gText_MoveInterfacePP[]; -extern const u8 gText_MoveInterfaceType[]; - -void MoveSelectionDisplayMoveNames(void) +static void MoveSelectionDisplayMoveNames(void) { s32 i; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); @@ -1487,13 +1497,13 @@ void MoveSelectionDisplayMoveNames(void) } } -void MoveSelectionDisplayPpString(void) +static void MoveSelectionDisplayPpString(void) { StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); BattleHandleAddTextPrinter(gDisplayedStringBattle, 7); } -void MoveSelectionDisplayPpNumber(void) +static void MoveSelectionDisplayPpNumber(void) { u8 *txtPtr; struct ChooseMoveStruct *moveInfo; @@ -1511,9 +1521,7 @@ void MoveSelectionDisplayPpNumber(void) BattleHandleAddTextPrinter(gDisplayedStringBattle, 9); } -extern const u8 gTypeNames[][7]; - -void MoveSelectionDisplayMoveType(void) +static void MoveSelectionDisplayMoveType(void) { u8 *txtPtr; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); @@ -1530,7 +1538,7 @@ void MoveSelectionDisplayMoveType(void) BattleHandleAddTextPrinter(gDisplayedStringBattle, 10); } -void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) +static void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) { u16 src[2]; src[0] = arg1 + 1; @@ -1540,7 +1548,7 @@ void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1) CopyBgTilemapBufferToVram(0); } -void MoveSelectionDestroyCursorAt(u8 cursorPosition) +static void MoveSelectionDestroyCursorAt(u8 cursorPosition) { u16 src[2]; src[0] = 0x1016; @@ -1580,21 +1588,19 @@ void SetCB2ToReshowScreenAfterMenu2(void) SetMainCallback2(ReshowBattleScreenAfterMenu); } -void sub_8059D60(void) +static void CompleteOnFinishedStatusAnimation(void) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x10) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) PlayerBufferExecCompleted(); } -void sub_8059D90(void) +static void CompleteOnFinishedBattleAnimation(void) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x20) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) PlayerBufferExecCompleted(); } -extern const u8 gText_LinkStandby[]; - -void PrintLinkStandbyMsg(void) +static void PrintLinkStandbyMsg(void) { if (gBattleTypeFlags & BATTLE_TYPE_LINK) { @@ -1604,7 +1610,7 @@ void PrintLinkStandbyMsg(void) } } -void PlayerHandleGetMonData(void) +static void PlayerHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; @@ -1629,7 +1635,7 @@ void PlayerHandleGetMonData(void) PlayerBufferExecCompleted(); } -u32 CopyPlayerMonData(u8 monId, u8 *dst) +static u32 CopyPlayerMonData(u8 monId, u8 *dst) { struct BattlePokemon battleMon; struct MovePpInfo moveData; @@ -1949,7 +1955,7 @@ void PlayerHandleGetRawMonData(void) PlayerBufferExecCompleted(); } -void PlayerHandleSetMonData(void) +static void PlayerHandleSetMonData(void) { u8 monsToCheck; u8 i; @@ -1971,7 +1977,7 @@ void PlayerHandleSetMonData(void) PlayerBufferExecCompleted(); } -void SetPlayerMonData(u8 monId) +static void SetPlayerMonData(u8 monId) { struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; @@ -2189,7 +2195,7 @@ void SetPlayerMonData(u8 monId) sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); } -void PlayerHandleSetRawMonData(void) +static void PlayerHandleSetRawMonData(void) { u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; u8 i; @@ -2200,14 +2206,14 @@ void PlayerHandleSetRawMonData(void) PlayerBufferExecCompleted(); } -void PlayerHandleLoadMonSprite(void) +static void PlayerHandleLoadMonSprite(void) { BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; gBattleBankFunc[gActiveBank] = CompleteOnBankSpritePosX_0; } -void PlayerHandleSwitchInAnim(void) +static void PlayerHandleSwitchInAnim(void) { ClearTemporarySpeciesSpriteData(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; @@ -2218,16 +2224,7 @@ void PlayerHandleSwitchInAnim(void) gBattleBankFunc[gActiveBank] = sub_805902C; } -extern struct SpriteTemplate gUnknown_0202499C; -extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; - -extern u8 sub_80A5C6C(u16, u8); -extern u8 sub_80A6138(u8 bank); -extern u8 sub_80A82E4(u8 bank); -extern u8 sub_80753E8(u16, u8); -extern void sub_806A068(u16, u8); - -void sub_805B258(u8 bank, bool8 dontClearSubstituteBit) +static void sub_805B258(u8 bank, bool8 dontClearSubstituteBit) { u16 species; @@ -2258,12 +2255,12 @@ void sub_805B258(u8 bank, bool8 dontClearSubstituteBit) gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); } -void PlayerHandleReturnMonToBall(void) +static void PlayerHandleReturnMonToBall(void) { if (gBattleBufferA[gActiveBank][1] == 0) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; - gBattleBankFunc[gActiveBank] = sub_805B464; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; } else { @@ -2274,21 +2271,21 @@ void PlayerHandleReturnMonToBall(void) } } -void sub_805B464(void) +static void DoSwitchOutAnimation(void) { - switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4) + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) { case 0: if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 1; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; break; case 1: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); gBattleBankFunc[gActiveBank] = sub_8059744; } break; @@ -2306,14 +2303,10 @@ struct MonCoords extern const struct MonCoords gTrainerBackPicCoords[]; extern const struct MonCoords gTrainerFrontPicCoords[]; -extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; - -extern u16 gPartnerTrainerId; - // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it -void PlayerHandleDrawTrainerPic(void) +static void PlayerHandleDrawTrainerPic(void) { s16 xPos, yPos; u32 trainerPicId; @@ -2396,7 +2389,7 @@ void PlayerHandleDrawTrainerPic(void) gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; } -void PlayerHandleTrainerSlide(void) +static void PlayerHandleTrainerSlide(void) { u32 trainerPicId; @@ -2434,12 +2427,7 @@ void PlayerHandleTrainerSlide(void) gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; } -extern void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*spriteCallback)(struct Sprite*)); -extern void oamt_add_pos2_onto_pos1(struct Sprite *sprite); -extern void sub_80A6EEC(struct Sprite *sprite); -extern void sub_8039C00(struct Sprite *sprite); - -void PlayerHandleTrainerSlideBack(void) +static void PlayerHandleTrainerSlideBack(void) { oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; @@ -2451,19 +2439,19 @@ void PlayerHandleTrainerSlideBack(void) gBattleBankFunc[gActiveBank] = sub_80588B4; } -void PlayerHandleFaintAnimation(void) +static void PlayerHandleFaintAnimation(void) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 == 0) + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) { if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4++; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; } else { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); PlaySE12WithPanning(SE_POKE_DEAD, -64); gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; @@ -2474,31 +2462,31 @@ void PlayerHandleFaintAnimation(void) } } -void PlayerHandlePaletteFade(void) +static void PlayerHandlePaletteFade(void) { BeginNormalPaletteFade(-1, 2, 0, 16, 0); PlayerBufferExecCompleted(); } -void PlayerHandleCmd12(void) +static void PlayerHandleSuccessBallThrowAnim(void) { - gBattleSpritesDataPtr->animationData->field_8 = 4; + gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS; gDoingBattleAnim = TRUE; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), 3); - gBattleBankFunc[gActiveBank] = sub_805991C; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone; } -void PlayerHandleBallThrow(void) +static void PlayerHandleBallThrowAnim(void) { - u8 var = gBattleBufferA[gActiveBank][1]; + u8 ballThrowCaseId = gBattleBufferA[gActiveBank][1]; - gBattleSpritesDataPtr->animationData->field_8 = var; + gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId; gDoingBattleAnim = TRUE; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), 3); - gBattleBankFunc[gActiveBank] = sub_805991C; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone; } -void PlayerHandlePause(void) +static void PlayerHandlePause(void) { u8 var = gBattleBufferA[gActiveBank][1]; @@ -2509,12 +2497,7 @@ void PlayerHandlePause(void) PlayerBufferExecCompleted(); } -extern void sub_817E0FC(u16 move, u16 weatherFlags, struct DisableStruct *disableStructPtr); -extern bool8 mplay_80342A4(u8 bank); - -extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; - -void PlayerHandleMoveAnimation(void) +static void PlayerHandleMoveAnimation(void) { if (!mplay_80342A4(gActiveBank)) { @@ -2533,35 +2516,35 @@ void PlayerHandleMoveAnimation(void) } else { - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; gBattleBankFunc[gActiveBank] = PlayerDoMoveAnimation; sub_817E0FC(move, gWeatherMoveAnim, gAnimDisableStructPtr); } } } -void PlayerDoMoveAnimation(void) +static void PlayerDoMoveAnimation(void) { u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); u8 multihit = gBattleBufferA[gActiveBank][11]; - switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4) + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) { case 0: if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) { gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 1; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; break; case 1: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { sub_805EB9C(0); DoMoveAnim(move); - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 2; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; } break; case 2: @@ -2571,28 +2554,25 @@ void PlayerDoMoveAnimation(void) sub_805EB9C(1); if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; } - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 3; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; } break; case 3: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40) + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { sub_805E394(); TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_4 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; PlayerBufferExecCompleted(); } break; } } -extern void sub_817C95C(u16 stringId); -extern void sub_81A57E4(u8 bank, u16 stringId); - -void PlayerHandlePrintString(void) +static void PlayerHandlePrintString(void) { u16 *stringId; @@ -2606,7 +2586,7 @@ void PlayerHandlePrintString(void) sub_81A57E4(gActiveBank, *stringId); } -void PlayerHandlePrintStringPlayerOnly(void) +static void PlayerHandlePrintStringPlayerOnly(void) { if (GetBankSide(gActiveBank) == SIDE_PLAYER) PlayerHandlePrintString(); @@ -2614,7 +2594,7 @@ void PlayerHandlePrintStringPlayerOnly(void) PlayerBufferExecCompleted(); } -void HandleChooseActionAfterDma3(void) +static void HandleChooseActionAfterDma3(void) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -2624,12 +2604,7 @@ void HandleChooseActionAfterDma3(void) } } -extern void sub_817F2A8(void); -extern const u8 gText_BattleMenu[]; -extern const u8 gText_WhatWillPkmnDo[]; -extern const u8 gText_BattleYesNoChoice[]; - -void PlayerHandleChooseAction(void) +static void PlayerHandleChooseAction(void) { s32 i; @@ -2645,7 +2620,7 @@ void PlayerHandleChooseAction(void) BattleHandleAddTextPrinter(gDisplayedStringBattle, 1); } -void PlayerHandleCmd19(void) +static void PlayerHandleUnknownYesNoBox(void) { if (GetBankSide(gActiveBank) == SIDE_PLAYER) { @@ -2653,10 +2628,533 @@ void PlayerHandleCmd19(void) BattleHandleAddTextPrinter(gText_BattleYesNoChoice, 12); gMultiUsePlayerCursor = 1; BattleCreateYesNoCursorAt(1); - gBattleBankFunc[gActiveBank] = PlayerHandleYesNoInput; + gBattleBankFunc[gActiveBank] = PlayerHandleUnknownYesNoInput; + } + else + { + PlayerBufferExecCompleted(); + } +} + +static void HandleChooseMoveAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 320; + gBattleBankFunc[gActiveBank] = HandleInputChooseMove; + } +} + +static void PlayerChooseMoveInBattlePalace(void) +{ + if (--*(gBattleStruct->field_298 + gActiveBank) == 0) + { + gBattlePalaceMoveSelectionRngValue = gRngValue; + EmitTwoReturnValues(1, 10, ChooseMoveAndTargetInBattlePalace()); + PlayerBufferExecCompleted(); + } +} + +static void PlayerHandleChooseMove(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_PALACE) + { + *(gBattleStruct->field_298 + gActiveBank) = 8; + gBattleBankFunc[gActiveBank] = PlayerChooseMoveInBattlePalace; + } + else + { + InitMoveSelectionsVarsAndStrings(); + gBattleBankFunc[gActiveBank] = HandleChooseMoveAfterDma3; + } +} + +void InitMoveSelectionsVarsAndStrings(void) +{ + MoveSelectionDisplayMoveNames(); + gMultiUsePlayerCursor = 0xFF; + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0); + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); +} + +static void PlayerHandleChooseItem(void) +{ + s32 i; + + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gBattleBankFunc[gActiveBank] = sub_80598A4; + gBankInMenu = gActiveBank; + + for (i = 0; i < 3; i++) + gUnknown_0203CF00[i] = gBattleBufferA[gActiveBank][1 + i]; +} + +static void PlayerHandleChoosePokemon(void) +{ + s32 i; + + for (i = 0; i < 3; i++) + gUnknown_0203CF00[i] = gBattleBufferA[gActiveBank][4 + i]; + + if (gBattleTypeFlags & BATTLE_TYPE_ARENA && (gBattleBufferA[gActiveBank][1] & 0xF) != 2) + { + EmitChosenMonReturnValue(1, gBattlePartyID[gActiveBank] + 1, gUnknown_0203CF00); + PlayerBufferExecCompleted(); + } + else + { + gUnknown_03005D7C[gActiveBank] = CreateTask(TaskDummy, 0xFF); + gTasks[gUnknown_03005D7C[gActiveBank]].data[0] = gBattleBufferA[gActiveBank][1] & 0xF; + *(&gBattleStruct->field_49) = gBattleBufferA[gActiveBank][1] >> 4; + *(&gBattleStruct->field_8B) = gBattleBufferA[gActiveBank][2]; + *(&gBattleStruct->field_B0) = gBattleBufferA[gActiveBank][3]; + BeginNormalPaletteFade(-1, 0, 0, 16, 0); + gBattleBankFunc[gActiveBank] = sub_80597CC; + gBankInMenu = gActiveBank; + } +} + +static void PlayerHandleCmd23(void) +{ + BattleMusicStop(); + BeginNormalPaletteFade(-1, 2, 0, 16, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal > 0) + gUnknown_0203CD70 += hpVal; + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], 0, HP_CURRENT); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void PlayerHandleExpUpdate(void) +{ + u8 monId = gBattleBufferA[gActiveBank][1]; + + if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_MON_LEVEL) + { + PlayerBufferExecCompleted(); + } + else + { + s16 expPointsToGive; + u8 taskId; + + LoadBattleBarGfx(1); + GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); // unused return value + expPointsToGive = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + taskId = CreateTask(Task_GiveExpToMon, 10); + gTasks[taskId].tExpTask_monId = monId; + gTasks[taskId].tExpTask_gainedExp = expPointsToGive; + gTasks[taskId].tExpTask_bank = gActiveBank; + gBattleBankFunc[gActiveBank] = nullsub_21; + } +} + +#undef tExpTask_monId +#undef tExpTask_gainedExp +#undef tExpTask_bank +#undef tExpTask_frames + +static void PlayerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerHandleStatusXor(void) +{ + u8 val = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS) ^ gBattleBufferA[gActiveBank][1]; + + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS, &val); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleDataTransfer(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandleDMA3Transfer(void) +{ + u32 dstArg = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8) + | (gBattleBufferA[gActiveBank][3] << 16) + | (gBattleBufferA[gActiveBank][4] << 24); + u16 sizeArg = gBattleBufferA[gActiveBank][5] | (gBattleBufferA[gActiveBank][6] << 8); + + const u8 *src = &gBattleBufferA[gActiveBank][7]; + u8 *dst = (u8*)(dstArg); + u32 size = sizeArg; + + while (1) + { + if (size <= 0x1000) + { + DmaCopy16(3, src, dst, size); + break; + } + DmaCopy16(3, src, dst, 0x1000); + src += 0x1000; + dst += 0x1000; + size -= 0x1000; + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandlePlayBGM(void) +{ + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd32(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandleTwoReturnValues(void) +{ + EmitTwoReturnValues(1, 0, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleChosenMonReturnValue(void) +{ + EmitChosenMonReturnValue(1, 0, NULL); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleOneReturnValue(void) +{ + EmitOneReturnValue(1, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleOneReturnValue_Duplicate(void) +{ + EmitOneReturnValue_Duplicate(1, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + PlayerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = 1; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void PlayerHandleCmd42(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + PlayerBufferExecCompleted(); +} + +static void PlayerHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + PlayerBufferExecCompleted(); +} + +static void PlayerHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, -25, 5); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + gSprites[gBankSpriteIds[gActiveBank]].data5 = gActiveBank; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_805CC00); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + + paletteNum = AllocSpritePalette(0xD6F8); + LoadCompressedPalette(gTrainerBackPicPaletteTable[gSaveBlock2Ptr->playerGender].data, 0x100 + paletteNum * 16, 32); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = paletteNum; + + taskId = CreateTask(task05_08033660, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_21; +} + +void sub_805CC00(struct Sprite *sprite) +{ + u8 bank = sprite->data5; + + FreeSpriteOamMatrix(sprite); + FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); + DestroySprite(sprite); + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[bank]], bank); + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], 0); +} + +static void task05_08033660(u8 taskId) +{ + if (gTasks[taskId].data[1] < 31) + { + gTasks[taskId].data[1]++; } else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_805B258(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_805B258(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_805B258(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_8058B40; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +static void PlayerHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) { PlayerBufferExecCompleted(); } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_805CE38; + } +} + +static void sub_805CE38(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + PlayerBufferExecCompleted(); + } +} + +static void PlayerHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd50(void) +{ + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + PlayerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + + sub_817E32C(animationId); + } +} + +static void PlayerHandleLinkStandbyMsg(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][2]); + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + PrintLinkStandbyMsg(); + // fall through + case 1: + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + break; + case 2: + PrintLinkStandbyMsg(); + break; + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleResetActionMoveSelection(void) +{ + switch (gBattleBufferA[gActiveBank][1]) + { + case RESET_ACTION_MOVE_SELECTION: + gActionSelectionCursor[gActiveBank] = 0; + gMoveSelectionCursor[gActiveBank] = 0; + break; + case RESET_ACTION_SELECTION: + gActionSelectionCursor[gActiveBank] = 0; + break; + case RESET_MOVE_SELECTION: + gMoveSelectionCursor[gActiveBank] = 0; + break; + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd55(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][4]); + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + gSaveBlock2Ptr->field_CA9_b = gBattleBufferA[gActiveBank][2]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + PlayerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_22(void) +{ } diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 1086c6955..bf6962b1b 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -984,9 +984,9 @@ void EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data) void EmitLoadMonSprite(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE; - gBattleBuffersTransferData[1] = 4; - gBattleBuffersTransferData[2] = 4; - gBattleBuffersTransferData[3] = 4; + gBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE; + gBattleBuffersTransferData[2] = CONTROLLER_LOADMONSPRITE; + gBattleBuffersTransferData[3] = CONTROLLER_LOADMONSPRITE; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1009,27 +1009,27 @@ void EmitReturnMonToBall(u8 bufferId, u8 arg1) void EmitDrawTrainerPic(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC; - gBattleBuffersTransferData[1] = 7; - gBattleBuffersTransferData[2] = 7; - gBattleBuffersTransferData[3] = 7; + gBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC; + gBattleBuffersTransferData[2] = CONTROLLER_DRAWTRAINERPIC; + gBattleBuffersTransferData[3] = CONTROLLER_DRAWTRAINERPIC; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } void EmitTrainerSlide(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE; - gBattleBuffersTransferData[1] = 8; - gBattleBuffersTransferData[2] = 8; - gBattleBuffersTransferData[3] = 8; + gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE; + gBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDE; + gBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDE; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } void EmitTrainerSlideBack(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK; - gBattleBuffersTransferData[1] = 9; - gBattleBuffersTransferData[2] = 9; - gBattleBuffersTransferData[3] = 9; + gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK; + gBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDEBACK; + gBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDEBACK; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1051,18 +1051,18 @@ void EmitPaletteFade(u8 bufferId) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitCmd12(u8 bufferId) +void EmitSuccessBallThrowAnim(u8 bufferId) { - gBattleBuffersTransferData[0] = CONTROLLER_12; - gBattleBuffersTransferData[1] = 12; - gBattleBuffersTransferData[2] = 12; - gBattleBuffersTransferData[3] = 12; + gBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleBuffersTransferData[2] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleBuffersTransferData[3] = CONTROLLER_SUCCESSBALLTHROWANIM; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitBallThrow(u8 bufferId, u8 caseId) +void EmitBallThrowAnim(u8 bufferId, u8 caseId) { - gBattleBuffersTransferData[0] = CONTROLLER_BALLTHROW; + gBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM; gBattleBuffersTransferData[1] = caseId; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2); } @@ -1178,12 +1178,12 @@ void EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitYesNoBox(u8 bufferId) +void EmitUnknownYesNoBox(u8 bufferId) { - gBattleBuffersTransferData[0] = CONTROLLER_YESNOBOX; - gBattleBuffersTransferData[1] = CONTROLLER_YESNOBOX; - gBattleBuffersTransferData[2] = CONTROLLER_YESNOBOX; - gBattleBuffersTransferData[3] = CONTROLLER_YESNOBOX; + gBattleBuffersTransferData[0] = CONTROLLER_UNKNOWNYESNOBOX; + gBattleBuffersTransferData[1] = CONTROLLER_UNKNOWNYESNOBOX; + gBattleBuffersTransferData[2] = CONTROLLER_UNKNOWNYESNOBOX; + gBattleBuffersTransferData[3] = CONTROLLER_UNKNOWNYESNOBOX; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1200,7 +1200,7 @@ void EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(*movePpData) + 4); } -void EmitOpenBag(u8 bufferId, u8 *arg1) +void EmitChooseItem(u8 bufferId, u8 *arg1) { s32 i; @@ -1337,38 +1337,38 @@ void EmitCmd32(u8 bufferId, u16 size, void *data) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 3); } -void EmitChoiceReturnValue(u8 bufferId, u8 arg1, u16 arg2) +void EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2) { - gBattleBuffersTransferData[0] = CONTROLLER_CHOICERETURNVALUE; + gBattleBuffersTransferData[0] = CONTROLLER_TWORETURNVALUES; gBattleBuffersTransferData[1] = arg1; gBattleBuffersTransferData[2] = arg2; gBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitCmd34(u8 bufferId, u8 b, u8 *c) +void EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c) { s32 i; - gBattleBuffersTransferData[0] = CONTROLLER_34; + gBattleBuffersTransferData[0] = CONTROLLER_CHOSENMONRETURNVALUE; gBattleBuffersTransferData[1] = b; for (i = 0; i < 3; i++) gBattleBuffersTransferData[2 + i] = c[i]; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 5); } -void EmitCmd35(u8 bufferId, u16 b) +void EmitOneReturnValue(u8 bufferId, u16 arg1) { - gBattleBuffersTransferData[0] = CONTROLLER_35; - gBattleBuffersTransferData[1] = b; - gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; + gBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE; + gBattleBuffersTransferData[1] = arg1; + gBattleBuffersTransferData[2] = (arg1 & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitCmd36(u8 bufferId, u16 b) +void EmitOneReturnValue_Duplicate(u8 bufferId, u16 b) { - gBattleBuffersTransferData[0] = CONTROLLER_36; + gBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE; gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; @@ -1378,9 +1378,9 @@ void EmitCmd36(u8 bufferId, u16 b) void EmitCmd37(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_37; - gBattleBuffersTransferData[1] = 37; - gBattleBuffersTransferData[2] = 37; - gBattleBuffersTransferData[3] = 37; + gBattleBuffersTransferData[1] = CONTROLLER_37; + gBattleBuffersTransferData[2] = CONTROLLER_37; + gBattleBuffersTransferData[3] = CONTROLLER_37; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1394,27 +1394,27 @@ void EmitCmd38(u8 bufferId, u8 b) void EmitCmd39(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_39; - gBattleBuffersTransferData[1] = 39; - gBattleBuffersTransferData[2] = 39; - gBattleBuffersTransferData[3] = 39; + gBattleBuffersTransferData[1] = CONTROLLER_39; + gBattleBuffersTransferData[2] = CONTROLLER_39; + gBattleBuffersTransferData[3] = CONTROLLER_39; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } void EmitCmd40(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_40; - gBattleBuffersTransferData[1] = 40; - gBattleBuffersTransferData[2] = 40; - gBattleBuffersTransferData[3] = 40; + gBattleBuffersTransferData[1] = CONTROLLER_40; + gBattleBuffersTransferData[2] = CONTROLLER_40; + gBattleBuffersTransferData[3] = CONTROLLER_40; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } void EmitHitAnimation(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION; - gBattleBuffersTransferData[1] = 41; - gBattleBuffersTransferData[2] = 41; - gBattleBuffersTransferData[3] = 41; + gBattleBuffersTransferData[1] = CONTROLLER_HITANIMATION; + gBattleBuffersTransferData[2] = CONTROLLER_HITANIMATION; + gBattleBuffersTransferData[3] = CONTROLLER_HITANIMATION; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } diff --git a/src/battle_interface.c b/src/battle_interface.c index 2318517f5..5f582a366 100644 --- a/src/battle_interface.c +++ b/src/battle_interface.c @@ -21,17 +21,11 @@ #include "safari_zone.h" #include "battle_anim.h" -enum -{ - HEALTH_BAR, - EXP_BAR -}; - struct TestingBar { s32 maxValue; s32 currValue; - s32 field_8; + s32 receivedValue; u32 unkC_0:5; u32 unk10; }; @@ -183,7 +177,6 @@ extern const u16 gBattleInterface_BallDisplayPal[]; extern const u8 gHealthboxElementsGfxTable[][32]; // functions -extern bool8 IsDoubleBattle(void); extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor *color, s8 speed, const u8 *str); // menu.h extern void LoadBattleBarGfx(u8 arg0); @@ -214,10 +207,10 @@ static void SpriteCB_StatusSummaryBallsOnBattleStart(struct Sprite *sprite); static void SpriteCB_StatusSummaryBallsOnSwitchout(struct Sprite *sprite); static u8 GetStatusIconForBankId(u8 statusElementId, u8 bank); -static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4, u16 arg5); -static u8 GetScaledExpFraction(s32 currValue, s32 arg1, s32 maxValue, u8 scale); +static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 receivedValue, s32 *arg3, u8 arg4, u16 arg5); +static u8 GetScaledExpFraction(s32 currValue, s32 receivedValue, s32 maxValue, u8 scale); static void sub_8074B9C(u8 bank, u8 whichBar); -static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 *arg4, u8 arg5); +static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 receivedValue, s32 *arg3, u8 *arg4, u8 arg5); static void sub_8074F88(struct TestingBar *barInfo, s32 *arg1, u16 *arg2); // const rom data @@ -1049,12 +1042,12 @@ static void sub_8072924(struct Sprite *sprite) sprite->pos2.y = gSprites[otherSpriteId].pos2.y; } -void SetBattleBarStruct(u8 bank, u8 healthboxSpriteId, s32 maxVal, s32 currVal, s32 field_C) +void SetBattleBarStruct(u8 bank, u8 healthboxSpriteId, s32 maxVal, s32 currVal, s32 receivedValue) { gBattleSpritesDataPtr->battleBars[bank].healthboxSpriteId = healthboxSpriteId; gBattleSpritesDataPtr->battleBars[bank].maxValue = maxVal; gBattleSpritesDataPtr->battleBars[bank].currentValue = currVal; - gBattleSpritesDataPtr->battleBars[bank].field_C = field_C; + gBattleSpritesDataPtr->battleBars[bank].receivedValue = receivedValue; gBattleSpritesDataPtr->battleBars[bank].field_10 = -32768; } @@ -2262,22 +2255,22 @@ s32 sub_8074AA0(u8 bank, u8 healthboxSpriteId, u8 whichBar, u8 arg3) { var = sub_8074DB8(gBattleSpritesDataPtr->battleBars[bank].maxValue, gBattleSpritesDataPtr->battleBars[bank].currentValue, - gBattleSpritesDataPtr->battleBars[bank].field_C, + gBattleSpritesDataPtr->battleBars[bank].receivedValue, &gBattleSpritesDataPtr->battleBars[bank].field_10, 6, 1); } else // exp bar { u16 expFraction = GetScaledExpFraction(gBattleSpritesDataPtr->battleBars[bank].currentValue, - gBattleSpritesDataPtr->battleBars[bank].field_C, + gBattleSpritesDataPtr->battleBars[bank].receivedValue, gBattleSpritesDataPtr->battleBars[bank].maxValue, 8); if (expFraction == 0) expFraction = 1; - expFraction = abs(gBattleSpritesDataPtr->battleBars[bank].field_C / expFraction); + expFraction = abs(gBattleSpritesDataPtr->battleBars[bank].receivedValue / expFraction); var = sub_8074DB8(gBattleSpritesDataPtr->battleBars[bank].maxValue, gBattleSpritesDataPtr->battleBars[bank].currentValue, - gBattleSpritesDataPtr->battleBars[bank].field_C, + gBattleSpritesDataPtr->battleBars[bank].receivedValue, &gBattleSpritesDataPtr->battleBars[bank].field_10, 8, expFraction); } @@ -2293,7 +2286,7 @@ s32 sub_8074AA0(u8 bank, u8 healthboxSpriteId, u8 whichBar, u8 arg3) static void sub_8074B9C(u8 bank, u8 whichBar) { - u8 array[7]; + u8 array[8]; u8 subRet, level; u8 barElementId; u8 i; @@ -2303,7 +2296,7 @@ static void sub_8074B9C(u8 bank, u8 whichBar) case HEALTH_BAR: subRet = sub_8074E8C(gBattleSpritesDataPtr->battleBars[bank].maxValue, gBattleSpritesDataPtr->battleBars[bank].currentValue, - gBattleSpritesDataPtr->battleBars[bank].field_C, + gBattleSpritesDataPtr->battleBars[bank].receivedValue, &gBattleSpritesDataPtr->battleBars[bank].field_10, array, 6); barElementId = 3; @@ -2327,7 +2320,7 @@ static void sub_8074B9C(u8 bank, u8 whichBar) case EXP_BAR: sub_8074E8C(gBattleSpritesDataPtr->battleBars[bank].maxValue, gBattleSpritesDataPtr->battleBars[bank].currentValue, - gBattleSpritesDataPtr->battleBars[bank].field_C, + gBattleSpritesDataPtr->battleBars[bank].receivedValue, &gBattleSpritesDataPtr->battleBars[bank].field_10, array, 8); level = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_LEVEL); @@ -2349,7 +2342,7 @@ static void sub_8074B9C(u8 bank, u8 whichBar) } } -static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4, u16 arg5) +static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 receivedValue, s32 *arg3, u8 arg4, u16 arg5) { s32 r6; s32 ret; @@ -2363,7 +2356,7 @@ static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4 *arg3 = currValue; } - currValue -= arg2; + currValue -= receivedValue; if (currValue < 0) currValue = 0; else if (currValue > maxValue) @@ -2388,7 +2381,7 @@ static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4 { s32 var = (maxValue << 8) / arg4; - if (arg2 < 0) + if (receivedValue < 0) { *arg3 = r6 + var; ret = *arg3 >> 8; @@ -2413,7 +2406,7 @@ static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4 } else { - if (arg2 < 0) + if (receivedValue < 0) { *arg3 += arg5; if (*arg3 > currValue) @@ -2432,9 +2425,9 @@ static s32 sub_8074DB8(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 arg4 return ret; } -static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 arg2, s32 *arg3, u8 *arg4, u8 arg5) +static u8 sub_8074E8C(s32 maxValue, s32 currValue, s32 receivedValue, s32 *arg3, u8 *arg4, u8 arg5) { - s32 r5 = currValue - arg2; + s32 r5 = currValue - receivedValue; u8 ret; u8 i; u8 r2; @@ -2487,7 +2480,7 @@ static s16 sub_8074F28(struct TestingBar *barInfo, s32 *arg1, u16 *arg2, s32 arg ret = sub_8074DB8(barInfo->maxValue, barInfo->currValue, - barInfo->field_8, + barInfo->receivedValue, arg1, 6, 1); sub_8074F88(barInfo, arg1, arg2); @@ -2508,7 +2501,7 @@ static void sub_8074F88(struct TestingBar *barInfo, s32 *arg1, u16 *arg2) u8 i; sub_8074E8C(barInfo->maxValue, barInfo->currValue, - barInfo->field_8, arg1, sp8, 6); + barInfo->receivedValue, arg1, sp8, 6); for (i = 0; i < 6; i++) sp10[i] = (barInfo->unkC_0 << 12) | (barInfo->unk10 + sp8[i]); @@ -2516,13 +2509,13 @@ static void sub_8074F88(struct TestingBar *barInfo, s32 *arg1, u16 *arg2) CpuCopy16(sp10, arg2, sizeof(sp10)); } -static u8 GetScaledExpFraction(s32 currValue, s32 arg1, s32 maxValue, u8 scale) +static u8 GetScaledExpFraction(s32 currValue, s32 receivedValue, s32 maxValue, u8 scale) { s32 r5, result; s8 r4, r0; scale *= 8; - r5 = currValue - arg1; + r5 = currValue - receivedValue; if (r5 < 0) r5 = 0; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index a112cd7b9..b2afd9837 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -3625,7 +3625,7 @@ static void atk23_getexp(void) if (gBattleExecBuffer == 0) { gActiveBank = gBattleStruct->expGetterBank; - if (gBattleBufferB[gActiveBank][0] == 0x21 && gBattleBufferB[gActiveBank][1] == 0xB) + if (gBattleBufferB[gActiveBank][0] == CONTROLLER_TWORETURNVALUES && gBattleBufferB[gActiveBank][1] == RET_VALUE_LEVELLED_UP) { if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gBattlePartyID[gActiveBank] == gBattleStruct->expGetterId) sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); @@ -7137,7 +7137,7 @@ static void atk76_various(void) gDisableStructs[1].truantUnknownBit = 1; break; case VARIOUS_EMIT_YESNOBOX: - EmitYesNoBox(0); + EmitUnknownYesNoBox(0); MarkBufferBankForExecution(gActiveBank); break; case 14: @@ -7255,7 +7255,7 @@ static void atk78_faintifabilitynotdamp(void) { gActiveBank = gBankAttacker; gBattleMoveDamage = gBattleMons[gActiveBank].hp; - EmitHealthBarUpdate(0, 0x7FFF); + EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr++; @@ -10184,7 +10184,7 @@ static void atkC9_jumpifattackandspecialattackcannotfall(void) // memento { gActiveBank = gBankAttacker; gBattleMoveDamage = gBattleMons[gActiveBank].hp; - EmitHealthBarUpdate(0, 0x7FFF); + EmitHealthBarUpdate(0, INSTANT_HP_BAR_DROP); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 5; } @@ -11003,13 +11003,13 @@ static void atkEF_pokeball_catch_calculation(void) if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) { - EmitBallThrow(0, BALL_TRAINER_BLOCK); + EmitBallThrowAnim(0, BALL_TRAINER_BLOCK); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_TrainerBallBlock; } else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) { - EmitBallThrow(0, BALL_3_SHAKES_SUCCESS); + EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_WallyBallThrow; } @@ -11098,7 +11098,7 @@ static void atkEF_pokeball_catch_calculation(void) if (odds > 254) // mon caught { - EmitBallThrow(0, BALL_3_SHAKES_SUCCESS); + EmitBallThrowAnim(0, BALL_3_SHAKES_SUCCESS); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_SuccessBallThrow; SetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_POKEBALL, &gLastUsedItem); @@ -11120,7 +11120,7 @@ static void atkEF_pokeball_catch_calculation(void) if (gLastUsedItem == ITEM_MASTER_BALL) shakes = BALL_3_SHAKES_SUCCESS; // why calculate the shakes before that check? - EmitBallThrow(0, shakes); + EmitBallThrowAnim(0, shakes); MarkBufferBankForExecution(gActiveBank); if (shakes == BALL_3_SHAKES_SUCCESS) // mon caught, copy of the code above -- cgit v1.2.3 From 26c79313d86e056b70c758f775ecbadb206dbdbb Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 22 Oct 2017 20:38:23 +0200 Subject: safari controller is done --- src/battle_controller_player.c | 18 +- src/battle_controller_safari.c | 723 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 732 insertions(+), 9 deletions(-) create mode 100644 src/battle_controller_safari.c (limited to 'src') diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b41dbf0bc..b9ce93a89 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -154,7 +154,7 @@ static void MoveSelectionDisplayMoveNames(void); static void HandleMoveSwitchting(void); static void sub_8058FC0(void); static void sub_8059828(void); -static void sub_80598E0(void); +static void CompleteWhenChoseItem(void); static void sub_8059544(u8 taskId); static void Task_PrepareToGiveExpWithExpBar(u8 taskId); static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); @@ -297,16 +297,16 @@ static void HandleInputChooseAction(void) switch (gActionSelectionCursor[gActiveBank]) { - case ACTION_USE_MOVE: + case 0: EmitTwoReturnValues(1, ACTION_USE_MOVE, 0); break; - case ACTION_USE_ITEM: + case 1: EmitTwoReturnValues(1, ACTION_USE_ITEM, 0); break; - case ACTION_SWITCH: + case 2: EmitTwoReturnValues(1, ACTION_SWITCH, 0); break; - case ACTION_RUN: + case 3: EmitTwoReturnValues(1, ACTION_RUN, 0); break; } @@ -1400,18 +1400,18 @@ static void sub_8059828(void) } } -static void sub_80598A4(void) +static void OpenBagAndChooseItem(void) { if (!gPaletteFade.active) { - gBattleBankFunc[gActiveBank] = sub_80598E0; + gBattleBankFunc[gActiveBank] = CompleteWhenChoseItem; nullsub_35(); FreeAllWindowBuffers(); sub_81AABB0(); } } -static void sub_80598E0(void) +static void CompleteWhenChoseItem(void) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -2685,7 +2685,7 @@ static void PlayerHandleChooseItem(void) s32 i; BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); - gBattleBankFunc[gActiveBank] = sub_80598A4; + gBattleBankFunc[gActiveBank] = OpenBagAndChooseItem; gBankInMenu = gActiveBank; for (i = 0; i < 3; i++) diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c new file mode 100644 index 000000000..74210e629 --- /dev/null +++ b/src/battle_controller_safari.c @@ -0,0 +1,723 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u8 gBankInMenu; +extern u16 gUnknown_020243FC; + +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; + +extern const u8 gText_SafariZoneMenu[]; +extern const u8 gText_WhatWillPkmnDo2[]; + +extern void sub_81358F4(void); + +// this file's functions +static void SafariHandleGetMonData(void); +static void SafariHandleGetRawMonData(void); +static void SafariHandleSetMonData(void); +static void SafariHandleSetRawMonData(void); +static void SafariHandleLoadMonSprite(void); +static void SafariHandleSwitchInAnim(void); +static void SafariHandleReturnMonToBall(void); +static void SafariHandleDrawTrainerPic(void); +static void SafariHandleTrainerSlide(void); +static void SafariHandleTrainerSlideBack(void); +static void SafariHandleFaintAnimation(void); +static void SafariHandlePaletteFade(void); +static void SafariHandleSuccessBallThrowAnim(void); +static void SafariHandleBallThrowAnim(void); +static void SafariHandlePause(void); +static void SafariHandleMoveAnimation(void); +static void SafariHandlePrintString(void); +static void SafariHandlePrintStringPlayerOnly(void); +static void SafariHandleChooseAction(void); +static void SafariHandleUnknownYesNoBox(void); +static void SafariHandleChooseMove(void); +static void SafariHandleChooseItem(void); +static void SafariHandleChoosePokemon(void); +static void SafariHandleCmd23(void); +static void SafariHandleHealthBarUpdate(void); +static void SafariHandleExpUpdate(void); +static void SafariHandleStatusIconUpdate(void); +static void SafariHandleStatusAnimation(void); +static void SafariHandleStatusXor(void); +static void SafariHandleDataTransfer(void); +static void SafariHandleDMA3Transfer(void); +static void SafariHandlePlayBGM(void); +static void SafariHandleCmd32(void); +static void SafariHandleTwoReturnValues(void); +static void SafariHandleChosenMonReturnValue(void); +static void SafariHandleOneReturnValue(void); +static void SafariHandleOneReturnValue_Duplicate(void); +static void SafariHandleCmd37(void); +static void SafariHandleCmd38(void); +static void SafariHandleCmd39(void); +static void SafariHandleCmd40(void); +static void SafariHandleHitAnimation(void); +static void SafariHandleCmd42(void); +static void SafariHandleEffectivenessSound(void); +static void SafariHandlePlayFanfareOrBGM(void); +static void SafariHandleFaintingCry(void); +static void SafariHandleIntroSlide(void); +static void SafariHandleIntroTrainerBallThrow(void); +static void SafariHandleDrawPartyStatusSummary(void); +static void SafariHandleCmd49(void); +static void SafariHandleCmd50(void); +static void SafariHandleSpriteInvisibility(void); +static void SafariHandleBattleAnimation(void); +static void SafariHandleLinkStandbyMsg(void); +static void SafariHandleResetActionMoveSelection(void); +static void SafariHandleCmd55(void); +static void nullsub_115(void); + +static void SafariBufferRunCommand(void); +static void SafariBufferExecCompleted(void); +static void CompleteWhenChosePokeblock(void); + +static void (*const gSafariBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + SafariHandleGetMonData, + SafariHandleGetRawMonData, + SafariHandleSetMonData, + SafariHandleSetRawMonData, + SafariHandleLoadMonSprite, + SafariHandleSwitchInAnim, + SafariHandleReturnMonToBall, + SafariHandleDrawTrainerPic, + SafariHandleTrainerSlide, + SafariHandleTrainerSlideBack, + SafariHandleFaintAnimation, + SafariHandlePaletteFade, + SafariHandleSuccessBallThrowAnim, + SafariHandleBallThrowAnim, + SafariHandlePause, + SafariHandleMoveAnimation, + SafariHandlePrintString, + SafariHandlePrintStringPlayerOnly, + SafariHandleChooseAction, + SafariHandleUnknownYesNoBox, + SafariHandleChooseMove, + SafariHandleChooseItem, + SafariHandleChoosePokemon, + SafariHandleCmd23, + SafariHandleHealthBarUpdate, + SafariHandleExpUpdate, + SafariHandleStatusIconUpdate, + SafariHandleStatusAnimation, + SafariHandleStatusXor, + SafariHandleDataTransfer, + SafariHandleDMA3Transfer, + SafariHandlePlayBGM, + SafariHandleCmd32, + SafariHandleTwoReturnValues, + SafariHandleChosenMonReturnValue, + SafariHandleOneReturnValue, + SafariHandleOneReturnValue_Duplicate, + SafariHandleCmd37, + SafariHandleCmd38, + SafariHandleCmd39, + SafariHandleCmd40, + SafariHandleHitAnimation, + SafariHandleCmd42, + SafariHandleEffectivenessSound, + SafariHandlePlayFanfareOrBGM, + SafariHandleFaintingCry, + SafariHandleIntroSlide, + SafariHandleIntroTrainerBallThrow, + SafariHandleDrawPartyStatusSummary, + SafariHandleCmd49, + SafariHandleCmd50, + SafariHandleSpriteInvisibility, + SafariHandleBattleAnimation, + SafariHandleLinkStandbyMsg, + SafariHandleResetActionMoveSelection, + SafariHandleCmd55, + nullsub_115 +}; + +static void nullsub_114(void) +{ +} + +void SetBankFuncToSafariBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = SafariBufferRunCommand; +} + +static void SafariBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gSafariBufferCommands)) + gSafariBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + SafariBufferExecCompleted(); + } +} + +static void HandleInputChooseAction(void) +{ + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + + switch (gActionSelectionCursor[gActiveBank]) + { + case 0: + EmitTwoReturnValues(1, ACTION_SAFARI_ZONE_BALL, 0); + break; + case 1: + EmitTwoReturnValues(1, ACTION_POKEBLOCK_CASE, 0); + break; + case 2: + EmitTwoReturnValues(1, ACTION_GO_NEAR, 0); + break; + case 3: + EmitTwoReturnValues(1, ACTION_SAFARI_ZONE_RUN, 0); + break; + } + SafariBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gActionSelectionCursor[gActiveBank] & 1) + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gActionSelectionCursor[gActiveBank] & 1)) + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gActionSelectionCursor[gActiveBank] & 2) + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gActionSelectionCursor[gActiveBank] & 2)) + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + } + } +} + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + SafariBufferExecCompleted(); +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + SafariBufferExecCompleted(); +} + +static void CompleteOnHealthboxSpriteCallbackDummy(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + SafariBufferExecCompleted(); +} + +static void sub_81595E4(void) +{ + if (!gPaletteFade.active) + { + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } +} + +static void CompleteOnSpecialAnimDone(void) +{ + if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + SafariBufferExecCompleted(); +} + +static void OpenPokeblockCase(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = CompleteWhenChosePokeblock; + FreeAllWindowBuffers(); + sub_81358F4(); + } +} + +static void CompleteWhenChosePokeblock(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + EmitOneReturnValue(1, gScriptItemId); + SafariBufferExecCompleted(); + } +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + SafariBufferExecCompleted(); +} + +static void SafariBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = SafariBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + SafariBufferExecCompleted(); +} + +static void SafariHandleGetMonData(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleGetRawMonData(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleSetMonData(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleSetRawMonData(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleLoadMonSprite(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleSwitchInAnim(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleReturnMonToBall(void) +{ + SafariBufferExecCompleted(); +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; + +static void SafariHandleDrawTrainerPic(void) +{ + DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, gActiveBank); + sub_806A12C(gSaveBlock2Ptr->playerGender, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite( + &gUnknown_0202499C, + 80, + (8 - gTrainerBackPicCoords[gSaveBlock2Ptr->playerGender].coords) * 4 + 80, + 30); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void SafariHandleTrainerSlide(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleTrainerSlideBack(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleFaintAnimation(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandlePaletteFade(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleSuccessBallThrowAnim(void) +{ + gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS; + gDoingBattleAnim = TRUE; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone; +} + +static void SafariHandleBallThrowAnim(void) +{ + u8 ballThrowCaseId = gBattleBufferA[gActiveBank][1]; + + gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId; + gDoingBattleAnim = TRUE; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnSpecialAnimDone; +} + +static void SafariHandlePause(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleMoveAnimation(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; +} + +static void SafariHandlePrintStringPlayerOnly(void) +{ + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + SafariHandlePrintString(); + else + SafariBufferExecCompleted(); +} + +static void HandleChooseActionAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 160; + gBattleBankFunc[gActiveBank] = HandleInputChooseAction; + } +} + +static void SafariHandleChooseAction(void) +{ + s32 i; + + gBattleBankFunc[gActiveBank] = HandleChooseActionAfterDma3; + BattleHandleAddTextPrinter(gText_SafariZoneMenu, 2); + + for (i = 0; i < 4; i++) + ActionSelectionDestroyCursorAt(i); + + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo2); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 1); +} + +static void SafariHandleUnknownYesNoBox(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleChooseMove(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleChooseItem(void) +{ + s32 i; + + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gBattleBankFunc[gActiveBank] = OpenPokeblockCase; + gBankInMenu = gActiveBank; +} + +static void SafariHandleChoosePokemon(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd23(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleHealthBarUpdate(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleExpUpdate(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleStatusIconUpdate(void) +{ + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_SAFARI_BALLS_TEXT); + SafariBufferExecCompleted(); +} + +static void SafariHandleStatusAnimation(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleStatusXor(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleDataTransfer(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleDMA3Transfer(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandlePlayBGM(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd32(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleTwoReturnValues(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleChosenMonReturnValue(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleOneReturnValue(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleOneReturnValue_Duplicate(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd37(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd38(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd39(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd40(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleHitAnimation(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd42(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + SafariBufferExecCompleted(); +} + +static void SafariHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + SafariBufferExecCompleted(); +} + +static void SafariHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry1(species, 25); + SafariBufferExecCompleted(); +} + +static void SafariHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + SafariBufferExecCompleted(); +} + +static void SafariHandleIntroTrainerBallThrow(void) +{ + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_SAFARI_ALL_TEXT); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + gBattleBankFunc[gActiveBank] = CompleteOnHealthboxSpriteCallbackDummy; +} + +static void SafariHandleDrawPartyStatusSummary(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd49(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd50(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleSpriteInvisibility(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleBattleAnimation(void) +{ + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + SafariBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; +} + +static void SafariHandleLinkStandbyMsg(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleResetActionMoveSelection(void) +{ + SafariBufferExecCompleted(); +} + +static void SafariHandleCmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + SafariBufferExecCompleted(); + if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) + gBattleBankFunc[gActiveBank] = sub_81595E4; +} + +static void nullsub_115(void) +{ +} -- cgit v1.2.3 From 21f499592201ac4474c365a2b6b2ab1f2b173abc Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 22 Oct 2017 20:49:21 +0200 Subject: start player partner controller --- src/battle_controller_player_partner.c | 198 +++++++++++++++++++++++++++++++++ 1 file changed, 198 insertions(+) create mode 100644 src/battle_controller_player_partner.c (limited to 'src') diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c new file mode 100644 index 000000000..009de472f --- /dev/null +++ b/src/battle_controller_player_partner.c @@ -0,0 +1,198 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u8 gBankInMenu; +extern u16 gUnknown_020243FC; + +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; + +extern void sub_81358F4(void); + +// this file's functions +void PlayerPartnerHandleGetMonData(void); +void PlayerPartnerHandleGetRawMonData(void); +void PlayerPartnerHandleSetMonData(void); +void PlayerPartnerHandleSetRawMonData(void); +void PlayerPartnerHandleLoadMonSprite(void); +void PlayerPartnerHandleSwitchInAnim(void); +void PlayerPartnerHandleReturnMonToBall(void); +void PlayerPartnerHandleDrawTrainerPic(void); +void PlayerPartnerHandleTrainerSlide(void); +void PlayerPartnerHandleTrainerSlideBack(void); +void PlayerPartnerHandleFaintAnimation(void); +void PlayerPartnerHandlePaletteFade(void); +void PlayerPartnerHandleSuccessBallThrowAnim(void); +void PlayerPartnerHandleBallThrowAnim(void); +void PlayerPartnerHandlePause(void); +void PlayerPartnerHandleMoveAnimation(void); +void PlayerPartnerHandlePrintString(void); +void PlayerPartnerHandlePrintStringPlayerOnly(void); +void PlayerPartnerHandleChooseAction(void); +void PlayerPartnerHandleUnknownYesNoBox(void); +void PlayerPartnerHandleChooseMove(void); +void PlayerPartnerHandleChooseItem(void); +void PlayerPartnerHandleChoosePokemon(void); +void PlayerPartnerHandleCmd23(void); +void PlayerPartnerHandleHealthBarUpdate(void); +void PlayerPartnerHandleExpUpdate(void); +void PlayerPartnerHandleStatusIconUpdate(void); +void PlayerPartnerHandleStatusAnimation(void); +void PlayerPartnerHandleStatusXor(void); +void PlayerPartnerHandleDataTransfer(void); +void PlayerPartnerHandleDMA3Transfer(void); +void PlayerPartnerHandlePlayBGM(void); +void PlayerPartnerHandleCmd32(void); +void PlayerPartnerHandleTwoReturnValues(void); +void PlayerPartnerHandleChosenMonReturnValue(void); +void PlayerPartnerHandleOneReturnValue(void); +void PlayerPartnerHandleOneReturnValue_Duplicate(void); +void PlayerPartnerHandleCmd37(void); +void PlayerPartnerHandleCmd38(void); +void PlayerPartnerHandleCmd39(void); +void PlayerPartnerHandleCmd40(void); +void PlayerPartnerHandleHitAnimation(void); +void PlayerPartnerHandleCmd42(void); +void PlayerPartnerHandleEffectivenessSound(void); +void PlayerPartnerHandlePlayFanfareOrBGM(void); +void PlayerPartnerHandleFaintingCry(void); +void PlayerPartnerHandleIntroSlide(void); +void PlayerPartnerHandleIntroTrainerBallThrow(void); +void PlayerPartnerHandleDrawPartyStatusSummary(void); +void PlayerPartnerHandleCmd49(void); +void PlayerPartnerHandleCmd50(void); +void PlayerPartnerHandleSpriteInvisibility(void); +void PlayerPartnerHandleBattleAnimation(void); +void PlayerPartnerHandleLinkStandbyMsg(void); +void PlayerPartnerHandleResetActionMoveSelection(void); +void PlayerPartnerHandleCmd55(void); +void nullsub_128(void); + +void PlayerPartnerBufferRunCommand(void); +void PlayerPartnerBufferExecCompleted(void); + +void (*const gPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + PlayerPartnerHandleGetMonData, + PlayerPartnerHandleGetRawMonData, + PlayerPartnerHandleSetMonData, + PlayerPartnerHandleSetRawMonData, + PlayerPartnerHandleLoadMonSprite, + PlayerPartnerHandleSwitchInAnim, + PlayerPartnerHandleReturnMonToBall, + PlayerPartnerHandleDrawTrainerPic, + PlayerPartnerHandleTrainerSlide, + PlayerPartnerHandleTrainerSlideBack, + PlayerPartnerHandleFaintAnimation, + PlayerPartnerHandlePaletteFade, + PlayerPartnerHandleSuccessBallThrowAnim, + PlayerPartnerHandleBallThrowAnim, + PlayerPartnerHandlePause, + PlayerPartnerHandleMoveAnimation, + PlayerPartnerHandlePrintString, + PlayerPartnerHandlePrintStringPlayerOnly, + PlayerPartnerHandleChooseAction, + PlayerPartnerHandleUnknownYesNoBox, + PlayerPartnerHandleChooseMove, + PlayerPartnerHandleChooseItem, + PlayerPartnerHandleChoosePokemon, + PlayerPartnerHandleCmd23, + PlayerPartnerHandleHealthBarUpdate, + PlayerPartnerHandleExpUpdate, + PlayerPartnerHandleStatusIconUpdate, + PlayerPartnerHandleStatusAnimation, + PlayerPartnerHandleStatusXor, + PlayerPartnerHandleDataTransfer, + PlayerPartnerHandleDMA3Transfer, + PlayerPartnerHandlePlayBGM, + PlayerPartnerHandleCmd32, + PlayerPartnerHandleTwoReturnValues, + PlayerPartnerHandleChosenMonReturnValue, + PlayerPartnerHandleOneReturnValue, + PlayerPartnerHandleOneReturnValue_Duplicate, + PlayerPartnerHandleCmd37, + PlayerPartnerHandleCmd38, + PlayerPartnerHandleCmd39, + PlayerPartnerHandleCmd40, + PlayerPartnerHandleHitAnimation, + PlayerPartnerHandleCmd42, + PlayerPartnerHandleEffectivenessSound, + PlayerPartnerHandlePlayFanfareOrBGM, + PlayerPartnerHandleFaintingCry, + PlayerPartnerHandleIntroSlide, + PlayerPartnerHandleIntroTrainerBallThrow, + PlayerPartnerHandleDrawPartyStatusSummary, + PlayerPartnerHandleCmd49, + PlayerPartnerHandleCmd50, + PlayerPartnerHandleSpriteInvisibility, + PlayerPartnerHandleBattleAnimation, + PlayerPartnerHandleLinkStandbyMsg, + PlayerPartnerHandleResetActionMoveSelection, + PlayerPartnerHandleCmd55, + nullsub_128 +}; + +// unknown unused data +static const u8 gUnknown_08617254[] = +{ + 0x83, 0x4d, 0xf3, 0x5f, 0x6f, 0x4f, 0xeb, 0x3e, + 0x67, 0x2e, 0x10, 0x46, 0x8c, 0x3d, 0x28, 0x35, + 0xc5, 0x2c, 0x15, 0x7f, 0xb5, 0x56, 0x9d, 0x53, + 0x3b, 0x43, 0xda, 0x36, 0x79, 0x2a, 0x0e, 0x53, +}; + +void nullsub_77(void) +{ +} + +void SetBankFuncToPlayerPartnerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = PlayerPartnerBufferRunCommand; +} + +void PlayerPartnerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gPlayerPartnerBufferCommands)) + gPlayerPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + PlayerPartnerBufferExecCompleted(); + } +} + -- cgit v1.2.3 From a8ea415c81d72a5057f185885512f69405106691 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 11:07:36 +0200 Subject: player partner controller is done --- src/battle_controller_player_partner.c | 1900 ++++++++++++++++++++++++++++++-- 1 file changed, 1836 insertions(+), 64 deletions(-) (limited to 'src') diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 009de472f..b7479c3cc 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -4,6 +4,7 @@ #include "battle_message.h" #include "battle_interface.h" #include "battle_anim.h" +#include "battle_ai_script_commands.h" #include "pokemon.h" #include "link.h" #include "util.h" @@ -15,6 +16,7 @@ #include "palette.h" #include "task.h" #include "text.h" +#include "string_util.h" #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" @@ -39,74 +41,101 @@ extern u16 gBattle_BG0_X; extern u16 gBattle_BG0_Y; extern u8 gBankInMenu; extern u16 gUnknown_020243FC; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gPartnerTrainerId; +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_020244B4[]; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern struct UnusedControllerStruct gUnknown_02022D0C; +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; extern void sub_81358F4(void); +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); // this file's functions -void PlayerPartnerHandleGetMonData(void); -void PlayerPartnerHandleGetRawMonData(void); -void PlayerPartnerHandleSetMonData(void); -void PlayerPartnerHandleSetRawMonData(void); -void PlayerPartnerHandleLoadMonSprite(void); -void PlayerPartnerHandleSwitchInAnim(void); -void PlayerPartnerHandleReturnMonToBall(void); -void PlayerPartnerHandleDrawTrainerPic(void); -void PlayerPartnerHandleTrainerSlide(void); -void PlayerPartnerHandleTrainerSlideBack(void); -void PlayerPartnerHandleFaintAnimation(void); -void PlayerPartnerHandlePaletteFade(void); -void PlayerPartnerHandleSuccessBallThrowAnim(void); -void PlayerPartnerHandleBallThrowAnim(void); -void PlayerPartnerHandlePause(void); -void PlayerPartnerHandleMoveAnimation(void); -void PlayerPartnerHandlePrintString(void); -void PlayerPartnerHandlePrintStringPlayerOnly(void); -void PlayerPartnerHandleChooseAction(void); -void PlayerPartnerHandleUnknownYesNoBox(void); -void PlayerPartnerHandleChooseMove(void); -void PlayerPartnerHandleChooseItem(void); -void PlayerPartnerHandleChoosePokemon(void); -void PlayerPartnerHandleCmd23(void); -void PlayerPartnerHandleHealthBarUpdate(void); -void PlayerPartnerHandleExpUpdate(void); -void PlayerPartnerHandleStatusIconUpdate(void); -void PlayerPartnerHandleStatusAnimation(void); -void PlayerPartnerHandleStatusXor(void); -void PlayerPartnerHandleDataTransfer(void); -void PlayerPartnerHandleDMA3Transfer(void); -void PlayerPartnerHandlePlayBGM(void); -void PlayerPartnerHandleCmd32(void); -void PlayerPartnerHandleTwoReturnValues(void); -void PlayerPartnerHandleChosenMonReturnValue(void); -void PlayerPartnerHandleOneReturnValue(void); -void PlayerPartnerHandleOneReturnValue_Duplicate(void); -void PlayerPartnerHandleCmd37(void); -void PlayerPartnerHandleCmd38(void); -void PlayerPartnerHandleCmd39(void); -void PlayerPartnerHandleCmd40(void); -void PlayerPartnerHandleHitAnimation(void); -void PlayerPartnerHandleCmd42(void); -void PlayerPartnerHandleEffectivenessSound(void); -void PlayerPartnerHandlePlayFanfareOrBGM(void); -void PlayerPartnerHandleFaintingCry(void); -void PlayerPartnerHandleIntroSlide(void); -void PlayerPartnerHandleIntroTrainerBallThrow(void); -void PlayerPartnerHandleDrawPartyStatusSummary(void); -void PlayerPartnerHandleCmd49(void); -void PlayerPartnerHandleCmd50(void); -void PlayerPartnerHandleSpriteInvisibility(void); -void PlayerPartnerHandleBattleAnimation(void); -void PlayerPartnerHandleLinkStandbyMsg(void); -void PlayerPartnerHandleResetActionMoveSelection(void); -void PlayerPartnerHandleCmd55(void); -void nullsub_128(void); - -void PlayerPartnerBufferRunCommand(void); -void PlayerPartnerBufferExecCompleted(void); - -void (*const gPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void PlayerPartnerHandleGetMonData(void); +static void PlayerPartnerHandleGetRawMonData(void); +static void PlayerPartnerHandleSetMonData(void); +static void PlayerPartnerHandleSetRawMonData(void); +static void PlayerPartnerHandleLoadMonSprite(void); +static void PlayerPartnerHandleSwitchInAnim(void); +static void PlayerPartnerHandleReturnMonToBall(void); +static void PlayerPartnerHandleDrawTrainerPic(void); +static void PlayerPartnerHandleTrainerSlide(void); +static void PlayerPartnerHandleTrainerSlideBack(void); +static void PlayerPartnerHandleFaintAnimation(void); +static void PlayerPartnerHandlePaletteFade(void); +static void PlayerPartnerHandleSuccessBallThrowAnim(void); +static void PlayerPartnerHandleBallThrowAnim(void); +static void PlayerPartnerHandlePause(void); +static void PlayerPartnerHandleMoveAnimation(void); +static void PlayerPartnerHandlePrintString(void); +static void PlayerPartnerHandlePrintStringPlayerOnly(void); +static void PlayerPartnerHandleChooseAction(void); +static void PlayerPartnerHandleUnknownYesNoBox(void); +static void PlayerPartnerHandleChooseMove(void); +static void PlayerPartnerHandleChooseItem(void); +static void PlayerPartnerHandleChoosePokemon(void); +static void PlayerPartnerHandleCmd23(void); +static void PlayerPartnerHandleHealthBarUpdate(void); +static void PlayerPartnerHandleExpUpdate(void); +static void PlayerPartnerHandleStatusIconUpdate(void); +static void PlayerPartnerHandleStatusAnimation(void); +static void PlayerPartnerHandleStatusXor(void); +static void PlayerPartnerHandleDataTransfer(void); +static void PlayerPartnerHandleDMA3Transfer(void); +static void PlayerPartnerHandlePlayBGM(void); +static void PlayerPartnerHandleCmd32(void); +static void PlayerPartnerHandleTwoReturnValues(void); +static void PlayerPartnerHandleChosenMonReturnValue(void); +static void PlayerPartnerHandleOneReturnValue(void); +static void PlayerPartnerHandleOneReturnValue_Duplicate(void); +static void PlayerPartnerHandleCmd37(void); +static void PlayerPartnerHandleCmd38(void); +static void PlayerPartnerHandleCmd39(void); +static void PlayerPartnerHandleCmd40(void); +static void PlayerPartnerHandleHitAnimation(void); +static void PlayerPartnerHandleCmd42(void); +static void PlayerPartnerHandleEffectivenessSound(void); +static void PlayerPartnerHandlePlayFanfareOrBGM(void); +static void PlayerPartnerHandleFaintingCry(void); +static void PlayerPartnerHandleIntroSlide(void); +static void PlayerPartnerHandleIntroTrainerBallThrow(void); +static void PlayerPartnerHandleDrawPartyStatusSummary(void); +static void PlayerPartnerHandleCmd49(void); +static void PlayerPartnerHandleCmd50(void); +static void PlayerPartnerHandleSpriteInvisibility(void); +static void PlayerPartnerHandleBattleAnimation(void); +static void PlayerPartnerHandleLinkStandbyMsg(void); +static void PlayerPartnerHandleResetActionMoveSelection(void); +static void PlayerPartnerHandleCmd55(void); +static void nullsub_128(void); + +static void PlayerPartnerBufferRunCommand(void); +static void PlayerPartnerBufferExecCompleted(void); +static void sub_81BB628(u8 taskId); +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); +static void Task_PrepareToGiveExpWithExpBar(u8 taskId); +static void sub_81BB4E4(u8 taskId); +static void sub_81BB628(u8 taskId); +static void sub_81BB688(u8 taskId); +static void sub_81BB9A0(void); +static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst); +static void SetPlayerPartnerMonData(u8 monId); +static void sub_81BD0E4(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void PlayerPartnerDoMoveAnimation(void); +static void sub_81BE2C8(u8 taskId); +static void sub_81BE498(void); + +static void (*const gPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { PlayerPartnerHandleGetMonData, PlayerPartnerHandleGetRawMonData, @@ -176,7 +205,7 @@ static const u8 gUnknown_08617254[] = 0x3b, 0x43, 0xda, 0x36, 0x79, 0x2a, 0x0e, 0x53, }; -void nullsub_77(void) +static void nullsub_77(void) { } @@ -185,7 +214,7 @@ void SetBankFuncToPlayerPartnerBufferRunCommand(void) gBattleBankFunc[gActiveBank] = PlayerPartnerBufferRunCommand; } -void PlayerPartnerBufferRunCommand(void) +static void PlayerPartnerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { @@ -196,3 +225,1746 @@ void PlayerPartnerBufferRunCommand(void) } } +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + PlayerPartnerBufferExecCompleted(); +} + +static void sub_81BAE98(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_25(0); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + PlayerPartnerBufferExecCompleted(); + } +} + +static void sub_81BAF00(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + PlayerPartnerBufferExecCompleted(); + } +} + +static void sub_81BAF48(void) +{ + bool32 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r6 = TRUE; + } + } + + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_81BAF00; + } +} + +static void sub_81BB02C(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8 + && gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && ++gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 != 1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + + gBattleBankFunc[gActiveBank] = sub_81BAF48; + } +} + +static void sub_81BB1D4(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].animEnded && gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + PlayerPartnerBufferExecCompleted(); +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerPartnerBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + PlayerPartnerBufferExecCompleted(); +} + +// the whole exp task is copied&pasted from player controller +#define tExpTask_monId data[0] +#define tExpTask_gainedExp data[1] +#define tExpTask_bank data[2] +#define tExpTask_frames data[10] + +static void Task_GiveExpToMon(u8 taskId) +{ + u32 monId = (u8)(gTasks[taskId].tExpTask_monId); + u8 bank = gTasks[taskId].tExpTask_bank; + s16 gainedExp = gTasks[taskId].tExpTask_gainedExp; + + if (IsDoubleBattle() == TRUE || monId != gBattlePartyID[bank]) // give exp without the expbar + { + struct Pokemon *mon = &gPlayerParty[monId]; + u16 species = GetMonData(mon, MON_DATA_SPECIES); + u8 level = GetMonData(mon, MON_DATA_LEVEL); + u32 currExp = GetMonData(mon, MON_DATA_EXP); + u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= nextLvlExp) + { + u8 savedActiveBank; + + SetMonData(mon, MON_DATA_EXP, &nextLvlExp); + CalculateMonStats(mon); + gainedExp -= nextLvlExp - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + EmitTwoReturnValues(1, RET_VALUE_LEVELLED_UP, gainedExp); + gActiveBank = savedActiveBank; + + if (IsDoubleBattle() == TRUE + && ((u16)(monId) == gBattlePartyID[bank] || (u16)(monId) == gBattlePartyID[bank ^ BIT_MON])) + gTasks[taskId].func = sub_81BB628; + else + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } + else + { + currExp += gainedExp; + SetMonData(mon, MON_DATA_EXP, &currExp); + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } + } + else + { + gTasks[taskId].func = Task_PrepareToGiveExpWithExpBar; + } +} + +static void Task_PrepareToGiveExpWithExpBar(u8 taskId) +{ + u8 monIndex = gTasks[taskId].tExpTask_monId; + s32 gainedExp = gTasks[taskId].tExpTask_gainedExp; + u8 bank = gTasks[taskId].tExpTask_bank; + struct Pokemon *mon = &gPlayerParty[monIndex]; + u8 level = GetMonData(mon, MON_DATA_LEVEL); + u16 species = GetMonData(mon, MON_DATA_SPECIES); + u32 exp = GetMonData(mon, MON_DATA_EXP); + u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level]; + u32 expToNextLvl; + + exp -= currLvlExp; + expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp; + SetBattleBarStruct(bank, gHealthBoxesIds[bank], expToNextLvl, exp, -gainedExp); + PlaySE(SE_EXP); + gTasks[taskId].func = sub_81BB4E4; +} + +static void sub_81BB4E4(u8 taskId) +{ + if (gTasks[taskId].tExpTask_frames < 13) + { + gTasks[taskId].tExpTask_frames++; + } + else + { + u8 monId = gTasks[taskId].tExpTask_monId; + s16 gainedExp = gTasks[taskId].tExpTask_gainedExp; + u8 bank = gTasks[taskId].tExpTask_bank; + s16 r4; + + r4 = sub_8074AA0(bank, gHealthBoxesIds[bank], EXP_BAR, 0); + SetHealthboxSpriteVisible(gHealthBoxesIds[bank]); + if (r4 == -1) + { + u8 level; + s32 currExp; + u16 species; + s32 expOnNextLvl; + + m4aSongNumStop(SE_EXP); + level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + currExp = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + expOnNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= expOnNextLvl) + { + u8 savedActiveBank; + + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &expOnNextLvl); + CalculateMonStats(&gPlayerParty[monId]); + gainedExp -= expOnNextLvl - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + EmitTwoReturnValues(1, RET_VALUE_LEVELLED_UP, gainedExp); + gActiveBank = savedActiveBank; + gTasks[taskId].func = sub_81BB628; + } + else + { + currExp += gainedExp; + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp); + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } + } + } +} + +static void sub_81BB628(u8 taskId) +{ + u8 bank = gTasks[taskId].tExpTask_bank; + u8 monIndex = gTasks[taskId].tExpTask_monId; + + if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON]) + bank ^= BIT_MON; + + DoSpecialBattleAnimation(bank, bank, bank, B_ANIM_LVL_UP); + gTasks[taskId].func = sub_81BB688; +} + +static void sub_81BB688(u8 taskId) +{ + u8 bank = gTasks[taskId].tExpTask_bank; + + if (!gBattleSpritesDataPtr->healthBoxesData[bank].specialAnimActive) + { + u8 monIndex = gTasks[taskId].tExpTask_monId; + + GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value + + if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON]) + UpdateHealthboxAttribute(gHealthBoxesIds[bank ^ BIT_MON], &gPlayerParty[monIndex], HEALTHBOX_ALL); + else + UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[monIndex], HEALTHBOX_ALL); + + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } +} + +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId) +{ + u8 monIndex; + u8 bank; + + monIndex = gTasks[taskId].tExpTask_monId; + GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value + bank = gTasks[taskId].tExpTask_bank; + gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); +} + +static void sub_81BB78C(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_24(species); + FreeOamMatrix(gSprites[gBankSpriteIds[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerPartnerBufferExecCompleted(); + } +} + +static void sub_81BB828(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerPartnerBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter2(void) +{ + if (!IsTextPrinterActive(0)) + PlayerPartnerBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + PlayerPartnerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_81BB92C(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + + gBattleBankFunc[gActiveBank] = sub_81BB9A0; + } +} + +static void sub_81BB9A0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + PlayerPartnerBufferExecCompleted(); + } +} + +static void sub_81BB9F4(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + CreateTask(c3_0802FDF4, 10); + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleBankFunc[gActiveBank] = sub_81BB92C; + } +} + +static void sub_81BBAE8(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + gBattleBankFunc[gActiveBank] = sub_81BB9F4; + } +} + +static void PlayerPartnerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = PlayerPartnerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + PlayerPartnerBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyPlayerPartnerMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyPlayerPartnerMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + PlayerPartnerBufferExecCompleted(); +} + +static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gPlayerParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gPlayerParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void PlayerPartnerHandleGetRawMonData(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetPlayerPartnerMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetPlayerPartnerMonData(i); + monsToCheck >>= 1; + } + } + PlayerPartnerBufferExecCompleted(); +} + +static void SetPlayerPartnerMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +static void PlayerPartnerHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleLoadMonSprite(void) +{ + u16 species; + + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + gBattleBankFunc[gActiveBank] = sub_81BB1D4; +} + +static void PlayerPartnerHandleSwitchInAnim(void) +{ + ClearTemporarySpeciesSpriteData(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_81BD0E4(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_81BBAE8; +} + +static void sub_81BD0E4(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite( + &gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); +} + +static void PlayerPartnerHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + PlayerPartnerBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + gBattleBankFunc[gActiveBank] = sub_81BB828; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +// some explanation here +// in emerald it's possible to have a tag battle in the battle frontier facilities with AI +// which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it +static void PlayerPartnerHandleDrawTrainerPic(void) +{ + s16 xPos, yPos; + u32 trainerPicId; + + if (gPartnerTrainerId == STEVEN_PARTNER_ID) + { + trainerPicId = BACK_PIC_STEVEN; + xPos = 90; + yPos = (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80; + } + else + { + trainerPicId = GetFrontierTrainerFrontSpriteId(gPartnerTrainerId); + xPos = 32; + yPos = (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 80; + } + + // Use back pic only if the partner is Steven + if (gPartnerTrainerId == STEVEN_PARTNER_ID) + { + DecompressTrainerBackPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + } + else // otherwise use front sprite + { + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A1C0(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].pos2.y = 48; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gSprites[gBankSpriteIds[gActiveBank]].oam.affineMode = 0; + gSprites[gBankSpriteIds[gActiveBank]].hFlip = 1; + } + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void PlayerPartnerHandleTrainerSlide(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_81BAE98; +} + +static void PlayerPartnerHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; + gBattleBankFunc[gActiveBank] = sub_81BB78C; + } + } +} + +static void PlayerPartnerHandlePaletteFade(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleSuccessBallThrowAnim(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleBallThrowAnim(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandlePause(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always return FALSE + { + PlayerPartnerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = PlayerPartnerDoMoveAnimation; + } + } +} + +static void PlayerPartnerDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + PlayerPartnerBufferExecCompleted(); + } + break; + } +} + +static void PlayerPartnerHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter2; +} + +static void PlayerPartnerHandlePrintStringPlayerOnly(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleChooseAction(void) +{ + AI_TrySwitchOrUseItem(); + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleUnknownYesNoBox(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleChooseMove(void) +{ + u8 chosenMoveId; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + + BattleAI_SetupAIData(0xF); + chosenMoveId = BattleAI_ChooseMoveOrAction(); + + if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & (MOVE_TARGET_x10 | MOVE_TARGET_USER)) + gBankTarget = gActiveBank; + if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & MOVE_TARGET_BOTH) + { + gBankTarget = GetBankByIdentity(IDENTITY_OPPONENT_MON1); + if (gAbsentBankFlags & gBitTable[gBankTarget]) + gBankTarget = GetBankByIdentity(IDENTITY_OPPONENT_MON2); + } + + EmitTwoReturnValues(1, 10, chosenMoveId | (gBankTarget << 8)); + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleChooseItem(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleChoosePokemon(void) +{ + s32 chosenMonId = GetMostSuitableMonToSwitchInto(); + + if (chosenMonId == 6) // just switch to the next mon + { + u8 playerMonIdentity = GetBankByIdentity(IDENTITY_PLAYER_MON1); + u8 selfIdentity = GetBankByIdentity(IDENTITY_PLAYER_MON2); + + for (chosenMonId = 3; chosenMonId < 6; chosenMonId++) + { + if (GetMonData(&gPlayerParty[chosenMonId], MON_DATA_HP) != 0 + && chosenMonId != gBattlePartyID[playerMonIdentity] + && chosenMonId != gBattlePartyID[selfIdentity]) + { + break; + } + } + } + + *(gBattleStruct->field_5C + gActiveBank) = chosenMonId; + EmitChosenMonReturnValue(1, chosenMonId, NULL); + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd23(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void PlayerPartnerHandleExpUpdate(void) +{ + u8 monId = gBattleBufferA[gActiveBank][1]; + + if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_MON_LEVEL) + { + PlayerPartnerBufferExecCompleted(); + } + else + { + s16 expPointsToGive; + u8 taskId; + + LoadBattleBarGfx(1); + GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); // unused return value + expPointsToGive = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + taskId = CreateTask(Task_GiveExpToMon, 10); + gTasks[taskId].tExpTask_monId = monId; + gTasks[taskId].tExpTask_gainedExp = expPointsToGive; + gTasks[taskId].tExpTask_bank = gActiveBank; + gBattleBankFunc[gActiveBank] = nullsub_21; + } +} + +#undef tExpTask_monId +#undef tExpTask_gainedExp +#undef tExpTask_bank +#undef tExpTask_frames + +static void PlayerPartnerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerPartnerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerPartnerHandleStatusXor(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleDataTransfer(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleDMA3Transfer(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandlePlayBGM(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd32(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleTwoReturnValues(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleChosenMonReturnValue(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleOneReturnValue(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleOneReturnValue_Duplicate(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + PlayerPartnerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void PlayerPartnerHandleCmd42(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, -25, 5); + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + gSprites[gBankSpriteIds[gActiveBank]].data5 = gActiveBank; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_805CC00); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + + paletteNum = AllocSpritePalette(0xD6F9); + if (gPartnerTrainerId == STEVEN_PARTNER_ID) + { + u8 spriteId = BACK_PIC_STEVEN; + LoadCompressedPalette(gTrainerBackPicPaletteTable[spriteId].data, 0x100 + paletteNum * 16, 32); + } + else + { + u8 spriteId = GetFrontierTrainerFrontSpriteId(gPartnerTrainerId); + LoadCompressedPalette(gTrainerFrontPicPaletteTable[spriteId].data, 0x100 + paletteNum * 16, 32); + } + + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = paletteNum; + + taskId = CreateTask(sub_81BE2C8, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_77; +} + +static void sub_81BE2C8(u8 taskId) +{ + if (gTasks[taskId].data[1] < 24) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81BD0E4(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81BD0E4(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_81BD0E4(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_81BB02C; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +static void PlayerPartnerHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + PlayerPartnerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_81BE498; + } +} + +static void sub_81BE498(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + PlayerPartnerBufferExecCompleted(); + } +} + +static void PlayerPartnerHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd50(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + PlayerPartnerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + } +} + +static void PlayerPartnerHandleLinkStandbyMsg(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleResetActionMoveSelection(void) +{ + PlayerPartnerBufferExecCompleted(); +} + +static void PlayerPartnerHandleCmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + PlayerPartnerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_128(void) +{ +} -- cgit v1.2.3 From aa7e97945be693227c254b1e8664a6f7603d69de Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 11:24:58 +0200 Subject: start recorded player controller --- src/battle_controller_recorded_player.c | 204 ++++++++++++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 src/battle_controller_recorded_player.c (limited to 'src') diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c new file mode 100644 index 000000000..1f07b377c --- /dev/null +++ b/src/battle_controller_recorded_player.c @@ -0,0 +1,204 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "battle_ai_script_commands.h" +#include "recorded_battle.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u8 gBankInMenu; +extern u16 gUnknown_020243FC; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gPartnerTrainerId; +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_020244B4[]; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern struct UnusedControllerStruct gUnknown_02022D0C; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; + +extern void sub_81358F4(void); +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); + +// this file's functions +void RecordedPlayerHandleGetMonData(void); +void RecordedPlayerHandleGetRawMonData(void); +void RecordedPlayerHandleSetMonData(void); +void RecordedPlayerHandleSetRawMonData(void); +void RecordedPlayerHandleLoadMonSprite(void); +void RecordedPlayerHandleSwitchInAnim(void); +void RecordedPlayerHandleReturnMonToBall(void); +void RecordedPlayerHandleDrawTrainerPic(void); +void RecordedPlayerHandleTrainerSlide(void); +void RecordedPlayerHandleTrainerSlideBack(void); +void RecordedPlayerHandleFaintAnimation(void); +void RecordedPlayerHandlePaletteFade(void); +void RecordedPlayerHandleSuccessBallThrowAnim(void); +void RecordedPlayerHandleBallThrowAnim(void); +void RecordedPlayerHandlePause(void); +void RecordedPlayerHandleMoveAnimation(void); +void RecordedPlayerHandlePrintString(void); +void RecordedPlayerHandlePrintStringPlayerOnly(void); +void RecordedPlayerHandleChooseAction(void); +void RecordedPlayerHandleUnknownYesNoBox(void); +void RecordedPlayerHandleChooseMove(void); +void RecordedPlayerHandleChooseItem(void); +void RecordedPlayerHandleChoosePokemon(void); +void RecordedPlayerHandleCmd23(void); +void RecordedPlayerHandleHealthBarUpdate(void); +void RecordedPlayerHandleExpUpdate(void); +void RecordedPlayerHandleStatusIconUpdate(void); +void RecordedPlayerHandleStatusAnimation(void); +void RecordedPlayerHandleStatusXor(void); +void RecordedPlayerHandleDataTransfer(void); +void RecordedPlayerHandleDMA3Transfer(void); +void RecordedPlayerHandlePlayBGM(void); +void RecordedPlayerHandleCmd32(void); +void RecordedPlayerHandleTwoReturnValues(void); +void RecordedPlayerHandleChosenMonReturnValue(void); +void RecordedPlayerHandleOneReturnValue(void); +void RecordedPlayerHandleOneReturnValue_Duplicate(void); +void RecordedPlayerHandleCmd37(void); +void RecordedPlayerHandleCmd38(void); +void RecordedPlayerHandleCmd39(void); +void RecordedPlayerHandleCmd40(void); +void RecordedPlayerHandleHitAnimation(void); +void RecordedPlayerHandleCmd42(void); +void RecordedPlayerHandleEffectivenessSound(void); +void RecordedPlayerHandlePlayFanfareOrBGM(void); +void RecordedPlayerHandleFaintingCry(void); +void RecordedPlayerHandleIntroSlide(void); +void RecordedPlayerHandleIntroTrainerBallThrow(void); +void RecordedPlayerHandleDrawPartyStatusSummary(void); +void RecordedPlayerHandleCmd49(void); +void RecordedPlayerHandleCmd50(void); +void RecordedPlayerHandleSpriteInvisibility(void); +void RecordedPlayerHandleBattleAnimation(void); +void RecordedPlayerHandleLinkStandbyMsg(void); +void RecordedPlayerHandleResetActionMoveSelection(void); +void RecordedPlayerHandleCmd55(void); +void nullsub_121(void); + +void RecordedPlayerBufferRunCommand(void); +void RecordedPlayerBufferExecCompleted(void); + +void (*const gRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + RecordedPlayerHandleGetMonData, + RecordedPlayerHandleGetRawMonData, + RecordedPlayerHandleSetMonData, + RecordedPlayerHandleSetRawMonData, + RecordedPlayerHandleLoadMonSprite, + RecordedPlayerHandleSwitchInAnim, + RecordedPlayerHandleReturnMonToBall, + RecordedPlayerHandleDrawTrainerPic, + RecordedPlayerHandleTrainerSlide, + RecordedPlayerHandleTrainerSlideBack, + RecordedPlayerHandleFaintAnimation, + RecordedPlayerHandlePaletteFade, + RecordedPlayerHandleSuccessBallThrowAnim, + RecordedPlayerHandleBallThrowAnim, + RecordedPlayerHandlePause, + RecordedPlayerHandleMoveAnimation, + RecordedPlayerHandlePrintString, + RecordedPlayerHandlePrintStringPlayerOnly, + RecordedPlayerHandleChooseAction, + RecordedPlayerHandleUnknownYesNoBox, + RecordedPlayerHandleChooseMove, + RecordedPlayerHandleChooseItem, + RecordedPlayerHandleChoosePokemon, + RecordedPlayerHandleCmd23, + RecordedPlayerHandleHealthBarUpdate, + RecordedPlayerHandleExpUpdate, + RecordedPlayerHandleStatusIconUpdate, + RecordedPlayerHandleStatusAnimation, + RecordedPlayerHandleStatusXor, + RecordedPlayerHandleDataTransfer, + RecordedPlayerHandleDMA3Transfer, + RecordedPlayerHandlePlayBGM, + RecordedPlayerHandleCmd32, + RecordedPlayerHandleTwoReturnValues, + RecordedPlayerHandleChosenMonReturnValue, + RecordedPlayerHandleOneReturnValue, + RecordedPlayerHandleOneReturnValue_Duplicate, + RecordedPlayerHandleCmd37, + RecordedPlayerHandleCmd38, + RecordedPlayerHandleCmd39, + RecordedPlayerHandleCmd40, + RecordedPlayerHandleHitAnimation, + RecordedPlayerHandleCmd42, + RecordedPlayerHandleEffectivenessSound, + RecordedPlayerHandlePlayFanfareOrBGM, + RecordedPlayerHandleFaintingCry, + RecordedPlayerHandleIntroSlide, + RecordedPlayerHandleIntroTrainerBallThrow, + RecordedPlayerHandleDrawPartyStatusSummary, + RecordedPlayerHandleCmd49, + RecordedPlayerHandleCmd50, + RecordedPlayerHandleSpriteInvisibility, + RecordedPlayerHandleBattleAnimation, + RecordedPlayerHandleLinkStandbyMsg, + RecordedPlayerHandleResetActionMoveSelection, + RecordedPlayerHandleCmd55, + nullsub_121 +}; + +void nullsub_120(void) +{ +} + +void SetBankFuncToRecordedPlayerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = RecordedPlayerBufferRunCommand; +} + +void RecordedPlayerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gRecordedPlayerBufferCommands)) + gRecordedPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + RecordedPlayerBufferExecCompleted(); + } +} -- cgit v1.2.3 From 918625196ed5e91999f1a244a8881fb9f8069c64 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 13:32:11 +0200 Subject: recorded player controller is done --- src/battle_controller_player.c | 2 +- src/battle_controller_player_partner.c | 2 +- src/battle_controller_recorded_player.c | 1780 +++++++++++++++++++++++++++++-- 3 files changed, 1717 insertions(+), 67 deletions(-) (limited to 'src') diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b9ce93a89..b022d3f87 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -2510,7 +2510,7 @@ static void PlayerHandleMoveAnimation(void) gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; - if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always return FALSE + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE { PlayerBufferExecCompleted(); } diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index b7479c3cc..25eaf773f 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -1456,7 +1456,7 @@ static void PlayerPartnerHandleMoveAnimation(void) gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; - if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always return FALSE + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE { PlayerPartnerBufferExecCompleted(); } diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 1f07b377c..efedf52b6 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -50,79 +50,89 @@ extern u8 gBankTarget; extern u8 gAbsentBankFlags; extern u8 gUnknown_020244B4[]; extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern u8 gBattleCommunication[]; +extern u8 gUnknown_0203C7B4; +extern struct MusicPlayerInfo gMPlay_BGM; extern struct UnusedControllerStruct gUnknown_02022D0C; extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; extern const struct BattleMove gBattleMoves[]; -extern void sub_81358F4(void); extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); // this file's functions -void RecordedPlayerHandleGetMonData(void); -void RecordedPlayerHandleGetRawMonData(void); -void RecordedPlayerHandleSetMonData(void); -void RecordedPlayerHandleSetRawMonData(void); -void RecordedPlayerHandleLoadMonSprite(void); -void RecordedPlayerHandleSwitchInAnim(void); -void RecordedPlayerHandleReturnMonToBall(void); -void RecordedPlayerHandleDrawTrainerPic(void); -void RecordedPlayerHandleTrainerSlide(void); -void RecordedPlayerHandleTrainerSlideBack(void); -void RecordedPlayerHandleFaintAnimation(void); -void RecordedPlayerHandlePaletteFade(void); -void RecordedPlayerHandleSuccessBallThrowAnim(void); -void RecordedPlayerHandleBallThrowAnim(void); -void RecordedPlayerHandlePause(void); -void RecordedPlayerHandleMoveAnimation(void); -void RecordedPlayerHandlePrintString(void); -void RecordedPlayerHandlePrintStringPlayerOnly(void); -void RecordedPlayerHandleChooseAction(void); -void RecordedPlayerHandleUnknownYesNoBox(void); -void RecordedPlayerHandleChooseMove(void); -void RecordedPlayerHandleChooseItem(void); -void RecordedPlayerHandleChoosePokemon(void); -void RecordedPlayerHandleCmd23(void); -void RecordedPlayerHandleHealthBarUpdate(void); -void RecordedPlayerHandleExpUpdate(void); -void RecordedPlayerHandleStatusIconUpdate(void); -void RecordedPlayerHandleStatusAnimation(void); -void RecordedPlayerHandleStatusXor(void); -void RecordedPlayerHandleDataTransfer(void); -void RecordedPlayerHandleDMA3Transfer(void); -void RecordedPlayerHandlePlayBGM(void); -void RecordedPlayerHandleCmd32(void); -void RecordedPlayerHandleTwoReturnValues(void); -void RecordedPlayerHandleChosenMonReturnValue(void); -void RecordedPlayerHandleOneReturnValue(void); -void RecordedPlayerHandleOneReturnValue_Duplicate(void); -void RecordedPlayerHandleCmd37(void); -void RecordedPlayerHandleCmd38(void); -void RecordedPlayerHandleCmd39(void); -void RecordedPlayerHandleCmd40(void); -void RecordedPlayerHandleHitAnimation(void); -void RecordedPlayerHandleCmd42(void); -void RecordedPlayerHandleEffectivenessSound(void); -void RecordedPlayerHandlePlayFanfareOrBGM(void); -void RecordedPlayerHandleFaintingCry(void); -void RecordedPlayerHandleIntroSlide(void); -void RecordedPlayerHandleIntroTrainerBallThrow(void); -void RecordedPlayerHandleDrawPartyStatusSummary(void); -void RecordedPlayerHandleCmd49(void); -void RecordedPlayerHandleCmd50(void); -void RecordedPlayerHandleSpriteInvisibility(void); -void RecordedPlayerHandleBattleAnimation(void); -void RecordedPlayerHandleLinkStandbyMsg(void); -void RecordedPlayerHandleResetActionMoveSelection(void); -void RecordedPlayerHandleCmd55(void); -void nullsub_121(void); - -void RecordedPlayerBufferRunCommand(void); -void RecordedPlayerBufferExecCompleted(void); - -void (*const gRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void RecordedPlayerHandleGetMonData(void); +static void RecordedPlayerHandleGetRawMonData(void); +static void RecordedPlayerHandleSetMonData(void); +static void RecordedPlayerHandleSetRawMonData(void); +static void RecordedPlayerHandleLoadMonSprite(void); +static void RecordedPlayerHandleSwitchInAnim(void); +static void RecordedPlayerHandleReturnMonToBall(void); +static void RecordedPlayerHandleDrawTrainerPic(void); +static void RecordedPlayerHandleTrainerSlide(void); +static void RecordedPlayerHandleTrainerSlideBack(void); +static void RecordedPlayerHandleFaintAnimation(void); +static void RecordedPlayerHandlePaletteFade(void); +static void RecordedPlayerHandleSuccessBallThrowAnim(void); +static void RecordedPlayerHandleBallThrowAnim(void); +static void RecordedPlayerHandlePause(void); +static void RecordedPlayerHandleMoveAnimation(void); +static void RecordedPlayerHandlePrintString(void); +static void RecordedPlayerHandlePrintStringPlayerOnly(void); +static void RecordedPlayerHandleChooseAction(void); +static void RecordedPlayerHandleUnknownYesNoBox(void); +static void RecordedPlayerHandleChooseMove(void); +static void RecordedPlayerHandleChooseItem(void); +static void RecordedPlayerHandleChoosePokemon(void); +static void RecordedPlayerHandleCmd23(void); +static void RecordedPlayerHandleHealthBarUpdate(void); +static void RecordedPlayerHandleExpUpdate(void); +static void RecordedPlayerHandleStatusIconUpdate(void); +static void RecordedPlayerHandleStatusAnimation(void); +static void RecordedPlayerHandleStatusXor(void); +static void RecordedPlayerHandleDataTransfer(void); +static void RecordedPlayerHandleDMA3Transfer(void); +static void RecordedPlayerHandlePlayBGM(void); +static void RecordedPlayerHandleCmd32(void); +static void RecordedPlayerHandleTwoReturnValues(void); +static void RecordedPlayerHandleChosenMonReturnValue(void); +static void RecordedPlayerHandleOneReturnValue(void); +static void RecordedPlayerHandleOneReturnValue_Duplicate(void); +static void RecordedPlayerHandleCmd37(void); +static void RecordedPlayerHandleCmd38(void); +static void RecordedPlayerHandleCmd39(void); +static void RecordedPlayerHandleCmd40(void); +static void RecordedPlayerHandleHitAnimation(void); +static void RecordedPlayerHandleCmd42(void); +static void RecordedPlayerHandleEffectivenessSound(void); +static void RecordedPlayerHandlePlayFanfareOrBGM(void); +static void RecordedPlayerHandleFaintingCry(void); +static void RecordedPlayerHandleIntroSlide(void); +static void RecordedPlayerHandleIntroTrainerBallThrow(void); +static void RecordedPlayerHandleDrawPartyStatusSummary(void); +static void RecordedPlayerHandleCmd49(void); +static void RecordedPlayerHandleCmd50(void); +static void RecordedPlayerHandleSpriteInvisibility(void); +static void RecordedPlayerHandleBattleAnimation(void); +static void RecordedPlayerHandleLinkStandbyMsg(void); +static void RecordedPlayerHandleResetActionMoveSelection(void); +static void RecordedPlayerHandleCmd55(void); +static void nullsub_121(void); + +static void RecordedPlayerBufferRunCommand(void); +static void RecordedPlayerBufferExecCompleted(void); +static void sub_818A328(void); +static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst); +static void SetRecordedPlayerMonData(u8 monId); +static void sub_818BA6C(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void RecordedPlayerDoMoveAnimation(void); +static void sub_818CC24(u8 taskId); +static void sub_818CDF4(void); + +static void (*const gRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { RecordedPlayerHandleGetMonData, RecordedPlayerHandleGetRawMonData, @@ -183,7 +193,7 @@ void (*const gRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = nullsub_121 }; -void nullsub_120(void) +static void nullsub_120(void) { } @@ -192,7 +202,7 @@ void SetBankFuncToRecordedPlayerBufferRunCommand(void) gBattleBankFunc[gActiveBank] = RecordedPlayerBufferRunCommand; } -void RecordedPlayerBufferRunCommand(void) +static void RecordedPlayerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { @@ -202,3 +212,1643 @@ void RecordedPlayerBufferRunCommand(void) RecordedPlayerBufferExecCompleted(); } } + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + RecordedPlayerBufferExecCompleted(); +} + +static void sub_81899F0(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_25(0); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + RecordedPlayerBufferExecCompleted(); + } +} + +static void sub_8189A58(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + RecordedPlayerBufferExecCompleted(); + } +} + +static void sub_8189AA0(void) +{ + bool32 r6 = FALSE; + + if (GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON1) + { + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r6 = TRUE; + } + } + + if (r6 && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + if (IsDoubleBattle()) + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], gActiveBank ^ BIT_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_8189A58; + } + } + else + { + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r6 = TRUE; + } + } + + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_8189A58; + } + } +} + +static void sub_8189D40(void) +{ + bool32 r10 = FALSE; + + if (GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON1) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + } + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + sub_8172EF0(gActiveBank ^ BIT_MON, &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + } + } + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1; + } + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40 + && !IsCryPlayingOrClearCrySongs()) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20) + { + if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if (GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON1) + m4aMPlayContinue(&gMPlay_BGM); + } + else + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + } + + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1; + r10 = TRUE; + } + + if (r10 && gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0; + gBattleBankFunc[gActiveBank] = sub_8189AA0; + } +} + +static void sub_818A064(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].animEnded && gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + RecordedPlayerBufferExecCompleted(); +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + RecordedPlayerBufferExecCompleted(); + } +} + +static void sub_818A114(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_24(species); + FreeOamMatrix(gSprites[gBankSpriteIds[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedPlayerBufferExecCompleted(); + } +} + +static void sub_818A1B0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedPlayerBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + RecordedPlayerBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + RecordedPlayerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_818A2B4(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + + gBattleBankFunc[gActiveBank] = sub_818A328; + } +} + +static void sub_818A328(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + RecordedPlayerBufferExecCompleted(); + } +} + +static void sub_818A37C(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + CreateTask(c3_0802FDF4, 10); + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleBankFunc[gActiveBank] = sub_818A2B4; + } +} + +static void sub_818A470(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + gBattleBankFunc[gActiveBank] = sub_818A37C; + } +} + +static void RecordedPlayerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = RecordedPlayerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + RecordedPlayerBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyRecordedPlayerMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyRecordedPlayerMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + RecordedPlayerBufferExecCompleted(); +} + +static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gPlayerParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gPlayerParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void RecordedPlayerHandleGetRawMonData(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetRecordedPlayerMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetRecordedPlayerMonData(i); + monsToCheck >>= 1; + } + } + RecordedPlayerBufferExecCompleted(); +} + +static void SetRecordedPlayerMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +static void RecordedPlayerHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleLoadMonSprite(void) +{ + u16 species; + + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + gBattleBankFunc[gActiveBank] = sub_818A064; +} + +static void RecordedPlayerHandleSwitchInAnim(void) +{ + ClearTemporarySpeciesSpriteData(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_818BA6C(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_818A470; +} + +static void sub_818BA6C(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite( + &gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); +} + +static void RecordedPlayerHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedPlayerBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + gBattleBankFunc[gActiveBank] = sub_818A1B0; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +static void RecordedPlayerHandleDrawTrainerPic(void) +{ + s16 xPos, yPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_x2000000) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + trainerPicId = sub_8185F40(); + else + trainerPicId = gLinkPlayers[gUnknown_0203C7B4].gender; + } + else + { + trainerPicId = gLinkPlayers[0].gender; + } + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 90; + else // first mon + xPos = 32; + + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + { + xPos = 90; + yPos = (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 80; + } + else + { + yPos = (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80; + } + + } + else + { + xPos = 80; + yPos = (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80; + } + + if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + { + trainerPicId = PlayerGenderToFrontTrainerPicId(gSaveBlock2Ptr->playerGender); + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A1C0(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].pos2.y = 48; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gSprites[gBankSpriteIds[gActiveBank]].oam.affineMode = 0; + gSprites[gBankSpriteIds[gActiveBank]].hFlip = 1; + } + else + { + DecompressTrainerBackPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, yPos, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + } + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void RecordedPlayerHandleTrainerSlide(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_81899F0; +} + +static void RecordedPlayerHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; + gBattleBankFunc[gActiveBank] = sub_818A114; + } + } +} + +static void RecordedPlayerHandlePaletteFade(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleSuccessBallThrowAnim(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleBallThrowAnim(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandlePause(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + RecordedPlayerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = RecordedPlayerDoMoveAnimation; + } + } +} + +static void RecordedPlayerDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + RecordedPlayerBufferExecCompleted(); + } + break; + } +} + +static void RecordedPlayerHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; +} + +static void RecordedPlayerHandlePrintStringPlayerOnly(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void ChooseActionInBattlePalace(void) +{ + if (gBattleCommunication[4] >= gNoOfAllBanks / 2) + { + EmitTwoReturnValues(1, RecordedBattle_ReadBankAction(gActiveBank), 0); + RecordedPlayerBufferExecCompleted(); + } +} + +static void RecordedPlayerHandleChooseAction(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_PALACE) + { + gBattleBankFunc[gActiveBank] = ChooseActionInBattlePalace; + } + else + { + EmitTwoReturnValues(1, RecordedBattle_ReadBankAction(gActiveBank), 0); + RecordedPlayerBufferExecCompleted(); + } +} + +static void RecordedPlayerHandleUnknownYesNoBox(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleChooseMove(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_PALACE) + { + EmitTwoReturnValues(1, 10, ChooseMoveAndTargetInBattlePalace()); + } + else + { + u8 moveId = RecordedBattle_ReadBankAction(gActiveBank); + u8 target = RecordedBattle_ReadBankAction(gActiveBank); + EmitTwoReturnValues(1, 10, moveId | (target << 8)); + } + + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleChooseItem(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleChoosePokemon(void) +{ + *(gBattleStruct->field_5C + gActiveBank) = RecordedBattle_ReadBankAction(gActiveBank); + EmitChosenMonReturnValue(1, *(gBattleStruct->field_5C + gActiveBank), NULL); + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd23(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], 0, HP_CURRENT); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void RecordedPlayerHandleExpUpdate(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void RecordedPlayerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void RecordedPlayerHandleStatusXor(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleDataTransfer(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleDMA3Transfer(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandlePlayBGM(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd32(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleTwoReturnValues(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleChosenMonReturnValue(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleOneReturnValue(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleOneReturnValue_Duplicate(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + RecordedPlayerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void RecordedPlayerHandleCmd42(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, -25, 5); + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + u32 trainerPicId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + gSprites[gBankSpriteIds[gActiveBank]].data5 = gActiveBank; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_805CC00); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + + paletteNum = AllocSpritePalette(0xD6F9); + if (gBattleTypeFlags & BATTLE_TYPE_x2000000) + trainerPicId = gLinkPlayers[sub_806D864(gActiveBank)].gender; + else + trainerPicId = gSaveBlock2Ptr->playerGender; + + LoadCompressedPalette(gTrainerBackPicPaletteTable[trainerPicId].data, 0x100 + paletteNum * 16, 32); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = paletteNum; + + taskId = CreateTask(sub_818CC24, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_120; +} + +static void sub_818CC24(u8 taskId) +{ + if (gTasks[taskId].data[1] < 24) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_818BA6C(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_818BA6C(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_818BA6C(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_8189D40; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +static void RecordedPlayerHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + RecordedPlayerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_818CDF4; + } +} + +static void sub_818CDF4(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + RecordedPlayerBufferExecCompleted(); + } +} + +static void RecordedPlayerHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd50(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + RecordedPlayerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + } +} + +static void RecordedPlayerHandleLinkStandbyMsg(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleResetActionMoveSelection(void) +{ + RecordedPlayerBufferExecCompleted(); +} + +static void RecordedPlayerHandleCmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + RecordedPlayerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_121(void) +{ +} -- cgit v1.2.3 From 5b703079627cf11a123e3f1a7e7f0e5e0fbeb9ed Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 13:36:55 +0200 Subject: revert merge coz its bugged --- src/decoration.c | 2781 ----------------------------- src/decoration_inventory.c | 189 -- src/international_string_util.c | 8 +- src/pokemon_summary_screen.c | 3679 --------------------------------------- src/start_menu.c | 2 +- src/tv.c | 2 +- 6 files changed, 6 insertions(+), 6655 deletions(-) delete mode 100644 src/decoration.c delete mode 100644 src/decoration_inventory.c delete mode 100755 src/pokemon_summary_screen.c (limited to 'src') diff --git a/src/decoration.c b/src/decoration.c deleted file mode 100644 index 0179d36a1..000000000 --- a/src/decoration.c +++ /dev/null @@ -1,2781 +0,0 @@ - -// Includes -#include "global.h" -#include "decompress.h" -#include "malloc.h" -#include "string_util.h" -#include "international_string_util.h" -#include "script.h" -#include "task.h" -#include "main.h" -#include "palette.h" -#include "songs.h" -#include "overworld.h" -#include "fieldmap.h" -#include "metatile_behavior.h" -#include "field_weather.h" -#include "field_player_avatar.h" -#include "field_camera.h" -#include "field_screen.h" -#include "field_map_obj.h" -#include "list_menu.h" -#include "menu_helpers.h" -#include "new_menu_helpers.h" -#include "menu_indicators.h" -#include "sound.h" -#include "event_scripts.h" -#include "event_data.h" -#include "region_map.h" -#include "player_pc.h" -#include "strings.h" -#include "tv.h" -#include "secret_base.h" -#include "tilesets.h" -#include "item_icon.h" -#include "trader.h" -#include "map_object_constants.h" -#include "decoration_inventory.h" -#include "decoration.h" -#include "graphics.h" - -// Static type declarations - -#define OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG 0xbe5 -#define OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG 0x008 - -struct DecorPCBuffer { - struct ListMenuItem items[41]; - u8 names[41][24]; - u8 unk_520; - u8 unk_521; - u8 unk_522; -}; - -struct PlaceDecorationGraphicsDataBuffer { - /*0x000; 0x0203a190*/ const struct Decoration *decoration; - /*0x004; 0x0203a194*/ u16 tiles[0x40]; - /*0x084; 0x0203a214*/ u8 image[0x800]; - /*0x884; 0x0203aa14*/ u16 palette[16]; -}; - -struct DecorRearrangementDataBuffer { - u8 idx; - u8 width; - u8 height; - u16 flagId; -}; - -// Static RAM declarations - -EWRAM_DATA u8 *gCurDecorInventoryItems = NULL; -EWRAM_DATA u8 sSecretBasePCMenuCursorPos = 0; -EWRAM_DATA u8 sCurDecorCatCount = 0; -EWRAM_DATA u8 sSecretBaseItemsIndicesBuffer[16] = {}; -EWRAM_DATA u8 sPlayerRoomItemsIndicesBuffer[12] = {}; -EWRAM_DATA u16 sSecretBasePCSelectDecorLineNo = 0; -EWRAM_DATA u16 sSecretBasePCSelectDecorPageNo = 0; -EWRAM_DATA u8 gCurDecorationIndex = 0; -EWRAM_DATA u8 sCurDecorationCategory = DECORCAT_DESK; -EWRAM_DATA u32 filler_0203a174[2] = {}; -EWRAM_DATA struct DecorPCPointers gUnknown_0203A17C = {}; -EWRAM_DATA u8 sDecorMenuWindowIndices[4] = {}; -EWRAM_DATA struct DecorPCBuffer *sDecorPCBuffer = NULL; -EWRAM_DATA struct PlaceDecorationGraphicsDataBuffer sPlaceDecorationGraphicsDataBuffer = {}; -EWRAM_DATA u16 sCurDecorMapX = 0; -EWRAM_DATA u16 sCurDecorMapY = 0; -EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx1 = 0; -EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx2 = 0; -EWRAM_DATA u8 sDecorationLastDirectionMoved = 0; -EWRAM_DATA struct OamData sDecorSelectorOam = {}; -EWRAM_DATA struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {}; -EWRAM_DATA u8 sCurDecorSelectedInRearrangement = 0; - -// Static ROM declarations - -void sub_8126B80(u8 taskId); -void sub_8126C08(void); -void SecretBasePC_Decorate(u8 taskId); -void SecretBasePC_PutAway(u8 taskId); -void SecretBasePC_Toss(u8 taskId); -void sub_8126DA4(u8 taskId); -void SecretBasePC_Cancel(u8 taskId); -void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId); -void sub_8126DFC(u8 taskId); -void sub_8126E8C(u8 taskId); -void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed); -void sub_8127058(u8 *str, bool8 flag); -void sub_8127088(u8 taskId); -void sub_81270E8(u8 taskId); -void sub_8127180(u8 taskId); -void sub_812719C(u8 taskId); -void sub_81271CC(u8 taskId); -void sub_8127268(u8 taskId); -void sub_8127454(u8 *dest, u16 decorId); -void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu); -void sub_81274A0(u8 a0, s32 a1, u8 a2); -void sub_8127620(u8 taskId); -void sub_812764C(u8 taskId); -void sub_8127744(u32 a0); -void sub_81277A8(void); -bool8 sub_81277BC(u8 idx); -bool8 sub_81277E8(u8 idx); -void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId); -void sub_812759C(u8 taskId); -void sub_8127718(u8 decorCat); -void sub_8127A30(u8 taskId); -void sub_8127A8C(u8 taskId); -void sub_8127F68(u8 taskId); -void sub_8128060(u8 taskId); -void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor); -void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data); -void sub_812826C(u8 taskId); -void sub_81283BC(u8 taskId); -void sub_8128414(u8 taskId); -void sub_8128950(u8 taskId); -void sub_81289D0(u8 taskId); -void sub_81289F0(u8 taskId); -void sub_8128AAC(u8 taskId); -void sub_8128B80(u8 taskId); -void sub_8128BA0(u8 taskId); -void sub_8128BBC(u8 taskId); -void c1_overworld_prev_quest(u8 taskId); -void sub_8128CD4(void); -void sub_8128DE0(void); -void sub_8128FD8(u8 taskId); -void sub_8129020(u8 taskId); -void sub_81292D0(struct Sprite *sprite); -void sub_81292E8(struct Sprite *sprite); -u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor); -const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode); -bool8 sub_81299AC(u8 taskId); -void sub_8129ABC(u8 taskId); -void sub_8129B34(u8 taskId); -void sub_8129BCC(u8 taskId); -void sub_8129BF8(u8 taskId); -void sub_8129C74(u8 taskId); -void sub_8129D64(u8 taskId); -void sub_812A0E8(u8 taskId); -void sub_812A1A0(u8 taskId); -void sub_812A1C0(u8 taskId); -void sub_812A1F0(u8 taskId); -void sub_812A210(u8 taskId); -void sub_812A22C(u8 taskId); -void sub_812A25C(u8 taskId); -void sub_812A334(void); -void sub_812A36C(struct Sprite *sprite); -void sub_812A39C(void); -void sub_812A3C8(void); -void sub_812A3D4(u8 taskId); -void sub_812A458(u8 taskId); -void sub_812A478(u8 taskId); - -// .rodata - -#include "data/decoration/tiles.h" -#include "data/decoration/description.h" -#include "data/decoration/header.h" - -const u8 *const sDecorCatNames[] = { - gText_Desk, - gText_Chair, - gText_Plant, - gText_Ornament, - gText_Mat, - gText_Poster, - gText_Doll, - gText_Cushion -}; - -const struct MenuAction sSecretBasePCMenuActions[] = { - { - gText_Decorate, {.void_u8=SecretBasePC_Decorate} - }, { - gText_PutAway, {.void_u8=SecretBasePC_PutAway} - }, { - gText_Toss2, {.void_u8=SecretBasePC_Toss} - }, { - gText_Cancel, {.void_u8=SecretBasePC_Cancel} - } -}; - -const u8 *const sSecretBasePCMenuItemDescriptions[] = { - gText_PutOutSelectedDecorItem, - gText_StoreChosenDecorInPC, - gText_ThrowAwayUnwantedDecors, - gText_GoBackPrevMenu -}; - -void (*const SecretBasePC_SelectedDecorActions[][2])(u8 taskId) = { - { - sub_8127F68, sub_8127A8C - }, { - sub_812A3D4, sub_8127A8C - }, { - sub_8133DA0, sub_8127A8C - } -}; - -const struct WindowTemplate gUnknown_085A6B90[4] = { - { 0, 1, 1, 18, 8, 15, 0x0001 }, - { 0, 1, 1, 13, 18, 13, 0x0091 }, - { 0, 17, 1, 12, 2, 15, 0x017b }, - { 0, 16, 13, 13, 6, 15, 0x0193 } -}; - -const u16 gUnknown_085A6BB0[] = INCBIN_U16("graphics/decorations/unk_85a6bb0.gbapal"); - -const struct ListMenuTemplate gUnknown_085A6BD0 = { - NULL, - sub_8127480, - sub_81274A0, - 0, 0, - 0, 0, 8, 0, - 9, 2, 1, 3, FALSE, 0, FALSE, 7 -}; - -#include "data/decoration/icon.h" -#include "data/decoration/tilemaps.h" - -const struct { - u8 shape; - u8 size; - u8 x; - u8 y; -} gUnknown_085A7250[] = { - {0, 1, 0x78, 0x4e}, - {1, 2, 0x80, 0x4e}, - {1, 3, 0x90, 0x56}, - {1, 3, 0x90, 0x46}, - {0, 2, 0x80, 0x46}, - {2, 2, 0x78, 0x46}, - {2, 3, 0x80, 0x56}, - {2, 3, 0x80, 0x36}, - {0, 3, 0x90, 0x46}, - {1, 3, 0x90, 0x46} -}; - -const union AnimCmd gUnknown_085A7278[] = { - ANIMCMD_FRAME(0, 0, FALSE, FALSE), - ANIMCMD_END -}; - -const union AnimCmd *const sDecorSelectorAnims[] = { - gUnknown_085A7278 -}; - -const struct SpriteFrameImage sDecorSelectorSpriteFrameImages = { - (const u8 *)&sPlaceDecorationGraphicsDataBuffer.image, 0x800 -}; - -const struct SpriteTemplate sDecorSelectorSpriteTemplate = { - 0xffff, - OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG, - &sDecorSelectorOam, - sDecorSelectorAnims, - &sDecorSelectorSpriteFrameImages, - gDummySpriteAffineAnimTable, - SpriteCallbackDummy -}; - -const struct SpriteTemplate sDecorWhilePlacingSpriteTemplate = { - 0x0000, - 0x0000, - &sDecorSelectorOam, - sDecorSelectorAnims, - NULL, - gDummySpriteAffineAnimTable, - SpriteCallbackDummy -}; - -const struct SpritePalette gUnknown_085A72BC = { - (const u16 *)&sPlaceDecorationGraphicsDataBuffer.palette, OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG -}; - -const struct YesNoFuncTable gUnknown_085A72C4 = { - sub_81289F0, - sub_8128FD8 -}; - -const struct YesNoFuncTable gUnknown_085A72CC = { - sub_8128BA0, - sub_8128FD8 -}; - -const struct YesNoFuncTable gUnknown_085A72D4[] = { - { - sub_81283BC, - sub_8128414 - }, { - sub_8129BCC, - sub_8129BF8 - } -}; - -const u8 gUnknown_085A72E4[] = { - 0x04, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x00 -}; - -const u8 gUnknown_085A72EC[] = { - 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x03, 0x00 -}; - -const u16 gUnknown_085A72F4[] = { - 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x20 -}; - -const u16 Unknown_085A7308[] = INCBIN_U16("graphics/decorations/unk_85a7308.gbapal"); - -const u16 Unknown_085A7328[] = INCBIN_U16("graphics/decorations/unk_85a7328.gbapal"); - -const struct YesNoFuncTable gUnknown_085A7348 = { - sub_812A1C0, - sub_8129B34 -}; - -const struct YesNoFuncTable gUnknown_085A7350 = { - sub_812A210, - sub_8129B34 -}; - -const u8 Unknown_085A7358[] = INCBIN_U8("graphics/misc/decoration_unk_85a7358.4bpp"); - -const struct SpritePalette gUnknown_085A73D8 = { - Unknown_085A7308, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG -}; - -const struct SpritePalette gUnknown_085A73E0 = { - Unknown_085A7328, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG -}; - -const struct OamData Unknown_085A73E8 = { - .size = 1, .priority = 1 -}; - -const union AnimCmd Unknown_085A73F0[] = { - ANIMCMD_FRAME(0, 0, 0), - ANIMCMD_END -}; - -const union AnimCmd *const Unknown_085A73F8[] = { - Unknown_085A73F0 -}; - -const struct SpriteFrameImage Unknown_085A73FC = { - Unknown_085A7358, 0x80 -}; - -const struct SpriteTemplate gUnknown_085A7404 = { - 0xFFFF, - OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG, - &Unknown_085A73E8, - Unknown_085A73F8, - &Unknown_085A73FC, - gDummySpriteAffineAnimTable, - sub_812A36C -}; - -const struct YesNoFuncTable gUnknown_085A741C = { - sub_812A478, - sub_8127A30 -}; - -// .text - -void sub_8126968(void) -{ - if (sCurDecorationCategory < 8) - { - gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items; - } - if (gUnknown_0203A17C.isPlayerRoom == FALSE) - { - gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations; - gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos; - } - if (gUnknown_0203A17C.isPlayerRoom == TRUE) - { - gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor; - gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos; - } -} - -u8 sub_81269D4(u8 idx) -{ - u8 *winidx; - struct WindowTemplate template; - - winidx = &sDecorMenuWindowIndices[idx]; - if (idx == 0) - { - template = gUnknown_085A6B90[0]; - template.width = GetMaxWidthInMenuTable(sSecretBasePCMenuActions, 4); - if (template.width > 18) - { - template.width = 18; - } - *winidx = AddWindow(&template); - } - else - { - *winidx = AddWindow(&gUnknown_085A6B90[idx]); - } - SetWindowBorderStyle(*winidx, 0, 0x214, 0xe); - schedule_bg_copy_tilemap_to_vram(0); - return *winidx; -} - -void sub_8126A58(u8 idx) -{ - sub_8198070(sDecorMenuWindowIndices[idx], FALSE); - ClearWindowTilemap(sDecorMenuWindowIndices[idx]); - RemoveWindow(sDecorMenuWindowIndices[idx]); - schedule_bg_copy_tilemap_to_vram(0); -} - -void sub_8126A88(void) -{ - u8 idx; - - idx = sub_81269D4(0); - PrintMenuTable(idx, 4, sSecretBasePCMenuActions); - InitMenuInUpperLeftCornerPlaySoundWhenAPressed(idx, 4, sSecretBasePCMenuCursorPos); -} - -void sub_8126ABC(void) -{ - sSecretBasePCMenuCursorPos = 0; - ScriptContext2_Enable(); - sub_8126A88(); - sub_8126C08(); -} - -void sub_8126AD8(u8 taskId) -{ - sub_8126ABC(); - gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations; - gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos; - gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->secretBases[0].decorations); - gUnknown_0203A17C.isPlayerRoom = FALSE; - gTasks[taskId].func = sub_8126B80; -} - -void sub_8126B2C(u8 taskId) -{ - sub_8126ABC(); - gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor; - gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos; - gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->playerRoomDecor); - gUnknown_0203A17C.isPlayerRoom = TRUE; - gTasks[taskId].func = sub_8126B80; -} - -void sub_8126B80(u8 taskId) -{ - u8 menuPos; - - if (!gPaletteFade.active) - { - menuPos = GetMenuCursorPos(); - switch (ProcessMenuInput()) - { - default: - PlaySE(SE_SELECT); - sSecretBasePCMenuActions[sSecretBasePCMenuCursorPos].func.void_u8(taskId); - break; - case -2: - sSecretBasePCMenuCursorPos = GetMenuCursorPos(); - if ((s8)menuPos != sSecretBasePCMenuCursorPos) - { - sub_8126C08(); - } - break; - case -1: - PlaySE(SE_SELECT); - SecretBasePC_Cancel(taskId); - break; - } - } -} - -void sub_8126C08(void) -{ - FillWindowPixelBuffer(0, 0x11); - AddTextPrinterParametrized(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3); -} - -void SecretBasePC_Decorate(u8 taskId) -{ - if (CountDecorations() == 0) - { - StringExpandPlaceholders(gStringVar4, gText_NoDecorations); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); - } - else - { - gTasks[taskId].data[11] = 0; - sCurDecorationCategory = DECORCAT_DESK; - SecretBasePC_PrepMenuForSelectingStoredDecors(taskId); - } -} - -void SecretBasePC_PutAway(u8 taskId) -{ - if (!sub_81299AC(taskId)) - { - StringExpandPlaceholders(gStringVar4, gText_NoDecorationsInUse); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); - } - else - { - sub_8126A58(0); - sub_8197434(0, 0); - fade_screen(1, 0); - gTasks[taskId].data[2] = 0; - gTasks[taskId].func = sub_8129ABC; - } -} - -void SecretBasePC_Toss(u8 taskId) -{ - if (CountDecorations() == 0) - { - StringExpandPlaceholders(gStringVar4, gText_NoDecorations); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); - } - else - { - gTasks[taskId].data[11] = 1; - sCurDecorationCategory = DECORCAT_DESK; - SecretBasePC_PrepMenuForSelectingStoredDecors(taskId); - } -} - -void SecretBasePC_Cancel(u8 taskId) -{ - sub_8126A58(0); - if (!gUnknown_0203A17C.isPlayerRoom) - { - ScriptContext1_SetupScript(gUnknown_0823B4E8); - DestroyTask(taskId); - } - else - { - sub_816B060(taskId); - } -} - -void sub_8126DA4(u8 taskId) -{ - sub_8126C08(); - gTasks[taskId].func = sub_8126B80; -} - -void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId) -{ - LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20); - sub_8197434(0, 0); - sub_8126A58(0); - sub_8126DFC(taskId); -} - -void sub_8126DFC(u8 taskId) -{ - u8 winIdx; - - winIdx = sub_81269D4(1); - sub_8126E8C(taskId); - InitMenuInUpperLeftCornerPlaySoundWhenAPressed(winIdx, 9, sCurDecorationCategory); - gTasks[taskId].func = sub_8127088; -} - -void sub_8126E44(u8 taskId) -{ - FillWindowPixelBuffer(sDecorMenuWindowIndices[1], 0x11); - sub_8126E8C(taskId); - InitMenuInUpperLeftCornerPlaySoundWhenAPressed(sDecorMenuWindowIndices[1], 9, sCurDecorationCategory); - gTasks[taskId].func = sub_8127088; -} - -void sub_8126E8C(u8 taskId) -{ - s16 *data; - u8 r5; - bool8 r8; - u8 i; - bool8 fl; - - data = gTasks[taskId].data; - r5 = sDecorMenuWindowIndices[1]; - fl = gUnknown_0203A17C.isPlayerRoom; - r8 = FALSE; - if (fl == TRUE && data[11] == 0) - { - r8 = TRUE; - } - for (i = 0; i < 8; i ++) - { - if (r8 == TRUE && i != DECORCAT_DOLL && i != DECORCAT_CUSHION) - { - sub_8126F68(r5, i, 8, i << 4, TRUE, 0xFF); - } - else - { - sub_8126F68(r5, i, 8, i << 4, FALSE, 0xFF); - } - } - PrintTextOnWindow(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0); - schedule_bg_copy_tilemap_to_vram(0); -} - -void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed) -{ - u8 width; - u8 *strbuf; - - width = x == 8 ? 0x68 : 0x60; - y ++; - sub_8127058(gStringVar4, flag); - strbuf = StringLength(gStringVar4) + gStringVar4; - StringCopy(strbuf, sDecorCatNames[decorCat]); - PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL); - strbuf = ConvertIntToDecimalStringN(strbuf, CountDecorationCategoryN(decorCat), STR_CONV_MODE_RIGHT_ALIGN, 2); - *strbuf++ = CHAR_SLASH; - ConvertIntToDecimalStringN(strbuf, gDecorationInventories[decorCat].size, STR_CONV_MODE_RIGHT_ALIGN, 2); - x = GetStringRightAlignXOffset(1, gStringVar4, width); - PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL); -} - -void sub_8127058(u8 *str, bool8 flag) -{ - StringCopy(str, gText_Color161Shadow161); - if (flag == TRUE) - { - str[2] = 0x04; // RED - str[5] = 0x05; // LIGHT_RED - } - else - { - str[2] = 0x02; // DARK_GREY - str[5] = 0x03; // LIGHT_GREY - } -} - -void sub_8127088(u8 taskId) -{ - s8 input; - - if (!gPaletteFade.active) - { - input = ProcessMenuInput(); - switch (input) - { - case -1: - case 8: - PlaySE(SE_SELECT); - sub_812719C(taskId); - break; - case -2: - break; - default: - PlaySE(SE_SELECT); - sCurDecorationCategory = input; - sub_81270E8(taskId); - break; - } - } -} - -void sub_81270E8(u8 taskId) -{ - sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory); - if (sCurDecorCatCount != 0) - { - CondenseDecorationCategoryN(sCurDecorationCategory); - gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items; - IdentifyOwnedDecorationsCurrentlyInUse(taskId); - sSecretBasePCSelectDecorPageNo = 0; - sSecretBasePCSelectDecorLineNo = 0; - gTasks[taskId].func = sub_8127620; - } - else - { - sub_8126A58(1); - StringExpandPlaceholders(gStringVar4, gText_NoDecorations); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127180); - } -} - -void sub_8127180(u8 taskId) -{ - sub_8197434(0, 0); - sub_8126DFC(taskId); -} - -void sub_812719C(u8 taskId) -{ - if (gTasks[taskId].data[11] != 2) - { - sub_81271CC(taskId); - } - else - { - sub_8127268(taskId); - } -} - -void sub_81271CC(u8 taskId) -{ - sub_8126A58(1); - sub_8126A88(); - sub_81973C4(0, 0); - sub_8126C08(); - gTasks[taskId].func = sub_8126B80; -} - -void sub_8127208(u8 taskId) -{ - LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20); - sub_8197434(0, 0); - gTasks[taskId].data[11] = 2; - sCurDecorationCategory = DECORCAT_DESK; - sub_8126DFC(taskId); -} - -void sub_8127250(u8 *dest, u8 decorCat) -{ - StringCopy(dest, sDecorCatNames[decorCat]); -} - -void sub_8127268(u8 taskId) -{ - sub_8126A58(1); - sub_8133E1C(taskId); -} - -void sub_8127284(void) -{ - sDecorPCBuffer->unk_520 = sCurDecorCatCount + 1; - if (sDecorPCBuffer->unk_520 > 8) - { - sDecorPCBuffer->unk_521 = 8; - } - else - { - sDecorPCBuffer->unk_521 = sDecorPCBuffer->unk_520; - } -} - -void sub_81272C8(void) -{ - sub_812225C(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520); -} - -void sub_81272F8(void) -{ - sub_8122298(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520, 8); -} - -void sub_8127330(u8 taskId) -{ - s16 *data; - u16 i; - - data = gTasks[taskId].data; - if ((sCurDecorationCategory < DECORCAT_DOLL || sCurDecorationCategory > DECORCAT_CUSHION) && gUnknown_0203A17C.isPlayerRoom == TRUE && data[11] == 0) - { - sub_8127058(gStringVar1, TRUE); - } - else - { - sub_8127058(gStringVar1, FALSE); - } - for (i = 0; i < sDecorPCBuffer->unk_520 - 1; i ++) - { - sub_8127454(sDecorPCBuffer->names[i], gCurDecorInventoryItems[i]); - sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i]; - sDecorPCBuffer->items[i].unk_04 = i; - } - StringCopy(sDecorPCBuffer->names[i], gText_Cancel); - sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i]; - sDecorPCBuffer->items[i].unk_04 = -2; - gUnknown_03006310 = gUnknown_085A6BD0; - gUnknown_03006310.unk_10 = sDecorMenuWindowIndices[1]; - gUnknown_03006310.unk_0c = sDecorPCBuffer->unk_520; - gUnknown_03006310.unk_00 = sDecorPCBuffer->items; - gUnknown_03006310.unk_0e = sDecorPCBuffer->unk_521; -} - -void sub_8127454(u8 *dest, u16 decorId) -{ - StringCopy(dest, gStringVar1); - StringAppend(dest, gDecorations[decorId].name); -} - -void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu) -{ - if (flag != TRUE) - { - PlaySE(SE_SELECT); - } - sub_8127744(a0); -} - -void sub_81274A0(u8 a0, s32 a1, u8 a2) -{ - if (a1 != -2) - { - if (sub_81277BC(a1 + 1) == TRUE) - { - blit_move_info_icon(a0, 0x18, 0x5c, a2 + 2); - } - else if (sub_81277E8(a1 + 1) == TRUE) - { - blit_move_info_icon(a0, 0x19, 0x5c, a2 + 2); - } - } -} - -void sub_8127500(void) -{ - if (sDecorPCBuffer->unk_522 == 0xFF) - { - sDecorPCBuffer->unk_522 = AddScrollIndicatorArrowPairParametrized(0x02, 0x3c, 0x0c, 0x94, sDecorPCBuffer->unk_520 - sDecorPCBuffer->unk_521, 0x6e, 0x6e, &sSecretBasePCSelectDecorPageNo); - } -} - -void sub_8127554(void) -{ - if (sDecorPCBuffer->unk_522 != 0xFF) - { - RemoveScrollIndicatorArrowPair(sDecorPCBuffer->unk_522); - sDecorPCBuffer->unk_522 = 0xFF; - } -} - -void sub_8127580(u8 taskId) -{ - sub_81269D4(1); - sub_812759C(taskId); -} - -void sub_812759C(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - sub_81269D4(3); - sub_8127718(sCurDecorationCategory); - sDecorPCBuffer = calloc(1, sizeof(struct DecorPCBuffer)); - sDecorPCBuffer->unk_522 = 0xFF; - sub_8127284(); - sub_81272C8(); - sub_81272F8(); - sub_8127330(taskId); - data[13] = ListMenuInit(&gUnknown_03006310, sSecretBasePCSelectDecorPageNo, sSecretBasePCSelectDecorLineNo); - sub_8127500(); -} - -void sub_8127620(u8 taskId) -{ - sub_812759C(taskId); - gTasks[taskId].func = sub_812764C; -} - -void sub_812764C(u8 taskId) -{ - s16 *data; - s32 input; - - data = gTasks[taskId].data; - if (!gPaletteFade.active) - { - input = ListMenuHandleInput(data[13]); - get_coro_args_x18_x1A(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo); - switch (input) - { - case -1: - break; - case -2: - PlaySE(SE_SELECT); - SecretBasePC_SelectedDecorActions[data[11]][1](taskId); - break; - default: - PlaySE(SE_SELECT); - gCurDecorationIndex = input; - sub_8127554(); - sub_81AE6C8(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo); - sub_8126A58(1); - sub_81277A8(); - free(sDecorPCBuffer); - SecretBasePC_SelectedDecorActions[data[11]][0](taskId); - break; - } - } -} - -void sub_8127718(u8 decorCat) -{ - sub_8126F68(sub_81269D4(2), decorCat, 0, 0, 0, 0); -} - -void sub_8127744(u32 a0) -{ - u8 winidx; - const u8 *txt; - - winidx = sDecorMenuWindowIndices[3]; - FillWindowPixelBuffer(winidx, 0x11); - if (a0 >= sCurDecorCatCount) - { - txt = gText_GoBackPrevMenu; - } - else - { - txt = gDecorations[gCurDecorInventoryItems[a0]].description; - } - PrintTextOnWindow(winidx, 1, txt, 0, 1, 0, 0); -} - -void sub_81277A8(void) -{ - sub_8126A58(3); - sub_8126A58(2); -} - -bool8 sub_81277BC(u8 idx) -{ - u8 i; - - for (i = 0; i < 16; i ++) - { - if (sSecretBaseItemsIndicesBuffer[i] == idx) - { - return TRUE; - } - } - return FALSE; -} - -bool8 sub_81277E8(u8 idx) -{ - u8 i; - - for (i = 0; i < 12; i ++) - { - if (sPlayerRoomItemsIndicesBuffer[i] == idx) - { - return TRUE; - } - } - return FALSE; -} - -void IdentifyOwnedDecorationsCurrentlyInUseInternal(u8 taskId) -{ - u16 i; - u16 j; - u16 k; - u16 cnt; - - cnt = 0; - memset(sSecretBaseItemsIndicesBuffer, 0, 16); - memset(sPlayerRoomItemsIndicesBuffer, 0, 12); - for (i = 0; i < 16; i ++) - { - if (gSaveBlock1Ptr->secretBases[0].decorations[i] != DECOR_NONE) - { - for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++) - { - if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->secretBases[0].decorations[i]) - { - for (k = 0; k < cnt && sSecretBaseItemsIndicesBuffer[k] != j + 1; k ++); - if (k == cnt) - { - sSecretBaseItemsIndicesBuffer[cnt] = j + 1; - cnt ++; - break; - } - } - } - } - } - cnt = 0; - for (i = 0; i < 12; i ++) - { - if (gSaveBlock1Ptr->playerRoomDecor[i] != DECOR_NONE) - { - for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++) - { - if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->playerRoomDecor[i] && sub_81277BC(j + 1) != TRUE) - { - for (k = 0; k < cnt && sPlayerRoomItemsIndicesBuffer[k] != j + 1; k ++); - if (k == cnt) - { - sPlayerRoomItemsIndicesBuffer[cnt] = j + 1; - cnt ++; - break; - } - } - } - } - } -} - -void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId) -{ - IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); -} - -bool8 IsSelectedDecorInThePC(void) -{ - u16 i; - for (i = 0; i < 16; i ++) - { - if (sSecretBaseItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1) - { - return FALSE; - } - if (i < 12 && sPlayerRoomItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1) - { - return FALSE; - } - } - return TRUE; -} - -void sub_8127A14(u8 taskId) -{ - sub_81269D4(1); - sub_8127620(taskId); -} - -void sub_8127A30(u8 taskId) -{ - sub_8197434(0, 0); - gTasks[taskId].func = sub_8127A14; -} - -void sub_8127A5C(u8 taskId) -{ - if (gMain.newKeys & (A_BUTTON | B_BUTTON)) - { - sub_8197434(0, 0); - sub_81269D4(1); - sub_8127620(taskId); - } -} - -void sub_8127A8C(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - sub_8127554(); - sub_81277A8(); - sub_81AE6C8(data[13], NULL, NULL); - free(sDecorPCBuffer); - sub_8126E44(taskId); -} - -void sub_8127ACC(u8 taskId) -{ - gTasks[taskId].data[3] = gSaveBlock1Ptr->pos.x; - gTasks[taskId].data[4] = gSaveBlock1Ptr->pos.y; - PlayerGetDestCoords(&gTasks[taskId].data[0], &gTasks[taskId].data[1]); -} - -void sub_8127B04(u8 taskId) -{ - DrawWholeMapView(); - Overworld_SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, gTasks[taskId].data[3], gTasks[taskId].data[4]); - warp_in(); -} - -u16 sub_8127B54(u8 decor, u8 a1) -{ - u16 resp; - - resp = -1; - switch (decor) - { - case DECOR_STAND: - resp = gUnknown_085A72E4[a1] << 12; - return resp; - case DECOR_SLIDE: - resp = gUnknown_085A72EC[a1] << 12; - return resp; - default: - return resp; - } -} - -void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor) -{ - u16 i; - u16 j; - u16 behavior; - u16 flags; - u16 v0; - u16 v1; - s16 decLeft; - s16 decBottom; - - for (i = 0; i < decHeight; i ++) - { - decBottom = mapY - decHeight + 1 + i; - for (j = 0; j < decWidth; j ++) - { - decLeft = mapX + j; - behavior = GetBehaviorByMetatileId(0x200 + gDecorations[decor].tiles[i * decWidth + j]); - if (MetatileBehavior_IsMB_B9(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12))) - { - flags = 0xc00; - } - else - { - flags = 0x000; - } - if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE) - { - v0 = 1; - } - else - { - v0 = 0; - } - v1 = sub_8127B54(gDecorations[decor].id, i * decWidth + j); - if (v1 != 0xFFFF) - { - MapGridSetMetatileEntryAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags | v1); - } - else - { - MapGridSetMetatileIdAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags); - } - } - } -} - -void sub_8127D38(u16 mapX, u16 mapY, u16 decor) -{ - switch (gDecorations[decor].shape) - { - case DECORSHAPE_1x1: - sub_8127B90(mapX, mapY, 1, 1, decor); - break; - case DECORSHAPE_2x1: - sub_8127B90(mapX, mapY, 2, 1, decor); - break; - case DECORSHAPE_3x1: // unused - sub_8127B90(mapX, mapY, 3, 1, decor); - break; - case DECORSHAPE_4x2: - sub_8127B90(mapX, mapY, 4, 2, decor); - break; - case DECORSHAPE_2x2: - sub_8127B90(mapX, mapY, 2, 2, decor); - break; - case DECORSHAPE_1x2: - sub_8127B90(mapX, mapY, 1, 2, decor); - break; - case DECORSHAPE_1x3: // unused - sub_8127B90(mapX, mapY, 1, 3, decor); - break; - case DECORSHAPE_2x4: - sub_8127B90(mapX, mapY, 2, 4, decor); - break; - case DECORSHAPE_3x3: - sub_8127B90(mapX, mapY, 3, 3, decor); - break; - case DECORSHAPE_3x2: - sub_8127B90(mapX, mapY, 3, 2, decor); - break; - } -} - -void sub_8127E18(void) -{ - u8 i; - u8 j; - - for (i = 0; i < 14; i ++) - { - if (FlagGet(0xAE + i) == TRUE) - { - FlagClear(0xAE + i); - for (j = 0; j < gMapHeader.events->mapObjectCount; j ++) - { - if (gMapHeader.events->mapObjects[j].flagId == 0xAE + i) - { - break; - } - } - VarSet(0x3F20 + gMapHeader.events->mapObjects[j].graphicsId, sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0]); - gSpecialVar_0x8005 = gMapHeader.events->mapObjects[j].localId; - gSpecialVar_0x8006 = sCurDecorMapX; - gSpecialVar_0x8007 = sCurDecorMapY; - show_sprite(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); - sub_808EBA8(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gSpecialVar_0x8006, gSpecialVar_0x8007); - sub_808F254(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); - break; - } - } -} - -bool8 sub_8127F38(void) -{ - u16 i; - - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - if (gUnknown_0203A17C.items[i] == DECOR_NONE) - { - return TRUE; - } - } - return FALSE; -} - -void sub_8127F68(u8 taskId) -{ - if (gUnknown_0203A17C.isPlayerRoom == TRUE && sCurDecorationCategory != DECORCAT_DOLL && sCurDecorationCategory != DECORCAT_CUSHION) - { - StringExpandPlaceholders(gStringVar4, gText_CantPlaceInRoom); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); - } - else if (IsSelectedDecorInThePC() == TRUE) - { - if (sub_8127F38() == TRUE) - { - fade_screen(1, 0); - gTasks[taskId].data[2] = 0; - gTasks[taskId].func = sub_8128060; - } - else - { - ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203A17C.size, STR_CONV_MODE_RIGHT_ALIGN, 2); - if (gUnknown_0203A17C.isPlayerRoom == FALSE) { - StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations); - } - else - { - StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations2); - } - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); - } - } - else - { - StringExpandPlaceholders(gStringVar4, gText_InUseAlready); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); - } -} - -void sub_8128060(u8 taskId) -{ - switch (gTasks[taskId].data[2]) - { - case 0: - if (!gPaletteFade.active) - { - sub_8127ACC(taskId); - gTasks[taskId].data[2] = 1; - } - break; - case 1: - gPaletteFade.bufferTransferDisabled = TRUE; - ConfigureCameraObjectForPlacingDecoration(&sPlaceDecorationGraphicsDataBuffer, gCurDecorInventoryItems[gCurDecorationIndex]); - sub_812826C(taskId); - SetUpPlacingDecorationPlayerAvatar(taskId, &sPlaceDecorationGraphicsDataBuffer); - pal_fill_black(); - gPaletteFade.bufferTransferDisabled = FALSE; - gTasks[taskId].data[2] = 2; - break; - case 2: - if (sub_80ABDFC() == TRUE) - { - gTasks[taskId].data[12] = 0; - sub_8128FD8(taskId); - } - break; - } -} - -void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor) -{ - sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0; - gUnknown_03005DD0.unk4 = gpu_pal_decompress_alloc_tag_and_upload(data, decor); - gSprites[gUnknown_03005DD0.unk4].oam.priority = 1; - gSprites[gUnknown_03005DD0.unk4].callback = sub_81292D0; - gSprites[gUnknown_03005DD0.unk4].pos1.x = gUnknown_085A7250[data->decoration->shape].x; - gSprites[gUnknown_03005DD0.unk4].pos1.y = gUnknown_085A7250[data->decoration->shape].y; -} - -void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data) -{ - u8 v0; - - v0 = 16 * (u8)gTasks[taskId].data[5] + gUnknown_085A7250[data->decoration->shape].x - 8 * ((u8)gTasks[taskId].data[5] - 1); - if (data->decoration->shape == DECORSHAPE_3x1 || data->decoration->shape == DECORSHAPE_3x3 || data->decoration->shape == DECORSHAPE_3x2) - { - v0 -= 8; - } - if (gSaveBlock2Ptr->playerGender == MALE) - { - sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, v0, 0x48, 0); - } - else - { - sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, v0, 0x48, 0); - } - gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1; - DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]); - sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4; -} - -void sub_812826C(u8 taskId) -{ - switch (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].shape) - { - case DECORSHAPE_1x1: - gTasks[taskId].data[5] = 1; - gTasks[taskId].data[6] = 1; - break; - case DECORSHAPE_2x1: - gTasks[taskId].data[5] = 2; - gTasks[taskId].data[6] = 1; - break; - case DECORSHAPE_3x1: - gTasks[taskId].data[5] = 3; - gTasks[taskId].data[6] = 1; - break; - case DECORSHAPE_4x2: - gTasks[taskId].data[5] = 4; - gTasks[taskId].data[6] = 2; - break; - case DECORSHAPE_2x2: - gTasks[taskId].data[5] = 2; - gTasks[taskId].data[6] = 2; - break; - case DECORSHAPE_1x2: - gTasks[taskId].data[5] = 1; - gTasks[taskId].data[6] = 2; - break; - case DECORSHAPE_1x3: - gTasks[taskId].data[5] = 1; - gTasks[taskId].data[6] = 3; - gTasks[taskId].data[1]++; - break; - case DECORSHAPE_2x4: - gTasks[taskId].data[5] = 2; - gTasks[taskId].data[6] = 4; - break; - case DECORSHAPE_3x3: - gTasks[taskId].data[5] = 3; - gTasks[taskId].data[6] = 3; - break; - case DECORSHAPE_3x2: - gTasks[taskId].data[5] = 3; - gTasks[taskId].data[6] = 2; - break; - } -} - -void sub_81283BC(u8 taskId) -{ - gTasks[taskId].data[10] = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1; - gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1; - sub_8128DE0(); - sub_8128950(taskId); -} - -void sub_8128414(u8 taskId) -{ - gTasks[taskId].data[10] = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1; - gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1; - sub_8128DE0(); - StringExpandPlaceholders(gStringVar4, gText_CancelDecorating); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8128B80); -} - -bool8 sub_8128484(u8 behaviorAt, u16 behaviorBy) -{ - if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE || behaviorBy != 0) - { - return FALSE; - } - return TRUE; -} - -bool8 sub_81284AC(u8 taskId, s16 x, s16 y, u16 decor) -{ - if (x == gTasks[taskId].data[3] + 7 && y == gTasks[taskId].data[4] + 7 && decor != DECOR_NONE) - { - return FALSE; - } - return TRUE; -} - -bool8 sub_81284F4(u16 behaviorAt, const struct Decoration *decoration) -{ - if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE) - { - if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsMB_C2(behaviorAt) == TRUE) - { - return TRUE; - } - if (MetatileBehavior_IsNormal(behaviorAt)) - { - return TRUE; - } - } - return FALSE; -} - -bool8 sub_812853C(u8 taskId, const struct Decoration *decoration) -{ - u8 i; - u8 j; - u8 behaviorAt; - u16 behaviorBy; - u8 mapY; - u8 mapX; - s16 curY; - s16 curX; - mapY = gTasks[taskId].data[6]; - mapX = gTasks[taskId].data[5]; - - switch (decoration->permission) - { - case DECORPERM_SOLID_FLOOR: - case DECORPERM_PASS_FLOOR: - for (i=0; itiles[(mapY - 1 - i) * mapX + j]) & 0xf000; - if (!sub_81284F4(behaviorAt, decoration)) - { - return FALSE; - } - if (!sub_81284AC(taskId, curX, curY, behaviorBy)) - { - return FALSE; - } - behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0); - if (behaviorAt != 0 && behaviorAt != 16) - { - return FALSE; - } - } - } - break; - case DECORPERM_BEHIND_FLOOR: - for (i=0; itiles[(mapY - 1 - i) * mapX + j]) & 0xf000; - if (!MetatileBehavior_IsNormal(behaviorAt) && !sub_8128484(behaviorAt, behaviorBy)) - { - return FALSE; - } - if (!sub_81284AC(taskId, curX, curY, behaviorBy)) - { - return FALSE; - } - if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16) - { - return FALSE; - } - } - } - curY = gTasks[taskId].data[1] - mapY + 1; - for (j=0; jtiles[j]) & 0xf000; - if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsMB_B7(behaviorAt)) - { - return FALSE; - } - if (!sub_81284AC(taskId, curX, curY, behaviorBy)) - { - return FALSE; - } - behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0); - if (behaviorAt != 0 && behaviorAt != 16) - { - return FALSE; - } - } - break; - case DECORPERM_NA_WALL: - for (i=0; ishape == DECORSHAPE_1x2) - { - if (!MetatileBehavior_IsMB_C3(behaviorAt)) - { - return FALSE; - } - } - else if (!MetatileBehavior_IsMB_B5(behaviorAt)) - { - if (!MetatileBehavior_IsMB_C3(behaviorAt)) - { - return FALSE; - } - } - if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16) - { - return FALSE; - } - } - break; - } - return TRUE; -} - -void sub_8128950(u8 taskId) -{ - if (sub_812853C(taskId, &gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]]) == TRUE) - { - StringExpandPlaceholders(gStringVar4, gText_PlaceItHere); - DisplayItemMessageOnField(taskId, gStringVar4, sub_81289D0); - } - else - { - PlaySE(SE_HAZURE); - StringExpandPlaceholders(gStringVar4, gText_CantBePlacedHere); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8129020); - } -} - -void sub_81289D0(u8 taskId) -{ - sub_8197930(); - sub_8121F68(taskId, &gUnknown_085A72C4); -} - -void sub_81289F0(u8 taskId) -{ - sub_8197434(0, 0); - sub_8128AAC(taskId); - if (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].permission != DECORPERM_SOLID_MAT) - { - sub_8127D38(gTasks[taskId].data[0], gTasks[taskId].data[1], gCurDecorInventoryItems[gCurDecorationIndex]); - } - else - { - sCurDecorMapX = gTasks[taskId].data[0] - 7; - sCurDecorMapY = gTasks[taskId].data[1] - 7; - ScriptContext1_SetupScript(gUnknown_08275D1F); - } - gSprites[sDecor_CameraSpriteObjectIdx1].pos1.y += 2; - if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE) - { - TV_PutSecretBaseVisitOnTheAir(); - } - sub_8128BBC(taskId); -} - -void sub_8128AAC(u8 taskId) -{ - u16 i; - - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - if (gUnknown_0203A17C.items[i] == DECOR_NONE) - { - gUnknown_0203A17C.items[i] = gCurDecorInventoryItems[gCurDecorationIndex]; - gUnknown_0203A17C.pos[i] = ((gTasks[taskId].data[0] - 7) << 4) + (gTasks[taskId].data[1] - 7); - break; - } - } - if (!gUnknown_0203A17C.isPlayerRoom) - { - for (i = 0; i < 16; i ++) - { - if (sSecretBaseItemsIndicesBuffer[i] == 0) - { - sSecretBaseItemsIndicesBuffer[i] = gCurDecorationIndex + 1; - break; - } - } - } - else - { - for (i = 0; i < 12; i ++) - { - if (sPlayerRoomItemsIndicesBuffer[i] == 0) - { - sPlayerRoomItemsIndicesBuffer[i] = gCurDecorationIndex + 1; - break; - } - } - } -} - -void sub_8128B80(u8 taskId) -{ - sub_8197930(); - sub_8121F68(taskId, &gUnknown_085A72CC); -} - -void sub_8128BA0(u8 taskId) -{ - sub_8197434(0, 0); - sub_8128BBC(taskId); -} - -void sub_8128BBC(u8 taskId) -{ - fade_screen(1, 0); - gTasks[taskId].data[2] = 0; - gTasks[taskId].func = c1_overworld_prev_quest; -} - -void c1_overworld_prev_quest(u8 taskId) -{ - switch (gTasks[taskId].data[2]) - { - case 0: - ScriptContext2_Enable(); - if (!gPaletteFade.active) - { - sub_8127B04(taskId); - gTasks[taskId].data[2] = 1; - } - break; - case 1: - sub_812A3C8(); - FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG); - gFieldCallback = sub_8128CD4; - SetMainCallback2(c2_exit_to_overworld_2_switch); - DestroyTask(taskId); - break; - } -} - -void sub_8128C64(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - switch (data[2]) - { - case 0: - sub_80E9578(); - data[2] ++; - break; - case 1: - ScriptContext1_SetupScript(gUnknown_08275D0C); - data[2] ++; - break; - case 2: - ScriptContext2_Enable(); - data[2] ++; - break; - case 3: - if (sub_80ABDFC() == TRUE) - { - gTasks[taskId].func = sub_812764C; - } - break; - } -} - -void sub_8128CD4(void) -{ - u8 taskId; - - ScriptContext2_Enable(); - pal_fill_black(); - taskId = CreateTask(sub_8128C64, 8); - sub_8127580(taskId); - gTasks[taskId].data[2] = 0; -} - -bool8 sub_8128D10(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - if (sDecorationLastDirectionMoved == DIR_SOUTH && data[1] - data[6] - 6 < 0) - { - data[1] ++; - return FALSE; - } - if (sDecorationLastDirectionMoved == DIR_NORTH && data[1] - 7 >= gMapHeader.mapData->height) - { - data[1] --; - return FALSE; - } - if (sDecorationLastDirectionMoved == DIR_WEST && data[0] - 7 < 0) - { - data[0] ++; - return FALSE; - } - if (sDecorationLastDirectionMoved == DIR_EAST && data[0] + data[5] - 8 >= gMapHeader.mapData->width) - { - data[0] --; - return FALSE; - } - return TRUE; -} - -bool8 sub_8128DB4(void) -{ - u16 heldKeys; - - heldKeys = gMain.heldKeys & 0x0F0; - if (heldKeys != DPAD_UP && heldKeys != DPAD_DOWN && heldKeys != DPAD_LEFT && heldKeys != DPAD_RIGHT) - { - return FALSE; - } - return TRUE; -} - -void sub_8128DE0(void) -{ - sDecorationLastDirectionMoved = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; -} - -void sub_8128E18(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - if (!gSprites[sDecor_CameraSpriteObjectIdx1].data4) - { - if (data[10] == 1) - { - gUnknown_085A72D4[data[12]].yesFunc(taskId); - return; - } else if (data[10] == 2) - { - gUnknown_085A72D4[data[12]].noFunc(taskId); - return; - } - if ((gMain.heldKeys & 0x0F0) == DPAD_UP) - { - sDecorationLastDirectionMoved = DIR_SOUTH; - gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data3 = -2; - data[1]--; - } - if ((gMain.heldKeys & 0x0F0) == DPAD_DOWN) - { - sDecorationLastDirectionMoved = DIR_NORTH; - gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 2; - data[1]++; - } - if ((gMain.heldKeys & 0x0F0) == DPAD_LEFT) - { - sDecorationLastDirectionMoved = DIR_WEST; - gSprites[sDecor_CameraSpriteObjectIdx1].data2 = -2; - gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; - data[0]--; - } - if ((gMain.heldKeys & 0x0F0) == DPAD_RIGHT) - { - sDecorationLastDirectionMoved = DIR_EAST; - gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 2; - gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; - data[0]++; - } - if (!sub_8128DB4() || !sub_8128D10(taskId)) - { - sub_8128DE0(); - } - } - if (sDecorationLastDirectionMoved) - { - gSprites[sDecor_CameraSpriteObjectIdx1].data4++; - gSprites[sDecor_CameraSpriteObjectIdx1].data4 &= 7; - } - if (!data[10]) - { - if (gMain.newKeys & A_BUTTON) - { - data[10] = A_BUTTON; - } - if (gMain.newKeys & B_BUTTON) - { - data[10] = B_BUTTON; - } - } -} - -void sub_8128FD8(u8 taskId) -{ - sub_8197434(0, 1); - gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0; - gTasks[taskId].data[10] = 0; - gTasks[taskId].func = sub_8128E18; -} - -void sub_8129020(u8 taskId) -{ - if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) - { - sub_8128FD8(taskId); - } -} - -void sub_8129048(struct PlaceDecorationGraphicsDataBuffer *data) -{ - CpuFill16(0, data, sizeof(*data)); -} - -void sub_8129068(u16 *dest, u16 pal) -{ - CpuFastCopy(&((u16 *)gTilesetPointer_SecretBase->palettes)[pal << 4], dest, 32); -} - -void sub_8129088(u8 *dest, u16 tile) -{ - u8 buffer[32]; - u16 mode; - u16 i; - - mode = tile >> 10; - if (tile != 0) - { - tile &= 0x03FF; - } - CpuFastCopy(&((u8 *)gTilesetPointer_SecretBase->tiles)[tile << 5], buffer, 32); - switch (mode) - { - case 0: - CpuFastCopy(buffer, dest, 32); - break; - case 1: - for (i = 0; i < 8; i ++) - { - dest[4 * i] = (buffer[4 * (i + 1) - 1] >> 4) + ((buffer[4 * (i + 1) - 1] & 0x0F) << 4); - dest[4 * i + 1] = (buffer[4 * (i + 1) - 2] >> 4) + ((buffer[4 * (i + 1) - 2] & 0x0F) << 4); - dest[4 * i + 2] = (buffer[4 * (i + 1) - 3] >> 4) + ((buffer[4 * (i + 1) - 3] & 0x0F) << 4); - dest[4 * i + 3] = (buffer[4 * (i + 1) - 4] >> 4) + ((buffer[4 * (i + 1) - 4] & 0x0F) << 4); - } - break; - case 2: - for (i = 0; i < 8; i ++) - { - dest[4 * i] = buffer[4 * (7 - i)]; - dest[4 * i + 1] = buffer[4 * (7 - i) + 1]; - dest[4 * i + 2] = buffer[4 * (7 - i) + 2]; - dest[4 * i + 3] = buffer[4 * (7 - i) + 3]; - } - break; - case 3: - for (i = 0; i < 32; i ++) - { - dest[i] = (buffer[31 - i] >> 4) + ((buffer[31 - i] & 0x0F) << 4); - } - break; - } -} - -void sub_81291A4(struct PlaceDecorationGraphicsDataBuffer *data) -{ - u16 i; - for (i = 0; i < 64; i ++) - { - sub_8129088(&data->image[i * 32], data->tiles[i]); - } -} - -u16 sub_81291CC(u16 tile) -{ - return ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[tile] & 0xFFF; -} - -void sub_81291E8(struct PlaceDecorationGraphicsDataBuffer *data) -{ - u8 i; - u8 shape; - - shape = data->decoration->shape; - for (i = 0; i < gUnknown_085A71B0[shape].size; i ++) - { - data->tiles[gUnknown_085A71B0[shape].tiles[i]] = sub_81291CC(data->decoration->tiles[gUnknown_085A71B0[shape].y[i]] * 8 + gUnknown_085A71B0[shape].x[i]); - } -} - -void SetDecorSelectionBoxOamAttributes(u8 decorShape) -{ - sDecorSelectorOam.y = 0; - sDecorSelectorOam.affineMode = ST_OAM_AFFINE_OFF; - sDecorSelectorOam.objMode = ST_OAM_OBJ_NORMAL; - sDecorSelectorOam.mosaic = 0; - sDecorSelectorOam.bpp = ST_OAM_4BPP; - sDecorSelectorOam.shape = gUnknown_085A7250[decorShape].shape; - sDecorSelectorOam.x = 0; - sDecorSelectorOam.matrixNum = 0; - sDecorSelectorOam.size = gUnknown_085A7250[decorShape].size; - sDecorSelectorOam.tileNum = 0; - sDecorSelectorOam.priority = 0; - sDecorSelectorOam.paletteNum = 0; -} - -void sub_81292D0(struct Sprite *sprite) -{ - sprite->data2 = 0; - sprite->data3 = 0; - sprite->data4 = 0; - sprite->data5 = 0; - sprite->data6 = 0; - sprite->data7 = 0; - sprite->callback = sub_81292E8; -} - -void sub_81292E8(struct Sprite *sprite) -{ - if (sprite->data7 == 0) - { - if (sprite->data6 < 15) - { - sprite->invisible = FALSE; - } - else - { - sprite->invisible = TRUE; - } - sprite->data6 ++; - sprite->data6 &= 0x1F; - } - else - { - sprite->invisible = FALSE; - } -} - -u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor) -{ - sub_8129048(data); - data->decoration = &gDecorations[decor]; - if (data->decoration->permission == DECORPERM_SOLID_MAT) - { - return AddPseudoFieldObject(data->decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1); - } - FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG); - sub_81291E8(data); - SetDecorSelectionBoxOamAttributes(data->decoration->shape); - sub_81291A4(data); - sub_8129068(data->palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(data->decoration->tiles[0] * 8) + 7] >> 12); - LoadSpritePalette(&gUnknown_085A72BC); - return CreateSprite(&sDecorSelectorSpriteTemplate, 0, 0, 0); -} - -u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor) -{ - struct SpriteSheet sheet; - struct CompressedSpritePalette palette; - struct SpriteTemplate *template; - u8 spriteId; - - if (!AllocItemIconTemporaryBuffers()) - { - return MAX_SPRITES; - } - LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gUnknown_0203CEBC); - CopyItemIconPicTo4x4Buffer(gUnknown_0203CEBC, gUnknown_0203CEC0); - sheet.data = gUnknown_0203CEC0; - sheet.size = 0x200; - sheet.tag = tilesTag; - LoadSpriteSheet(&sheet); - palette.data = GetDecorationIconPicOrPalette(decor, 1); - palette.tag = paletteTag; - LoadCompressedObjectPalette(&palette); - template = malloc(sizeof(struct SpriteTemplate)); - *template = gUnknown_08614FF4; - template->tileTag = tilesTag; - template->paletteTag = paletteTag; - spriteId = CreateSprite(template, 0, 0, 0); - FreeItemIconTemporaryBuffers(); - free(template); - return spriteId; -} - -const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode) -{ - if (decor > 120) - { - decor = DECOR_NONE; - } - return gUnknown_085A6BE8[decor][mode]; -} - -u8 AddDecorationIconObjectFromFieldObject(u16 tilesTag, u16 paletteTag, u8 decor) -{ - u8 spriteId; - struct SpriteSheet sheet; - struct SpritePalette palette; - struct SpriteTemplate *template; - - sub_8129048(&sPlaceDecorationGraphicsDataBuffer); - sPlaceDecorationGraphicsDataBuffer.decoration = &gDecorations[decor]; - if (sPlaceDecorationGraphicsDataBuffer.decoration->permission != DECORPERM_SOLID_MAT) - { - sub_81291E8(&sPlaceDecorationGraphicsDataBuffer); - SetDecorSelectionBoxOamAttributes(sPlaceDecorationGraphicsDataBuffer.decoration->shape); - sub_81291A4(&sPlaceDecorationGraphicsDataBuffer); - sub_8129068(sPlaceDecorationGraphicsDataBuffer.palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0] * 8) + 7] >> 12); - sheet.data = sPlaceDecorationGraphicsDataBuffer.image; - sheet.size = gUnknown_085A72F4[sPlaceDecorationGraphicsDataBuffer.decoration->shape] << 5; - sheet.tag = tilesTag; - LoadSpriteSheet(&sheet); - palette.data = sPlaceDecorationGraphicsDataBuffer.palette; - palette.tag = paletteTag; - LoadSpritePalette(&palette); - template = Alloc(sizeof(struct SpriteTemplate)); - *template = sDecorWhilePlacingSpriteTemplate; - template->tileTag = tilesTag; - template->paletteTag = paletteTag; - spriteId = CreateSprite(template, 0, 0, 0); - free(template); - } - else - { - spriteId = AddPseudoFieldObject(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1); - } - return spriteId; -} - -u8 AddDecorationIconObject(u8 decor, s16 x, s16 y, u8 priority, u16 tilesTag, u16 paletteTag) -{ - u8 spriteId; - - if (decor > 120) - { - spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, DECOR_NONE); - if (spriteId == MAX_SPRITES) - { - return MAX_SPRITES; - } - gSprites[spriteId].pos2.x = x + 4; - gSprites[spriteId].pos2.y = y + 4; - } - else if (gUnknown_085A6BE8[decor][0] == NULL) - { - spriteId = AddDecorationIconObjectFromFieldObject(tilesTag, paletteTag, decor); - if (spriteId == MAX_SPRITES) - { - return MAX_SPRITES; - } - gSprites[spriteId].pos2.x = x; - if (decor == DECOR_SILVER_SHIELD || decor == DECOR_GOLD_SHIELD) - { - gSprites[spriteId].pos2.y = y - 4; - } - else - { - gSprites[spriteId].pos2.y = y; - } - } - else - { - spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, decor); - if (spriteId == MAX_SPRITES) - { - return MAX_SPRITES; - } - gSprites[spriteId].pos2.x = x + 4; - gSprites[spriteId].pos2.y = y + 4; - } - gSprites[spriteId].oam.priority = priority; - return spriteId; -} - -void sub_81296EC(u8 idx) -{ - gUnknown_0203A17C.items[idx] = 0; - gUnknown_0203A17C.pos[idx] = 0; -} - -void sub_8129708(void) -{ - u16 i; - - gSpecialVar_0x8005 = 0; - gScriptResult = 0; - if (gSpecialVar_0x8004 == sCurDecorSelectedInRearrangement) - { - gScriptResult = 1; - } - else if (gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx]].permission == DECORPERM_SOLID_MAT) - { - gSpecialVar_0x8005 = sDecorRearrangementDataBuffer[gSpecialVar_0x8004].flagId; - sub_81296EC(sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx); - for (i = 0; i < gMapHeader.events->mapObjectCount; i ++) - { - if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8005) - { - gSpecialVar_0x8006 = gMapHeader.events->mapObjects[i].localId; - break; - } - } - } -} - -void sub_81297AC(void) -{ - u8 i; - - for (i = 0; i < gMapHeader.events->mapObjectCount; i ++) - { - if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8004) - { - gSpecialVar_0x8005 = gMapHeader.events->mapObjects[i].localId; - break; - } - } -} - -void sub_81297F8(void) -{ - u8 i; - u8 y; - u8 x; - int posX; - int posY; - u8 perm; - - for (i = 0; i < sCurDecorSelectedInRearrangement; i ++) - { - perm = gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[i].idx]].permission; - posX = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] >> 4; - posY = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] & 0x0F; - if (perm != DECORPERM_SOLID_MAT) - { - for (y = 0; y < sDecorRearrangementDataBuffer[i].height; y ++) - { - for (x = 0; x < sDecorRearrangementDataBuffer[i].width; x ++) - { - MapGridSetMetatileEntryAt(posX + 7 + x, posY + 7 - y, gMapHeader.mapData->map[posX + x + gMapHeader.mapData->width * (posY - y)] | 0x3000); - } - } - sub_81296EC(sDecorRearrangementDataBuffer[i].idx); - } - } -} - -void sub_81298EC(u8 taskId) -{ - switch (gTasks[taskId].data[2]) - { - case 0: - sub_81297F8(); - gTasks[taskId].data[2] = 1; - break; - case 1: - if (!gPaletteFade.active) { - DrawWholeMapView(); - ScriptContext1_SetupScript(gUnknown_08275D2E); - sub_8197434(0, 1); - gTasks[taskId].data[2] = 2; - } - break; - case 2: - ScriptContext2_Enable(); - IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); - pal_fill_black(); - gTasks[taskId].data[2] = 3; - break; - case 3: - if (sub_80ABDFC() == TRUE) - { - StringExpandPlaceholders(gStringVar4, gText_DecorationReturnedToPC); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64); - if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE) - { - TV_PutSecretBaseVisitOnTheAir(); - } - } - break; - } -} - - -bool8 sub_81299AC(u8 taskId) -{ - u16 i; - - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - if (gUnknown_0203A17C.items[i] != DECOR_NONE) - { - return TRUE; - } - } - return FALSE; -} - -void SetUpPuttingAwayDecorationPlayerAvatar(void) -{ - player_get_direction_lower_nybble(); - sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0; - sub_812A39C(); - gUnknown_03005DD0.unk4 = CreateSprite(&gUnknown_085A7404, 0x78, 0x50, 0); - if (gSaveBlock2Ptr->playerGender == MALE) - { - sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, 0x88, 0x48, 0); - } - else - { - sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, 0x88, 0x48, 0); - } - gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1; - DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]); - sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4; - gSprites[sDecor_CameraSpriteObjectIdx1].oam.priority = 1; -} - -void sub_8129ABC(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - switch (data[2]) - { - case 0: - if (!gPaletteFade.active) - { - sub_8127ACC(taskId); - data[2] = 1; - data[6] = 1; - data[5] = 1; - } - break; - case 1: - SetUpPuttingAwayDecorationPlayerAvatar(); - pal_fill_black(); - data[2] = 2; - break; - case 2: - if (sub_80ABDFC() == TRUE) - { - data[12] = 1; - sub_8129B34(taskId); - } - break; - } -} - -void sub_8129B34(u8 taskId) -{ - sub_8197434(0, 1); - gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0; - gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; - gSprites[sDecor_CameraSpriteObjectIdx1].callback = sub_812A36C; - gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = 0x88; - gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = 0x48; - gTasks[taskId].data[10] = 0; - gTasks[taskId].func = sub_8128E18; -} - -void sub_8129BCC(u8 taskId) -{ - gTasks[taskId].data[10] = 0; - sub_8128DE0(); - sub_8129C74(taskId); -} - -void sub_8129BF8(u8 taskId) -{ - gTasks[taskId].data[10] = 0; - sub_8128DE0(); - gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; - gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; - StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations); - DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0); -} - -void sub_8129C74(u8 taskId) -{ - s16 *data; - u8 behavior; - - sub_812A0E8(taskId); - if (sCurDecorSelectedInRearrangement != 0) - { - StringExpandPlaceholders(gStringVar4, gText_ReturnDecorationToPC); - DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1A0); - } - else - { - data = gTasks[taskId].data; - behavior = MapGridGetMetatileBehaviorAt(data[0], data[1]); - if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsMB_C5(behavior) == TRUE) - { - gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; - gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; - StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations); - DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0); - } - else - { - StringExpandPlaceholders(gStringVar4, gText_NoDecorationHere); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64); - } - } -} - -void sub_8129D64(u8 taskId) -{ - if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) - { - sub_8129B34(taskId); - } -} - -void sub_8129D8C(u8 decor, struct DecorRearrangementDataBuffer *data) -{ - if (gDecorations[decor].shape == DECORSHAPE_1x1) - { - data->width = 1; - data->height = 1; - } else if (gDecorations[decor].shape == DECORSHAPE_2x1) - { - data->width = 2; - data->height = 1; - } else if (gDecorations[decor].shape == DECORSHAPE_3x1) - { - data->width = 3; - data->height = 1; - } else if (gDecorations[decor].shape == DECORSHAPE_4x2) - { - data->width = 4; - data->height = 2; - } else if (gDecorations[decor].shape == DECORSHAPE_2x2) - { - data->width = 2; - data->height = 2; - } else if (gDecorations[decor].shape == DECORSHAPE_1x2) - { - data->width = 1; - data->height = 2; - } else if (gDecorations[decor].shape == DECORSHAPE_1x3) - { - data->width = 1; - data->height = 3; - } else if (gDecorations[decor].shape == DECORSHAPE_2x4) - { - data->width = 2; - data->height = 4; - } else if (gDecorations[decor].shape == DECORSHAPE_3x3) - { - data->width = 3; - data->height = 3; - } else if (gDecorations[decor].shape == DECORSHAPE_3x2) - { - data->width = 3; - data->height = 2; - } -} - -void sub_8129E0C(u8 x, u8 y) -{ - gSprites[sDecor_CameraSpriteObjectIdx1].invisible = TRUE; - gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; - gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = (x << 4) + 0x88; - gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = (y << 4) + 0x48; -} - -bool8 sub_8129E74(u8 taskId, u8 idx, struct DecorRearrangementDataBuffer *data) -{ - u8 x; - u8 y; - u8 xOff; - u8 yOff; - u8 ht; - - x = gTasks[taskId].data[0] - 7; - y = gTasks[taskId].data[1] - 7; - xOff = gUnknown_0203A17C.pos[idx] >> 4; - yOff = gUnknown_0203A17C.pos[idx] & 0x0F; - ht = data->height; - if (gUnknown_0203A17C.items[idx] == DECOR_SAND_ORNAMENT && MapGridGetMetatileIdAt(xOff + 7, yOff + 7) == 0x28C) - { - ht --; - } - if (x >= xOff && x < xOff + data->width && y > yOff - ht && y <= yOff) - { - sub_8129E0C(data->width - (x - xOff + 1), yOff - y); - return TRUE; - } - return FALSE; -} - -void sub_8129F20(void) -{ - u8 xOff; - u8 yOff; - u16 i; - - xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] >> 4; - yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] & 0x0F; - for (i = 0; i < 0x40; i ++) - { - if (gSaveBlock1Ptr->mapObjectTemplates[i].x == xOff && gSaveBlock1Ptr->mapObjectTemplates[i].y == yOff && !FlagGet(gSaveBlock1Ptr->mapObjectTemplates[i].flagId)) - { - sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].flagId = gSaveBlock1Ptr->mapObjectTemplates[i].flagId; - break; - } - } -} - -bool8 sub_8129FC8(u8 taskId) -{ - u16 i; - - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - if (gUnknown_0203A17C.items[i] != 0) - { - if (gDecorations[gUnknown_0203A17C.items[i]].permission == DECORPERM_SOLID_MAT) - { - sub_8129D8C(gUnknown_0203A17C.items[i], sDecorRearrangementDataBuffer); - if (sub_8129E74(taskId, i, sDecorRearrangementDataBuffer) == TRUE) - { - sDecorRearrangementDataBuffer->idx = i; - sub_8129F20(); - sCurDecorSelectedInRearrangement = 1; - return TRUE; - } - } - } - } - return FALSE; -} - -void sub_812A040(u8 left, u8 top, u8 right, u8 bottom) -{ - u8 i; - u8 xOff; - u8 yOff; - u8 decorIdx; - - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - decorIdx = gUnknown_0203A17C.items[i]; - xOff = gUnknown_0203A17C.pos[i] >> 4; - yOff = gUnknown_0203A17C.pos[i] & 0x0F; - if (decorIdx != 0 && gDecorations[decorIdx].permission == DECORPERM_SOLID_MAT && left <= xOff && top <= yOff && right >= xOff && bottom >= yOff) - { - sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx = i; - sub_8129F20(); - sCurDecorSelectedInRearrangement++; - } - } -} - -#ifdef NONMATCHING -void sub_812A0E8(u8 taskId) -{ - u8 i; - u8 xOff; - u8 yOff; - u8 decor; - register u8 decor asm("r1"); - struct DecorRearrangementDataBuffer *data; - - sCurDecorSelectedInRearrangement = 0; - if (sub_8129FC8(taskId) != TRUE) - { - for (i = 0; i < gUnknown_0203A17C.size; i ++) - { - decor = gUnknown_0203A17C.items[i]; - if (decor != DECOR_NONE) - { - data = &sDecorRearrangementDataBuffer[0]; - sub_8129D8C(decor, data); - if (sub_8129E74(taskId, i, data) == TRUE) - { - data->idx = i; - sCurDecorSelectedInRearrangement ++; - break; - } - } - } - if (sCurDecorSelectedInRearrangement != 0) - { - xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] >> 4; - yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] & 0x0F; - sub_812A040(xOff, yOff - sDecorRearrangementDataBuffer[0].height + 1, xOff + sDecorRearrangementDataBuffer[0].width - 1, yOff); // Arithmetic register swap at the r2 argument: `add r2, r0, r2` instead of `add r2, r2, r0` - } - } -} -#else -__attribute__((naked)) void sub_812A0E8(u8 taskId) -{ - asm_unified("\tpush {r4-r7,lr}\n" - "\tlsls r0, 24\n" - "\tlsrs r6, r0, 24\n" - "\tldr r4, =sCurDecorSelectedInRearrangement\n" - "\tmovs r0, 0\n" - "\tstrb r0, [r4]\n" - "\tadds r0, r6, 0\n" - "\tbl sub_8129FC8\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r0, 0x1\n" - "\tbeq _0812A18C\n" - "\tmovs r5, 0\n" - "\tldr r0, =gUnknown_0203A17C\n" - "\tldrb r1, [r0, 0x8]\n" - "\tcmp r5, r1\n" - "\tbcs _0812A15A\n" - "\tadds r7, r4, 0\n" - "_0812A10E:\n" - "\tldr r0, [r0]\n" - "\tadds r0, r5\n" - "\tldrb r1, [r0]\n" - "\tcmp r1, 0\n" - "\tbeq _0812A14C\n" - "\tldr r4, =sDecorRearrangementDataBuffer\n" - "\tadds r0, r1, 0\n" - "\tadds r1, r4, 0\n" - "\tbl sub_8129D8C\n" - "\tadds r0, r6, 0\n" - "\tadds r1, r5, 0\n" - "\tadds r2, r4, 0\n" - "\tbl sub_8129E74\n" - "\tlsls r0, 24\n" - "\tlsrs r0, 24\n" - "\tcmp r0, 0x1\n" - "\tbne _0812A14C\n" - "\tstrb r5, [r4]\n" - "\tldrb r0, [r7]\n" - "\tadds r0, 0x1\n" - "\tstrb r0, [r7]\n" - "\tb _0812A15A\n" - "\t.pool\n" - "_0812A14C:\n" - "\tadds r0, r5, 0x1\n" - "\tlsls r0, 24\n" - "\tlsrs r5, r0, 24\n" - "\tldr r0, =gUnknown_0203A17C\n" - "\tldrb r1, [r0, 0x8]\n" - "\tcmp r5, r1\n" - "\tbcc _0812A10E\n" - "_0812A15A:\n" - "\tldr r0, =sCurDecorSelectedInRearrangement\n" - "\tldrb r0, [r0]\n" - "\tcmp r0, 0\n" - "\tbeq _0812A18C\n" - "\tldr r0, =gUnknown_0203A17C\n" - "\tldr r2, =sDecorRearrangementDataBuffer\n" - "\tldrb r1, [r2]\n" - "\tldr r0, [r0, 0x4]\n" - "\tadds r0, r1\n" - "\tldrb r1, [r0]\n" - "\tlsrs r0, r1, 4\n" - "\tmovs r3, 0xF\n" - "\tands r3, r1\n" - "\tldrb r1, [r2, 0x2]\n" - "\tsubs r1, r3, r1\n" - "\tadds r1, 0x1\n" - "\tlsls r1, 24\n" - "\tlsrs r1, 24\n" - "\tldrb r2, [r2, 0x1]\n" - "\tadds r2, r0\n" - "\tsubs r2, 0x1\n" - "\tlsls r2, 24\n" - "\tlsrs r2, 24\n" - "\tbl sub_812A040\n" - "_0812A18C:\n" - "\tpop {r4-r7}\n" - "\tpop {r0}\n" - "\tbx r0\n" - "\t.pool"); -} -#endif - -void sub_812A1A0(u8 taskId) -{ - sub_8197930(); - sub_8121F68(taskId, &gUnknown_085A7348); -} - -void sub_812A1C0(u8 taskId) -{ - fade_screen(1, 0); - gTasks[taskId].data[2] = 0; - gTasks[taskId].func = sub_81298EC; -} - -void sub_812A1F0(u8 taskId) -{ - sub_8197930(); - sub_8121F68(taskId, &gUnknown_085A7350); -} - -void sub_812A210(u8 taskId) -{ - sub_8197434(0, 0); - sub_812A22C(taskId); -} - -void sub_812A22C(u8 taskId) -{ - fade_screen(1, 0); - gTasks[taskId].data[2] = 0; - gTasks[taskId].func = sub_812A25C; -} - -void sub_812A25C(u8 taskId) -{ - switch (gTasks[taskId].data[2]) - { - case 0: - if (!gPaletteFade.active) - { - sub_8127B04(taskId); - gTasks[taskId].data[2] = 1; - } - break; - case 1: - sub_812A3C8(); - gFieldCallback = sub_812A334; - SetMainCallback2(c2_exit_to_overworld_2_switch); - DestroyTask(taskId); - break; - } -} - -void sub_812A2C4(u8 taskId) -{ - s16 *data; - - data = gTasks[taskId].data; - switch (data[2]) - { - case 0: - sub_80E9578(); - data[2] ++; - break; - case 1: - ScriptContext1_SetupScript(gUnknown_08275D0C); - data[2] ++; - break; - case 2: - ScriptContext2_Enable(); - data[2] ++; - break; - case 3: - if (sub_80ABDFC() == TRUE) - { - gTasks[taskId].func = sub_8126B80; - } - break; - } -} - -void sub_812A334(void) -{ - u8 taskId; - - pal_fill_black(); - sub_81973C4(0, 1); - sub_8126ABC(); - taskId = CreateTask(sub_812A2C4, 8); - gTasks[taskId].data[2] = 0; -} - -void sub_812A36C(struct Sprite *sprite) -{ - sprite->data0 ++; - sprite->data0 &= 0x1F; - if (sprite->data0 > 15) - { - sprite->invisible = TRUE; - } - else - { - sprite->invisible = FALSE; - } -} - -void sub_812A39C(void) -{ - if (gSaveBlock2Ptr->playerGender == MALE) - { - LoadSpritePalette(&gUnknown_085A73D8); - } - else - { - LoadSpritePalette(&gUnknown_085A73E0); - } -} - -void sub_812A3C8(void) -{ - FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG); -} - -void sub_812A3D4(u8 taskId) -{ - if (IsSelectedDecorInThePC() == TRUE) - { - StringCopy(gStringVar1, gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].name); - StringExpandPlaceholders(gStringVar4, gText_DecorationWillBeDiscarded); - DisplayItemMessageOnField(taskId, gStringVar4, sub_812A458); - } - else - { - StringExpandPlaceholders(gStringVar4, gText_CantThrowAwayInUse); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); - } -} - -void sub_812A458(u8 taskId) -{ - sub_8197930(); - sub_8121F68(taskId, &gUnknown_085A741C); -} - -void sub_812A478(u8 taskId) -{ - gCurDecorInventoryItems[gCurDecorationIndex] = DECOR_NONE; - sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory); - CondenseDecorationCategoryN(sCurDecorationCategory); - IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); - StringExpandPlaceholders(gStringVar4, gText_DecorationThrownAway); - DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); -} diff --git a/src/decoration_inventory.c b/src/decoration_inventory.c deleted file mode 100644 index 03ab6c00c..000000000 --- a/src/decoration_inventory.c +++ /dev/null @@ -1,189 +0,0 @@ - -// Includes -#include "global.h" -#include "decoration.h" -#include "decoration_inventory.h" - -// Static type declarations - -// Static RAM declarations - -EWRAM_DATA struct DecorationInventory gDecorationInventories[8] = {}; - -// Static ROM declarations - -// .rodata - -// .text - -#define SET_DECOR_INV(i, ptr) {\ - gDecorationInventories[i].items = ptr;\ - gDecorationInventories[i].size = sizeof(ptr);\ -} - -void SetDecorationInventoriesPointers(void) -{ - SET_DECOR_INV(0, gSaveBlock1Ptr->decorDesk); - SET_DECOR_INV(1, gSaveBlock1Ptr->decorChair); - SET_DECOR_INV(2, gSaveBlock1Ptr->decorPlant); - SET_DECOR_INV(3, gSaveBlock1Ptr->decorOrnament); - SET_DECOR_INV(4, gSaveBlock1Ptr->decorMat); - SET_DECOR_INV(5, gSaveBlock1Ptr->decorPoster); - SET_DECOR_INV(6, gSaveBlock1Ptr->decorDoll); - SET_DECOR_INV(7, gSaveBlock1Ptr->decorCushion); - sub_8126968(); -} - -static void ClearDecorationInventory(u8 idx) -{ - u8 i; - - for (i = 0; i < gDecorationInventories[idx].size; i ++) - { - gDecorationInventories[idx].items[i] = DECOR_NONE; - } -} - -void ClearDecorationInventories(void) -{ - u8 idx; - - for (idx = 0; idx < 8; idx ++) - { - ClearDecorationInventory(idx); - } -} - -s8 GetFirstEmptyDecorSlot(u8 idx) -{ - s8 i; - - for (i = 0; i < (s8)gDecorationInventories[idx].size; i ++) - { - if (gDecorationInventories[idx].items[i] == DECOR_NONE) - { - return i; - } - } - return -1; -} - -bool8 CheckHasDecoration(u8 decor) -{ - u8 i; - u8 category; - - category = gDecorations[decor].category; - for (i = 0; i < gDecorationInventories[category].size; i ++) - { - if (gDecorationInventories[category].items[i] == decor) - { - return TRUE; - } - } - return FALSE; -} - -bool8 DecorationAdd(u8 decor) -{ - u8 category; - s8 idx; - - if (decor == DECOR_NONE) - { - return FALSE; - } - category = gDecorations[decor].category; - idx = GetFirstEmptyDecorSlot(category); - if (idx == -1) - { - return FALSE; - } - gDecorationInventories[category].items[idx] = decor; - return TRUE; -} - -bool8 DecorationCheckSpace(u8 decor) -{ - if (decor == DECOR_NONE) - { - return FALSE; - } - if (GetFirstEmptyDecorSlot(gDecorations[decor].category) == -1) - { - return FALSE; - } - return TRUE; -} - -s8 DecorationRemove(u8 decor) -{ - u8 i; - u8 idx; - - i = 0; - if (decor == DECOR_NONE) - { - return 0; - } - for (i = 0; i < gDecorationInventories[gDecorations[decor].category].size; i ++) - { - idx = gDecorations[decor].category; - if (gDecorationInventories[idx].items[i] == decor) - { - gDecorationInventories[idx].items[i] = DECOR_NONE; - CondenseDecorationCategoryN(idx); - return 1; - } - } - return 0; -} - -void CondenseDecorationCategoryN(u8 idx) -{ - u8 i; - u8 j; - u8 tmp; - - for (i = 0; i < gDecorationInventories[idx].size; i ++) - { - for (j = i + 1; j < gDecorationInventories[idx].size; j ++) - { - if (gDecorationInventories[idx].items[j] != DECOR_NONE && (gDecorationInventories[idx].items[i] == DECOR_NONE || gDecorationInventories[idx].items[i] > gDecorationInventories[idx].items[j])) - { - tmp = gDecorationInventories[idx].items[i]; - gDecorationInventories[idx].items[i] = gDecorationInventories[idx].items[j]; - gDecorationInventories[idx].items[j] = tmp; - } - } - } -} - -u8 CountDecorationCategoryN(u8 idx) -{ - u8 i; - u8 ct; - - ct = 0; - for (i = 0; i < gDecorationInventories[idx].size; i ++) - { - if (gDecorationInventories[idx].items[i] != DECOR_NONE) - { - ct ++; - } - } - return ct; -} - -u8 CountDecorations(void) -{ - u8 idx; - u8 ct; - - ct = 0; - for (idx = 0; idx < 8; idx ++) - { - ct += CountDecorationCategoryN(idx); - } - return ct; -} diff --git a/src/international_string_util.c b/src/international_string_util.c index 81985d614..c77b4f8ff 100644 --- a/src/international_string_util.c +++ b/src/international_string_util.c @@ -28,13 +28,13 @@ s32 GetStringWidthDifference(s32 fontId, const u8 *str, s32 totalWidth, s32 lett return 0; } -s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1) +s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1) { s32 i, var; for (var = 0, i = 0; i < arg1; i++) { - s32 stringWidth = GetStringWidth(1, str[i].text, 0); + s32 stringWidth = GetStringWidth(1, str[i * 2], 0); if (stringWidth > var) var = stringWidth; } @@ -42,13 +42,13 @@ s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1) return convert_pixel_width_to_tile_width(var); } -s32 sub_81DB3D8(const struct MenuAction *str, u8* arg1, s32 arg2) +s32 sub_81DB3D8(const u8 **str, u8* arg1, s32 arg2) { s32 i, var; for (var = 0, i = 0; i < arg2; i++) { - s32 stringWidth = GetStringWidth(1, str[arg1[i]].text, 0); + s32 stringWidth = GetStringWidth(1, str[arg1[i] * 2], 0); if (stringWidth > var) var = stringWidth; } diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c deleted file mode 100755 index 37ecdc982..000000000 --- a/src/pokemon_summary_screen.c +++ /dev/null @@ -1,3679 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "bg.h" -#include "decompress.h" -#include "item.h" -#include "items.h" -#include "link.h" -#include "m4a.h" -#include "main.h" -#include "malloc.h" -#include "moves.h" -#include "palette.h" -#include "pokemon.h" -#include "songs.h" -#include "sound.h" -#include "species.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "window.h" - -struct ContestMove -{ - u8 effect; - u8 type; - u8 comboID; - u8 combo[4]; -}; - -struct ContestEffect -{ - u8 type; - u8 appeal; - u8 jam; -}; - - - -extern struct UnkSummaryStruct* gUnknown_0203CF1C; -extern struct BgTemplate gUnknown_0861CBB4; -extern u8 gUnknown_0203CF20; -extern struct MusicPlayerInfo gMPlay_BGM; -extern s8 gUnknown_0861CC1C[]; -extern u8 gUnknown_08329D22[]; -extern u8 gUnknown_0203CF21; -extern u16 gSpecialVar_0x8005; -extern struct UnkStruct_61CC04 gUnknown_0861CC04; -extern struct UnkStruct_61CC04 gUnknown_0861CC10; -extern struct UnkStruct_61CC04 gUnknown_0861CBEC; -extern struct UnkStruct_61CC04 gUnknown_0861CBF8; -extern u16 gUnknown_08DC3CD4[]; -extern struct ContestMove gContestMoves[]; -extern struct ContestEffect gContestEffects[]; -extern struct WindowTemplate gUnknown_0861CC24; -extern struct TextColor gUnknown_0861CD2C[]; -extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1]; -extern u8 gText_MaleSymbol[]; -extern u8 gText_FemaleSymbol[]; -extern u8 gUnknown_0861CDD3[]; -extern void (*const gUnknown_0861CE54[])(); -extern void (*const gUnknown_0861CE64[])(u8 taskId); -extern struct WindowTemplate gUnknown_0861CCCC; -extern u8 gUnknown_0861CE74[]; -extern u8 gUnknown_0861CE7B[]; -extern struct WindowTemplate gUnknown_0861CCEC; -extern struct WindowTemplate gUnknown_0861CD14; - -extern void sub_806F2AC(u8 a, u8 b); -void sub_81C488C(u8 a); -extern void do_scheduled_bg_tilemap_copies_to_vram(void); -extern u8 sub_81221EC(); -extern u8 sub_81221AC(); -extern void SetVBlankHBlankCallbacksToNull(); -extern void sub_8121DA0(); -extern void clear_scheduled_bg_copies_to_vram(); -extern void remove_some_task(); -extern void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable); -extern void ShowBg(u8 a); -extern void SetGpuReg(u8 regOffset, u16 value); -extern void schedule_bg_copy_tilemap_to_vram(u8 a); -extern void SetBgTilemapBuffer(u8 bg, void *tilemap); -extern u8 gUnknown_08D9862C; -extern u8 gUnknown_08D98CC8; -extern u8 gUnknown_08D987FC; -extern u8 gUnknown_08D9898C; -extern u8 gUnknown_08D98B28; -extern u8 gUnknown_08D9853C; -extern u8 gUnknown_08D85620; -extern struct CompressedSpriteSheet gUnknown_0861CFBC; -extern struct CompressedSpriteSheet gUnknown_0861D074; -extern struct CompressedSpriteSheet gUnknown_0861D0F8; -extern struct CompressedSpritePalette gUnknown_0861D100; -extern struct CompressedSpritePalette gUnknown_0861D07C; -extern u8 gUnknown_08D97B84; -extern u8 gUnknown_08D97D0C; -extern void reset_temp_tile_data_buffers(); -extern void decompress_and_copy_tile_data_to_vram(u8 a, void* tiledata, u8 b, u8 c, u8 d); -extern u8 free_temp_tile_data_buffers_if_possible(); -extern void sub_8069004(struct BoxPokemon* a, void* b); -extern void sub_81C1E20(u8 taskId); -extern u8 *GetMonNickname(struct Pokemon *mon, u8 *dest); -extern u16 SpeciesToPokedexNum(u16 species); -extern u8 gText_UnkCtrlF908Clear01[]; -extern u8 gText_LevelSymbol[]; -extern u8 gText_PkmnInfo[]; -extern u8 gText_PkmnSkills[]; -extern u8 gText_BattleMoves[]; -extern u8 gText_ContestMoves[]; -extern u8 gText_Cancel2[]; -extern u8 gText_Info[]; -extern u8 gText_Switch[]; -extern u8 gText_RentalPkmn[]; -extern u8 gText_TypeSlash[]; -extern u8 gText_HP4[]; -extern u8 gText_Attack3[]; -extern u8 gText_Defense3[]; -extern u8 gText_SpAtk4[]; -extern u8 gText_SpDef4[]; -extern u8 gText_Speed2[]; -extern u8 gText_ExpPoints[]; -extern u8 gText_NextLv[]; -extern u8 gText_Status[]; -extern u8 gText_Power[]; -extern u8 gText_Accuracy2[]; -extern u8 gText_Appeal[]; -extern u8 gText_Jam[]; -extern u8 gText_OTSlash[]; -extern u8 gText_UnkCtrlF907F908[]; -extern u8 gAbilityNames[][13]; -extern u8 *gAbilityDescriptionPointers[]; -extern u8 gText_XNature[]; -extern u8 gText_XNatureHatchedAtYZ[]; -extern u8 gText_XNatureHatchedSomewhereAt[]; -extern u8 gText_XNatureMetAtYZ[]; -extern u8 gText_XNatureMetSomewhereAt[]; -extern u8 gText_XNatureFatefulEncounter[]; -extern u8 gText_XNatureProbablyMetAt[]; -extern u8 gText_XNatureObtainedInTrade[]; -extern u8 *gNatureNamePointers[]; -extern u8 gText_EmptyString5[]; -extern u32 gBattleTypeFlags; -extern u8 gText_FiveMarks[]; -extern u8 gText_EggWillTakeALongTime[]; -extern u8 gText_EggAboutToHatch[]; -extern u8 gText_EggWillHatchSoon[]; -extern u8 gText_EggWillTakeSomeTime[]; -extern u8 gText_PeculiarEggNicePlace[]; -extern u8 gText_PeculiarEggTrade[]; -extern u8 gText_EggFromTraveler[]; -extern u8 gText_EggFromHotSprings[]; -extern u8 gText_OddEggFoundByCouple[]; -extern u8 gText_None[]; -extern u8 gText_RibbonsVar1[]; -extern u8 gUnknown_0861CE82[]; -extern u8 gUnknown_0861CE8E[]; -extern u8 gText_OneDash[]; -extern u8 gText_TwoDashes[]; -extern u8 gText_ThreeDashes[]; -extern u8 gUnknown_0861CE97[]; -extern struct BattleMove gBattleMoves[]; - -extern u32 ChangeBgX(u8 bg, u32 value, u8 op); -extern void sub_8199C30(u8 a, u8 b, u8 c, u8 d, u8 e, u8 f); -extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor* colors, s8 speed, u8 *str); -extern s32 GetStringCenterAlignXOffset(u8 fontId, u8 *str, s32 totalWidth); -extern s32 GetStringRightAlignXOffset(u8 fontId, u8 *str, s32 totalWidth); -extern bool8 sub_81A6BF4(); -extern bool8 sub_81B9E94(); -extern void sub_81AFBF0(); -extern u8 sub_81AFC0C(u8 a, u8 *b); -extern void sub_81AFC28(u8 *a, u8 *b); -extern void sub_8124610(u8 *a, u8 b); -extern int GetPlayerIDAsU32(); -extern u8 GetCurrentPpToMaxPpState(u8 a, u8 b); - -void sub_81BFAE4(void); -void sub_81BFE24(); -u8 sub_81BFEB0(); -void sub_81C2554(); -void sub_81C1BA0(); -void sub_81C0098(struct Pokemon* a); -bool8 sub_81C00F0(struct Pokemon* a); -void sub_81C25E8(); -void sub_81C286C(); -void sub_81C2D9C(u8 a); -void sub_81C0348(); -void sub_81C2AFC(u8 a); -void sub_81C4190(); -void sub_81C42C8(); -u8 sub_81C45F4(void* a, u16* b); -void sub_81C4984(); -void sub_81C4A08(); -void sub_81C4A88(); -void sub_81C4280(); -void sub_81C0510(u8 taskId); -void sub_81C171C(u8 taskId); -void sub_8121E10(); -u8 sub_81B205C(struct Pokemon* a); -void sub_81C1DA4(u16 a, s16 b); -void sub_81C1EFC(u16 a, s16 b, u16 c); -void sub_81C240C(u16 a); -void sub_81C2194(u16 *a, u16 b, u8 c); -void sub_81C2074(u16 a, s16 b); -void sub_81C2524(); -void sub_81C2228(struct Pokemon* mon); -void sub_81C0484(u8 taskId); -void sub_81C4898(); -void sub_806F47C(u8 a); -u8 GetLRKeysState(); -void sub_81C0604(u8 taskId, s8 a); -void sub_81C0A8C(u8 taskId, s8 a); -void sub_81C48F0(); -void sub_81C0E48(u8 taskId); -void sub_81C0704(u8 taskId); -s8 sub_81C09B4(s8 a); -s8 sub_81C08F8(s8 a); -void sub_81C4204(u8 a, u8 b); -void sub_81C20F0(u8 taskId); -bool8 sub_81C0A50(struct Pokemon* mon); -void sub_81C49E0(); -void sub_81C0E24(); -void sub_81C2C38(u8 a); -void sub_81C0B8C(u8 taskId); -void sub_81C0CC4(u8 taskId); -void sub_81C2DE4(u8 a); -void sub_81C424C(); -void sub_81C0C68(u8 taskId); -void sub_81C0D44(u8 taskId); -void sub_81C22CC(struct Pokemon* mon); -void sub_81C0F44(u8 taskId); -void sub_81C3E9C(u16 a); -void sub_81C3F44(); -void sub_81C44F0(); -void sub_81C4AF8(u8 a); -void sub_81C1070(s16* a, s8 b, u8* c); -void sub_81C11F4(u8 a); -void sub_81C129C(u8 a); -bool8 sub_81C1040(); -void sub_81C4064(); -void sub_81C4C60(u8 a); -void sub_81C12E4(u8 taskId); -void sub_81C4C84(u8 a); -void sub_81C13B0(u8 a, u8 b); -void sub_81C14BC(struct Pokemon *mon, u8 a, u8 b); -void sub_81C15EC(struct BoxPokemon *mon, u8 a, u8 b); -void sub_81C40A0(u8 a, u8 b); -void sub_81C4568(u8 a, u8 b); -void sub_81C174C(u8 taskId); -bool8 sub_81C18A8(); -void sub_81C18F4(u8 a); -u8 sub_81B6D14(u16 a); -void sub_81C1940(u8 taskId); -void sub_81C4154(); -void sub_81C1F80(u8 taskId); -void sub_81C2628(); -void sub_81C2794(); -void sub_81C27DC(struct Pokemon *mon, u16 a); -void sub_81C2D68(u8 a); -void sub_81C335C(); -void sub_81C33CC(); -void sub_81C3428(); -void sub_81C349C(); -void sub_81C2EC4(); -void sub_81C2F5C(); -void sub_81C2FD8(); -void sub_81C302C(); -void sub_81C307C(); -void sub_81C3194(); -void sub_81C31C0(); -bool8 sub_81C3304(); -void sub_81C31F0(u8 *a); -u8 sub_81C3220(); -bool8 sub_81C32BC(); -void sub_81C35E4(); -void sub_81C3690(); -void sub_81C3710(); -void sub_81C37D8(); -void sub_81C3808(); -void sub_81C3890(); -void sub_81C38C0(); -void sub_81C3B08(u8 a); -void sub_81C3E2C(u8 a); -void sub_81C4D18(); - -void SetBgAttribute(u8 bg, u8 attributeId, u8 value); - -bool8 sub_81BFB10(); -u8 sub_81B1250(); - -union UnkUnion -{ - struct Pokemon mon[6]; - struct BoxPokemon boxMon[6]; -}; - - -u8 sub_80D214C(union UnkUnion* a, u8 b, u8 c, u8 d); - -struct PokeSummary -{ - u16 species; // 0x0 - u16 species2; // 0x2 - u8 isEgg; // 0x4 - u8 level; // 0x5 - u8 ribbons; // 0x6 - u8 unk7; // 0x7 - u8 altAbility; // 0x8 - u8 metLocation; // 0x9 - u8 metLevel; // 0xA - u8 metGame; // 0xB - u32 pid; // 0xC - u32 exp; // 0x10 - u16 moves[4]; // 0x14 - u8 pp[4]; // 0x1C - u16 currentHP; // 0x20 - u16 maxHP; // 0x22 - u16 atk; // 0x24 - u16 def; // 0x26 - u16 spatk; // 0x28 - u16 spdef; // 0x2A - u16 speed; // 0x2C - u16 item; // 0x2E - u16 friendship; // 0x30 - u8 OTGender; // 0x32 - u8 nature; // 0x33 - u8 ppBonuses; // 0x34 - u8 sanity; // 0x35 - u8 OTName[8]; // 0x36 - u8 unk3E[9]; // 0x3E - u32 OTID; // 0x48 -}; - -struct UnkSummaryStruct -{ - /*0x00*/ union UnkUnion *unk0; - /*0x04*/ void *unk4; - /*0x08*/ void *unk8; - /*0x0C*/ struct Pokemon currentMon; - /*0x70*/ struct PokeSummary summary; - u16 unkTilemap0[0x400]; - u16 unkTilemap0_1[0x400]; - u16 unkTilemap1[0x400]; - u16 unkTilemap1_1[0x400]; - u16 unkTilemap2[0x400]; - u16 unkTilemap2_1[0x400]; - u16 unkTilemap3[0x400]; - u16 unkTilemap3_1[0x400]; - u8 unk40BC; - u8 unk40BD; - u8 unk40BE; - u8 unk40BF; - u8 unk40C0; - u8 unk40C1; - u8 unk40C2; - u8 unk40C3; - u16 unk40C4; - u8 unk40C6; - u8 unk40C7; - u8 unk40C8; - u8 unk40C9; - u8 unk40CA; - u8 unk40CB[8]; - u8 unk40D3; - u8 unk40D4; - u8 unk40D5; - u8 unk_filler5[0x19]; - u8 unk40EF; - s16 unk40F0; - u8 unk_filler4[6]; -}; - -void sub_81BF8EC(u8 a, void *b, u8 c, u8 d, void *e) -{ - u8 byte; - gUnknown_0203CF1C = AllocZeroed(sizeof(struct UnkSummaryStruct)); - gUnknown_0203CF1C->unk40BC = a; - gUnknown_0203CF1C->unk0 = b; - gUnknown_0203CF1C->unk40BE = c; - gUnknown_0203CF1C->unk40BF = d; - gUnknown_0203CF1C->unk4 = e; - if (a == 2) - gUnknown_0203CF1C->unk40BD = 1; - else - gUnknown_0203CF1C->unk40BD = 0; - switch (a) - { - case 0: - case 2: - gUnknown_0203CF1C->unk40C1 = 0; - gUnknown_0203CF1C->unk40C2 = 3; - break; - case 1: - gUnknown_0203CF1C->unk40C1 = 0; - gUnknown_0203CF1C->unk40C2 = 3; - gUnknown_0203CF1C->unk40C8 = 1; - break; - case 3: - gUnknown_0203CF1C->unk40C1 = 2; - gUnknown_0203CF1C->unk40C2 = 3; - gUnknown_0203CF1C->unk40C3 = 1; - break; - } - byte = gUnknown_0203CF1C->unk40C1; - gUnknown_0203CF1C->unk40C0 = byte; - sub_81C488C(0xFF); - if (gMonSpritesGfxPtr == 0) - sub_806F2AC(0, 0); - SetMainCallback2(sub_81BFAE4); -} - -void sub_81BFA38(void *a, u8 b, u8 c, void *d, u16 e) -{ - sub_81BF8EC(3, a, b, c, d); - gUnknown_0203CF1C->unk40C4 = e; -} - -void sub_81BFA80(u8 a, void *b, u8 c, u8 d, void *e) -{ - sub_81BF8EC(a, b, c, d, e); - gUnknown_0203CF1C->unk40EF = 1; -} - -void sub_81BFAB4(void) -{ - RunTasks(); - AnimateSprites(); - BuildOamBuffer(); - do_scheduled_bg_tilemap_copies_to_vram(); - UpdatePaletteFade(); -} - -void sub_81BFAD0(void) -{ - LoadOam(); - ProcessSpriteCopyRequests(); - TransferPlttBuffer(); -} - -void sub_81BFAE4() -{ - while (1) - { - if (sub_81221EC() == 1 || sub_81BFB10() == TRUE || sub_81221AC() == 1) - break; - } -} - -bool8 sub_81BFB10(void) -{ - switch (gMain.state) - { - case 0: - SetVBlankHBlankCallbacksToNull(); - sub_8121DA0(); - clear_scheduled_bg_copies_to_vram(); - gMain.state++; - break; - case 1: - remove_some_task(); - gMain.state++; - break; - case 2: - ResetPaletteFade(); - gPaletteFade.bufferTransferDisabled = 1; - gMain.state++; - break; - case 3: - ResetSpriteData(); - gMain.state++; - break; - case 4: - FreeAllSpritePalettes(); - gMain.state++; - break; - case 5: - sub_81BFE24(); - gUnknown_0203CF1C->unk40F0 = 0; - gMain.state++; - break; - case 6: - if (sub_81BFEB0() != 0) - gMain.state++; - break; - case 7: - sub_81C2554(); - gMain.state++; - break; - case 8: - sub_81C1BA0(); - gMain.state++; - break; - case 9: - sub_81C0098(&gUnknown_0203CF1C->currentMon); - gUnknown_0203CF1C->unk40F0 = 0; - gMain.state++; - break; - case 10: - if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) != 0) - gMain.state++; - break; - case 11: - sub_81C25E8(); - gMain.state++; - break; - case 12: - sub_81C286C(); - gMain.state++; - break; - case 13: - sub_81C2D9C(gUnknown_0203CF1C->unk40C0); - gMain.state++; - break; - case 14: - sub_81C0348(); - gMain.state++; - break; - case 15: - sub_81C2AFC(gUnknown_0203CF1C->unk40C0); - gMain.state++; - break; - case 16: - sub_81C4190(); - sub_81C42C8(); - gUnknown_0203CF1C->unk40F0 = 0; - gMain.state++; - break; - case 17: - gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &gUnknown_0203CF1C->unk40F0); - if (gUnknown_0203CF1C->unk40D3 != 0xFF) - { - gUnknown_0203CF1C->unk40F0 = 0; - gMain.state++; - } - break; - case 18: - sub_81C4984(&gUnknown_0203CF1C->currentMon); - gMain.state++; - break; - case 19: - sub_81C4A08(&gUnknown_0203CF1C->currentMon); - gMain.state++; - break; - case 20: - sub_81C4A88(); - gMain.state++; - break; - case 21: - sub_81C4280(); - gMain.state++; - break; - case 22: - if (gUnknown_0203CF1C->unk40BC != 3) - CreateTask(sub_81C0510, 0); - else - CreateTask(sub_81C171C, 0); - gMain.state++; - break; - case 23: - BlendPalettes(-1, 16, 0); - gMain.state++; - break; - case 24: - BeginNormalPaletteFade(-1, 0, 16, 0, 0); - gPaletteFade.bufferTransferDisabled = 0; - gMain.state++; - break; - default: - SetVBlankCallback(sub_81BFAD0); - SetMainCallback2(sub_81BFAB4); - return TRUE; - } - return FALSE; -} - -void sub_81BFE24() -{ - ResetBgsAndClearDma3BusyFlags(0); - InitBgsFromTemplates(0, &gUnknown_0861CBB4, 4); - SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap2); - SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap1); - SetBgTilemapBuffer(3, &gUnknown_0203CF1C->unkTilemap0); - sub_8121E10(); - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); - schedule_bg_copy_tilemap_to_vram(3); - SetGpuReg(REG_OFFSET_DISPCNT, 0x1040); - SetGpuReg(REG_OFFSET_BLDCNT, 0); - ShowBg(0); - ShowBg(1); - ShowBg(2); - ShowBg(3); -} - -u8 sub_81BFEB0() -{ - switch (gUnknown_0203CF1C->unk40F0) - { - case 0: - reset_temp_tile_data_buffers(); - decompress_and_copy_tile_data_to_vram(1, &gUnknown_08D97D0C, 0, 0, 0); - gUnknown_0203CF1C->unk40F0++; - break; - case 1: - if (free_temp_tile_data_buffers_if_possible() != 1) - { - LZDecompressWram(&gUnknown_08D9862C, gUnknown_0203CF1C->unkTilemap0); - gUnknown_0203CF1C->unk40F0++; - } - break; - case 2: - LZDecompressWram(&gUnknown_08D98CC8, gUnknown_0203CF1C->unkTilemap0_1); - gUnknown_0203CF1C->unk40F0++; - break; - case 3: - LZDecompressWram(&gUnknown_08D987FC, gUnknown_0203CF1C->unkTilemap1_1); - gUnknown_0203CF1C->unk40F0++; - break; - case 4: - LZDecompressWram(&gUnknown_08D9898C, gUnknown_0203CF1C->unkTilemap2_1); - gUnknown_0203CF1C->unk40F0++; - break; - case 5: - LZDecompressWram(&gUnknown_08D98B28, gUnknown_0203CF1C->unkTilemap3_1); - gUnknown_0203CF1C->unk40F0++; - break; - case 6: - LoadCompressedPalette(&gUnknown_08D9853C, 0, 0x100); - LoadPalette(&gUnknown_08D85620, 0x81, 0x1E); - gUnknown_0203CF1C->unk40F0++; - break; - case 7: - LoadCompressedObjectPic(&gUnknown_0861CFBC); - gUnknown_0203CF1C->unk40F0++; - break; - case 8: - LoadCompressedObjectPic(&gUnknown_0861D074); - gUnknown_0203CF1C->unk40F0++; - break; - case 9: - LoadCompressedObjectPic(&gUnknown_0861D0F8); - gUnknown_0203CF1C->unk40F0++; - break; - case 10: - LoadCompressedObjectPalette(&gUnknown_0861D100); - gUnknown_0203CF1C->unk40F0++; - break; - case 11: - LoadCompressedObjectPalette(&gUnknown_0861D07C); - gUnknown_0203CF1C->unk40F0++; - break; - case 12: - LoadCompressedPalette(&gUnknown_08D97B84, 0x1D0, 0x60); - gUnknown_0203CF1C->unk40F0 = 0; - return 1; - } - return 0; -} - -void sub_81C0098(struct Pokemon *mon) -{ - if (gUnknown_0203CF1C->unk40BD == 0) - { - struct Pokemon *partyMon = gUnknown_0203CF1C->unk0->mon; - *mon = partyMon[gUnknown_0203CF1C->unk40BE]; - } - else - { - struct BoxPokemon *boxMon = gUnknown_0203CF1C->unk0->boxMon; - sub_8069004(&boxMon[gUnknown_0203CF1C->unk40BE], mon); - } -} - -bool8 sub_81C00F0(struct Pokemon *a) -{ - u32 i; - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - switch (gUnknown_0203CF1C->unk40F0) - { - case 0: - sum->species = GetMonData(a, MON_DATA_SPECIES); - sum->species2 = GetMonData(a, MON_DATA_SPECIES2); - sum->exp = GetMonData(a, MON_DATA_EXP); - sum->level = GetMonData(a, MON_DATA_LEVEL); - sum->altAbility = GetMonData(a, MON_DATA_ALT_ABILITY); - sum->item = GetMonData(a, MON_DATA_HELD_ITEM); - sum->pid = GetMonData(a, MON_DATA_PERSONALITY); - sum->sanity = GetMonData(a, MON_DATA_SANITY_BIT1); - if (sum->sanity != 0) - sum->isEgg = 1; - else - sum->isEgg = GetMonData(a, MON_DATA_IS_EGG); - break; - case 1: - for (i = 0; i < 4; i++) - { - sum->moves[i] = GetMonData(a, MON_DATA_MOVE1+i); - sum->pp[i] = GetMonData(a, MON_DATA_PP1+i); - } - sum->ppBonuses = GetMonData(a, MON_DATA_PP_BONUSES); - break; - case 2: - if ((struct Pokemon*)gUnknown_0203CF1C->unk0 == gPlayerParty || gUnknown_0203CF1C->unk40BC == 2 || gUnknown_0203CF1C->unk40EF == 1) - { - sum->nature = GetNature(a); - sum->currentHP = GetMonData(a, MON_DATA_HP); - sum->maxHP = GetMonData(a, MON_DATA_MAX_HP); - sum->atk = GetMonData(a, MON_DATA_ATK); - sum->def = GetMonData(a, MON_DATA_DEF); - sum->spatk = GetMonData(a, MON_DATA_SPATK); - sum->spdef = GetMonData(a, MON_DATA_SPDEF); - sum->speed = GetMonData(a, MON_DATA_SPD); - } - else - { - sum->nature = GetNature(a); - sum->currentHP = GetMonData(a, MON_DATA_HP); - sum->maxHP = GetMonData(a, MON_DATA_MAX_HP); - sum->atk = GetMonData(a, MON_DATA_ATK2); - sum->def = GetMonData(a, MON_DATA_DEF2); - sum->spatk = GetMonData(a, MON_DATA_SPATK2); - sum->spdef = GetMonData(a, MON_DATA_SPDEF2); - sum->speed = GetMonData(a, MON_DATA_SPD2); - } - break; - case 3: - GetMonData(a, MON_DATA_OT_NAME, &sum->OTName); - ConvertInternationalString((u8*)&sum->OTName, GetMonData(a, MON_DATA_LANGUAGE)); - sum->unk7 = sub_81B205C(a); - sum->OTGender = GetMonData(a, MON_DATA_OT_GENDER); - sum->OTID = GetMonData(a, MON_DATA_OT_ID); - sum->metLocation = GetMonData(a, MON_DATA_MET_LOCATION); - sum->metLevel = GetMonData(a, MON_DATA_MET_LEVEL); - sum->metGame = GetMonData(a, MON_DATA_MET_GAME); - sum->friendship = GetMonData(a, MON_DATA_FRIENDSHIP); - break; - default: - sum->ribbons = GetMonData(a, MON_DATA_RIBBON_COUNT); - return TRUE; - } - gUnknown_0203CF1C->unk40F0++; - return FALSE; -} - -void sub_81C0348(void) -{ - if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3) - { - sub_81C1DA4(0, 255); - sub_81C1EFC(0, 255, 0); - } - else - { - sub_81C240C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]); - sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0); - sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0); - SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap3); - SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap2); - ChangeBgX(2, 0x10000, 1); - ClearWindowTilemap(0x13); - ClearWindowTilemap(0xD); - } - if (gUnknown_0203CF1C->summary.unk7 == 0) - { - sub_81C2074(0, 0xFF); - } - else - { - if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3) - PutWindowTilemap(0xD); - } - sub_81C2524(); - sub_81C2228(&gUnknown_0203CF1C->currentMon); -} - -void sub_81C0434() -{ - FreeAllWindowBuffers(); - Free(gUnknown_0203CF1C); -} - -void sub_81C044C(u8 taskId) -{ - BeginNormalPaletteFade(-1, 0, 0, 16, 0); - gTasks[taskId].func = sub_81C0484; -} - -void sub_81C0484(u8 taskId) -{ - if (sub_81221EC() != 1 && !gPaletteFade.active) - { - SetMainCallback2(gUnknown_0203CF1C->unk4); - gUnknown_0203CF20 = gUnknown_0203CF1C->unk40BE; - sub_81C4898(); - ResetSpriteData(); - FreeAllSpritePalettes(); - StopCryAndClearCrySongs(); - m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); - if (gMonSpritesGfxPtr == 0) - sub_806F47C(0); - sub_81C0434(); - DestroyTask(taskId); - } -} - -void sub_81C0510(u8 taskId) -{ - if (sub_81221EC() != 1 && !gPaletteFade.active) - { - if (gMain.newKeys & DPAD_UP) - { - sub_81C0604(taskId, -1); - } - else if (gMain.newKeys & DPAD_DOWN) - { - sub_81C0604(taskId, 1); - } - else if ((gMain.newKeys & DPAD_LEFT) || GetLRKeysState() == 1) - { - sub_81C0A8C(taskId, -1); - } - else if ((gMain.newKeys & DPAD_RIGHT) || GetLRKeysState() == 2) - { - sub_81C0A8C(taskId, 1); - } - else if (gMain.newKeys & A_BUTTON) - { - if (gUnknown_0203CF1C->unk40C0 != 1) - { - if (gUnknown_0203CF1C->unk40C0 == 0) - { - sub_81C48F0(); - PlaySE(SE_SELECT); - sub_81C044C(taskId); - } - else - { - PlaySE(SE_SELECT); - sub_81C0E48(taskId); - } - } - } - else if (gMain.newKeys & B_BUTTON) - { - sub_81C48F0(); - PlaySE(SE_SELECT); - sub_81C044C(taskId); - } - } -} - -void sub_81C0604(u8 taskId, s8 a) -{ - s8 r4_2; - - if (gUnknown_0203CF1C->unk40C3 == 0) - { - if (gUnknown_0203CF1C->unk40BD == 1) - { - if (gUnknown_0203CF1C->unk40C0 != 0) - { - if (a == 1) - a = 0; - else - a = 2; - } - else - { - if (a == 1) - a = 1; - else - a = 3; - } - r4_2 = sub_80D214C(gUnknown_0203CF1C->unk0, gUnknown_0203CF1C->unk40BE, gUnknown_0203CF1C->unk40BF, a); - } - else if (sub_81B1250() == 1) - { - r4_2 = sub_81C09B4(a); - } - else - { - r4_2 = sub_81C08F8(a); - } - - if (r4_2 != -1) - { - PlaySE(SE_SELECT); - if (gUnknown_0203CF1C->summary.unk7 != 0) - { - sub_81C4204(2, 1); - ClearWindowTilemap(0xD); - schedule_bg_copy_tilemap_to_vram(0); - sub_81C2074(0, 2); - } - gUnknown_0203CF1C->unk40BE = r4_2; - gTasks[taskId].data[0] = 0; - gTasks[taskId].func = sub_81C0704; - } - } -} - -void sub_81C0704(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - - switch (data[0]) - { - case 0: - StopCryAndClearCrySongs(); - break; - case 1: - sub_81C4898(); - DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D3]); - break; - case 2: - DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D4]); - break; - case 3: - sub_81C0098(&gUnknown_0203CF1C->currentMon); - gUnknown_0203CF1C->unk40F0 = 0; - break; - case 4: - if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) == FALSE) - return; - break; - case 5: - sub_81C49E0(&gUnknown_0203CF1C->currentMon); - break; - case 6: - sub_81C4A08(&gUnknown_0203CF1C->currentMon); - break; - case 7: - if (gUnknown_0203CF1C->summary.unk7) - sub_81C2074(10, -2); - sub_81C2228(&gUnknown_0203CF1C->currentMon); - data[1] = 0; - break; - case 8: - gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &data[1]); - if (gUnknown_0203CF1C->unk40D3 == 0xFF) - return; - gSprites[gUnknown_0203CF1C->unk40D3].data2 = 1; - sub_81C0E24(); - data[1] = 0; - break; - case 9: - sub_81C4280(); - break; - case 10: - sub_81C25E8(); - break; - case 11: - sub_81C2D9C(gUnknown_0203CF1C->unk40C0); - sub_81C2524(); - break; - case 12: - gSprites[gUnknown_0203CF1C->unk40D3].data2 = 0; - break; - default: - if (sub_81221EC() == 0 && FuncIsActiveTask(sub_81C20F0) == 0) - { - data[0] = 0; - gTasks[taskId].func = sub_81C0510; - } - return; - } - data[0]++; -} - -s8 sub_81C08F8(s8 a) -{ - struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon; - - if (gUnknown_0203CF1C->unk40C0 == 0) - { - if (a == -1 && gUnknown_0203CF1C->unk40BE == 0) - return -1; - if (a == 1 && gUnknown_0203CF1C->unk40BE >= gUnknown_0203CF1C->unk40BF) - return -1; - return gUnknown_0203CF1C->unk40BE + a; - } - else - { - s8 index = gUnknown_0203CF1C->unk40BE; - - do - { - index += a; - if (index < 0 || index > gUnknown_0203CF1C->unk40BF) - return -1; - } while (GetMonData(&mon[index], MON_DATA_IS_EGG) != 0); - return index; - } -} - -s8 sub_81C09B4(s8 a) -{ - struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon; - s8 r5 = 0; - u8 i; - - for (i = 0; i < 6; i++) - { - if (gUnknown_0861CC1C[i] == gUnknown_0203CF1C->unk40BE) - { - r5 = i; - break; - } - } - - while (1) - { - int b; - s8* c = &gUnknown_0861CC1C[0]; - - r5 += a; - if (r5 < 0 || r5 >= 6) - return -1; - b = c[r5]; - if (sub_81C0A50(&mon[b]) == TRUE) - return b; - } -} - -bool8 sub_81C0A50(struct Pokemon* mon) -{ - if (GetMonData(mon, MON_DATA_SPECIES) == 0) - return FALSE; - else if (gUnknown_0203CF1C->unk40BE != 0 || GetMonData(mon, MON_DATA_IS_EGG) == 0) - return TRUE; - else - return FALSE; -} - -void sub_81C0A8C(u8 taskId, s8 b) -{ - struct PokeSummary *summary = &gUnknown_0203CF1C->summary; - s16 *data = gTasks[taskId].data; - - if (summary->isEgg) - return; - if (b == -1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C1) - return; - if (b == 1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C2) - return; - PlaySE(SE_SELECT); - sub_81C2C38(gUnknown_0203CF1C->unk40C0); - gUnknown_0203CF1C->unk40C0 += b; - data[0] = 0; - if (b == 1) - SetTaskFuncWithFollowupFunc(taskId, sub_81C0B8C, gTasks[taskId].func); - else - SetTaskFuncWithFollowupFunc(taskId, sub_81C0CC4, gTasks[taskId].func); - sub_81C2DE4(gUnknown_0203CF1C->unk40C0); - sub_81C424C(); -} - -void sub_81C0B8C(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - if (data[0] == 0) - { - if (gUnknown_0203CF1C->unk40C9 == 0) - { - data[1] = 1; - SetBgAttribute(1, 7, 1); - SetBgAttribute(2, 7, 2); - schedule_bg_copy_tilemap_to_vram(1); - } - else - { - data[1] = 2; - SetBgAttribute(2, 7, 1); - SetBgAttribute(1, 7, 2); - schedule_bg_copy_tilemap_to_vram(2); - } - ChangeBgX(data[1], 0, 0); - SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xBC)); - ShowBg(1); - ShowBg(2); - } - ChangeBgX(data[1], 0x2000, 1); - data[0] += 32; - if (data[0] > 0xFF) - gTasks[taskId].func = sub_81C0C68; -} - -void sub_81C0C68(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - gUnknown_0203CF1C->unk40C9 ^= 1; - data[1] = 0; - data[0] = 0; - sub_81C1BA0(); - sub_81C2AFC(gUnknown_0203CF1C->unk40C0); - sub_81C4280(); - sub_81C0E24(); - SwitchTaskToFollowupFunc(taskId); -} - -void sub_81C0CC4(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - if (data[0] == 0) - { - if (gUnknown_0203CF1C->unk40C9 == 0) - data[1] = 2; - else - data[1] = 1; - ChangeBgX(data[1], 0x10000, 0); - } - ChangeBgX(data[1], 0x2000, 2); - data[0] += 32; - if (data[0] > 0xFF) - gTasks[taskId].func = sub_81C0D44; -} - -void sub_81C0D44(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - if (gUnknown_0203CF1C->unk40C9 == 0) - { - SetBgAttribute(1, 7, 1); - SetBgAttribute(2, 7, 2); - schedule_bg_copy_tilemap_to_vram(2); - } - else - { - SetBgAttribute(2, 7, 1); - SetBgAttribute(1, 7, 2); - schedule_bg_copy_tilemap_to_vram(1); - } - if (gUnknown_0203CF1C->unk40C0 > 1) - { - SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xFFFFF0BC)); - ChangeBgX(data[1], 0x10000, 0); - } - ShowBg(1); - ShowBg(2); - gUnknown_0203CF1C->unk40C9 ^= 1; - data[1] = 0; - data[0] = 0; - sub_81C1BA0(); - sub_81C2AFC(gUnknown_0203CF1C->unk40C0); - sub_81C4280(); - sub_81C0E24(); - SwitchTaskToFollowupFunc(taskId); -} - -void sub_81C0E24() -{ - if (gUnknown_0203CF1C->unk40C0 == 1) - sub_81C22CC(&gUnknown_0203CF1C->currentMon); -} - -void sub_81C0E48(u8 taskId) -{ - u16 move; - gUnknown_0203CF1C->unk40C6 = 0; - move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - ClearWindowTilemap(0x13); - if (gSprites[gUnknown_0203CF1C->unk40D5].invisible == 0) - ClearWindowTilemap(0xD); - sub_81C1DA4(9, -3); - sub_81C1EFC(9, -3, move); - if (gUnknown_0203CF1C->unk40C8 == 0) - { - ClearWindowTilemap(5); - PutWindowTilemap(6); - } - sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0); - sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0); - sub_81C3E9C(move); - sub_81C3F44(); - sub_81C44F0(); - schedule_bg_copy_tilemap_to_vram(0); - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); - sub_81C4AF8(8); - gTasks[taskId].func = sub_81C0F44; -} - -void sub_81C0F44(u8 taskId) -{ - u8 id = taskId; - s16 *data = gTasks[taskId].data; - - if (sub_81221EC() != 1) - { - if (gMain.newKeys & DPAD_UP) - { - data[0] = 4; - sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6); - } - else if (gMain.newKeys & DPAD_DOWN) - { - data[0] = 4; - sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6); - } - else if (gMain.newKeys & A_BUTTON) - { - if (gUnknown_0203CF1C->unk40C8 == 1 - || (gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - { - PlaySE(SE_SELECT); - sub_81C11F4(taskId); - } - else if (sub_81C1040() == TRUE) - { - PlaySE(SE_SELECT); - sub_81C129C(taskId); - } - else - { - PlaySE(SE_HAZURE); - } - } - else if (gMain.newKeys & B_BUTTON) - { - PlaySE(SE_SELECT); - sub_81C11F4(id); - } - } -} - -bool8 sub_81C1040(void) -{ - u8 i; - for (i = 1; i < 4; i++) - { - if (gUnknown_0203CF1C->summary.moves[i] != 0) - return TRUE; - } - return FALSE; -} - -void sub_81C1070(s16 *a, s8 b, u8 *c) -{ - s8 i; - s8 moveIndex; - u16 move; - - PlaySE(SE_SELECT); - moveIndex = *c; - for (i = 0; i < 4; i++) - { - moveIndex += b; - if (moveIndex > a[0]) - moveIndex = 0; - else if (moveIndex < 0) - moveIndex = a[0]; - if (moveIndex == 4) - { - move = gUnknown_0203CF1C->unk40C4; - break; - } - move = gUnknown_0203CF1C->summary.moves[moveIndex]; - if (move != 0) - break; - } - sub_81C240C(move); - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); - sub_81C3E9C(move); - if ((*c == 4 && gUnknown_0203CF1C->unk40C4 == 0) || a[1] == 1) - { - ClearWindowTilemap(19); - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - ClearWindowTilemap(13); - schedule_bg_copy_tilemap_to_vram(0); - sub_81C1DA4(9, -3); - sub_81C1EFC(9, -3, move); - } - if (*c != 4 && moveIndex == 4 && gUnknown_0203CF1C->unk40C4 == 0) - { - ClearWindowTilemap(14); - ClearWindowTilemap(15); - schedule_bg_copy_tilemap_to_vram(0); - sub_81C1DA4(0, 3); - sub_81C1EFC(0, 3, 0); - } - *c = moveIndex; - if (c == &gUnknown_0203CF1C->unk40C6) - sub_81C4D18(8); - else - sub_81C4D18(18); -} - -void sub_81C11F4(u8 taskId) -{ - sub_81C4C60(8); - ClearWindowTilemap(6); - PutWindowTilemap(5); - sub_81C3E9C(0); - sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 1); - sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 1); - sub_81C4064(); - if (gUnknown_0203CF1C->unk40C6 != 4) - { - ClearWindowTilemap(14); - ClearWindowTilemap(15); - sub_81C1DA4(0, 3); - sub_81C1EFC(0, 3, 0); - } - schedule_bg_copy_tilemap_to_vram(0); - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); - gTasks[taskId].func = sub_81C0510; -} - -void sub_81C129C(u8 taskId) -{ - gUnknown_0203CF1C->unk40C7 = gUnknown_0203CF1C->unk40C6; - sub_81C4C84(1); - sub_81C4AF8(18); - gTasks[taskId].func = sub_81C12E4; -} - -void sub_81C12E4(u8 taskId) -{ - u8 a = taskId; - s16* data = gTasks[taskId].data; - if (sub_81221EC() != 1) - { - if (gMain.newKeys & DPAD_UP) - { - data[0] = 3; - sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C7); - } - else if (gMain.newKeys & DPAD_DOWN) - { - data[0] = 3; - sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C7); - } - else if (gMain.newKeys & A_BUTTON) - { - if (gUnknown_0203CF1C->unk40C6 == gUnknown_0203CF1C->unk40C7) - { - sub_81C13B0(taskId, 0); - } - else - sub_81C13B0(taskId, 1); - } - else if (gMain.newKeys & B_BUTTON) - sub_81C13B0(a, 0); - } -} - -void sub_81C13B0(u8 taskId, u8 b) -{ - u16 move; - PlaySE(SE_SELECT); - sub_81C4C84(0); - sub_81C4C60(18); - if (b == 1) - { - if (gUnknown_0203CF1C->unk40BD == 0) - { - struct Pokemon *why = gUnknown_0203CF1C->unk0->mon; - sub_81C14BC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); - } - else - { - struct BoxPokemon *why = gUnknown_0203CF1C->unk0->boxMon; - sub_81C15EC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); - } - sub_81C0098(&gUnknown_0203CF1C->currentMon); - sub_81C40A0(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); - sub_81C4568(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); - gUnknown_0203CF1C->unk40C6 = gUnknown_0203CF1C->unk40C7; - } - move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - sub_81C3E9C(move); - sub_81C240C(move); - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); - gTasks[taskId].func = sub_81C0F44; -} - - -#ifdef NONMATCHING -void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId) -{ - u16 localMoveTo; - u16 localMoveFrom; - u8 localPpTo; - u8 localPpFrom; - u8 localPpBonuses; - u16* moveFromPtr; - u16* moveToPtr; - u8* ppFromPtr; - u8* ppToPtr; - u8* ppBonusesPtr; - - moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId]; - localMoveFrom = *moveFromPtr; - - moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId]; - localMoveTo = *moveToPtr; - - ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId]; - localPpFrom = *ppFromPtr; - - ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId]; - localPpTo = *ppToPtr; - - ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses; - localPpBonuses = *ppBonusesPtr; - -{ - u8 bitsFrom, bitsTo; - - bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1); - bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1); - - - localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]); - localPpBonuses &= ~(gUnknown_08329D22[swappingToId]); - - localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1))); -} - - SetMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo); - SetMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom); - - SetMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo); - SetMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom); - - SetMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses); - - *moveFromPtr = localMoveTo; - *moveToPtr = localMoveFrom; - - *ppFromPtr = localPpTo; - *ppToPtr = localPpFrom; - - *ppBonusesPtr = localPpBonuses; -} -#else -__attribute__((naked)) -void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x28\n\ - adds r7, r0, 0\n\ - adds r4, r1, 0\n\ - adds r6, r2, 0\n\ - lsls r4, 24\n\ - lsrs r4, 24\n\ - lsls r6, 24\n\ - lsrs r6, 24\n\ - ldr r0, =gUnknown_0203CF1C\n\ - ldr r2, [r0]\n\ - lsls r0, r4, 1\n\ - mov r10, r0\n\ - adds r1, r2, 0\n\ - adds r1, 0x84\n\ - adds r0, r1, r0\n\ - str r0, [sp, 0x8]\n\ - ldrh r0, [r0]\n\ - mov r3, sp\n\ - adds r3, 0x2\n\ - str r3, [sp, 0x1C]\n\ - strh r0, [r3]\n\ - lsls r0, r6, 1\n\ - mov r9, r0\n\ - add r1, r9\n\ - str r1, [sp, 0xC]\n\ - ldrh r1, [r1]\n\ - mov r0, sp\n\ - strh r1, [r0]\n\ - adds r1, r2, 0\n\ - adds r1, 0x8C\n\ - adds r3, r1, r4\n\ - str r3, [sp, 0x10]\n\ - ldrb r0, [r3]\n\ - mov r3, sp\n\ - adds r3, 0x5\n\ - str r3, [sp, 0x24]\n\ - strb r0, [r3]\n\ - adds r1, r6\n\ - str r1, [sp, 0x14]\n\ - ldrb r0, [r1]\n\ - mov r1, sp\n\ - adds r1, 0x4\n\ - str r1, [sp, 0x20]\n\ - strb r0, [r1]\n\ - adds r2, 0xA4\n\ - str r2, [sp, 0x18]\n\ - ldrb r0, [r2]\n\ - mov r5, sp\n\ - adds r5, 0x6\n\ - strb r0, [r5]\n\ - ldr r1, =gUnknown_08329D22\n\ - adds r0, r4, r1\n\ - ldrb r0, [r0]\n\ - mov r8, r0\n\ - ldrb r0, [r5]\n\ - adds r2, r0, 0\n\ - mov r3, r8\n\ - ands r2, r3\n\ - mov r3, r10\n\ - asrs r2, r3\n\ - lsls r2, 24\n\ - lsrs r2, 24\n\ - adds r1, r6, r1\n\ - ldrb r1, [r1]\n\ - mov r12, r1\n\ - adds r1, r0, 0\n\ - mov r3, r12\n\ - ands r1, r3\n\ - mov r3, r9\n\ - asrs r1, r3\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - mov r3, r8\n\ - bics r0, r3\n\ - strb r0, [r5]\n\ - ldrb r0, [r5]\n\ - mov r3, r12\n\ - bics r0, r3\n\ - strb r0, [r5]\n\ - mov r0, r9\n\ - lsls r2, r0\n\ - mov r3, r10\n\ - lsls r1, r3\n\ - adds r2, r1\n\ - ldrb r0, [r5]\n\ - orrs r0, r2\n\ - strb r0, [r5]\n\ - adds r1, r4, 0\n\ - adds r1, 0xD\n\ - adds r0, r7, 0\n\ - mov r2, sp\n\ - bl SetMonData\n\ - adds r1, r6, 0\n\ - adds r1, 0xD\n\ - adds r0, r7, 0\n\ - ldr r2, [sp, 0x1C]\n\ - bl SetMonData\n\ - adds r4, 0x11\n\ - adds r0, r7, 0\n\ - adds r1, r4, 0\n\ - ldr r2, [sp, 0x20]\n\ - bl SetMonData\n\ - adds r6, 0x11\n\ - adds r0, r7, 0\n\ - adds r1, r6, 0\n\ - ldr r2, [sp, 0x24]\n\ - bl SetMonData\n\ - adds r0, r7, 0\n\ - movs r1, 0x15\n\ - adds r2, r5, 0\n\ - bl SetMonData\n\ - mov r0, sp\n\ - ldrh r0, [r0]\n\ - ldr r1, [sp, 0x8]\n\ - strh r0, [r1]\n\ - ldr r3, [sp, 0x1C]\n\ - ldrh r0, [r3]\n\ - ldr r1, [sp, 0xC]\n\ - strh r0, [r1]\n\ - ldr r3, [sp, 0x20]\n\ - ldrb r0, [r3]\n\ - ldr r1, [sp, 0x10]\n\ - strb r0, [r1]\n\ - ldr r3, [sp, 0x24]\n\ - ldrb r0, [r3]\n\ - ldr r1, [sp, 0x14]\n\ - strb r0, [r1]\n\ - ldrb r0, [r5]\n\ - ldr r3, [sp, 0x18]\n\ - strb r0, [r3]\n\ - add sp, 0x28\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -#ifdef NONMATCHING -void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId) -{ - u16 localMoveTo; - u16 localMoveFrom; - u8 localPpTo; - u8 localPpFrom; - u8 localPpBonuses; - u16* moveFromPtr; - u16* moveToPtr; - u8* ppFromPtr; - u8* ppToPtr; - u8* ppBonusesPtr; - - moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId]; - localMoveFrom = *moveFromPtr; - - moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId]; - localMoveTo = *moveToPtr; - - ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId]; - localPpFrom = *ppFromPtr; - - ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId]; - localPpTo = *ppToPtr; - - ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses; - localPpBonuses = *ppBonusesPtr; - -{ - u8 bitsFrom, bitsTo; - - bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1); - bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1); - - - localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]); - localPpBonuses &= ~(gUnknown_08329D22[swappingToId]); - - localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1))); -} - - SetBoxMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo); - SetBoxMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom); - - SetBoxMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo); - SetBoxMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom); - - SetBoxMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses); - - *moveFromPtr = localMoveTo; - *moveToPtr = localMoveFrom; - - *ppFromPtr = localPpTo; - *ppToPtr = localPpFrom; - - *ppBonusesPtr = localPpBonuses; -} -#else -__attribute__((naked)) -void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x28\n\ - adds r7, r0, 0\n\ - adds r4, r1, 0\n\ - adds r6, r2, 0\n\ - lsls r4, 24\n\ - lsrs r4, 24\n\ - lsls r6, 24\n\ - lsrs r6, 24\n\ - ldr r0, =gUnknown_0203CF1C\n\ - ldr r2, [r0]\n\ - lsls r0, r4, 1\n\ - mov r10, r0\n\ - adds r1, r2, 0\n\ - adds r1, 0x84\n\ - adds r0, r1, r0\n\ - str r0, [sp, 0x8]\n\ - ldrh r0, [r0]\n\ - mov r3, sp\n\ - adds r3, 0x2\n\ - str r3, [sp, 0x1C]\n\ - strh r0, [r3]\n\ - lsls r0, r6, 1\n\ - mov r9, r0\n\ - add r1, r9\n\ - str r1, [sp, 0xC]\n\ - ldrh r1, [r1]\n\ - mov r0, sp\n\ - strh r1, [r0]\n\ - adds r1, r2, 0\n\ - adds r1, 0x8C\n\ - adds r3, r1, r4\n\ - str r3, [sp, 0x10]\n\ - ldrb r0, [r3]\n\ - mov r3, sp\n\ - adds r3, 0x5\n\ - str r3, [sp, 0x24]\n\ - strb r0, [r3]\n\ - adds r1, r6\n\ - str r1, [sp, 0x14]\n\ - ldrb r0, [r1]\n\ - mov r1, sp\n\ - adds r1, 0x4\n\ - str r1, [sp, 0x20]\n\ - strb r0, [r1]\n\ - adds r2, 0xA4\n\ - str r2, [sp, 0x18]\n\ - ldrb r0, [r2]\n\ - mov r5, sp\n\ - adds r5, 0x6\n\ - strb r0, [r5]\n\ - ldr r1, =gUnknown_08329D22\n\ - adds r0, r4, r1\n\ - ldrb r0, [r0]\n\ - mov r8, r0\n\ - ldrb r0, [r5]\n\ - adds r2, r0, 0\n\ - mov r3, r8\n\ - ands r2, r3\n\ - mov r3, r10\n\ - asrs r2, r3\n\ - lsls r2, 24\n\ - lsrs r2, 24\n\ - adds r1, r6, r1\n\ - ldrb r1, [r1]\n\ - mov r12, r1\n\ - adds r1, r0, 0\n\ - mov r3, r12\n\ - ands r1, r3\n\ - mov r3, r9\n\ - asrs r1, r3\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - mov r3, r8\n\ - bics r0, r3\n\ - strb r0, [r5]\n\ - ldrb r0, [r5]\n\ - mov r3, r12\n\ - bics r0, r3\n\ - strb r0, [r5]\n\ - mov r0, r9\n\ - lsls r2, r0\n\ - mov r3, r10\n\ - lsls r1, r3\n\ - adds r2, r1\n\ - ldrb r0, [r5]\n\ - orrs r0, r2\n\ - strb r0, [r5]\n\ - adds r1, r4, 0\n\ - adds r1, 0xD\n\ - adds r0, r7, 0\n\ - mov r2, sp\n\ - bl SetBoxMonData\n\ - adds r1, r6, 0\n\ - adds r1, 0xD\n\ - adds r0, r7, 0\n\ - ldr r2, [sp, 0x1C]\n\ - bl SetBoxMonData\n\ - adds r4, 0x11\n\ - adds r0, r7, 0\n\ - adds r1, r4, 0\n\ - ldr r2, [sp, 0x20]\n\ - bl SetBoxMonData\n\ - adds r6, 0x11\n\ - adds r0, r7, 0\n\ - adds r1, r6, 0\n\ - ldr r2, [sp, 0x24]\n\ - bl SetBoxMonData\n\ - adds r0, r7, 0\n\ - movs r1, 0x15\n\ - adds r2, r5, 0\n\ - bl SetBoxMonData\n\ - mov r0, sp\n\ - ldrh r0, [r0]\n\ - ldr r1, [sp, 0x8]\n\ - strh r0, [r1]\n\ - ldr r3, [sp, 0x1C]\n\ - ldrh r0, [r3]\n\ - ldr r1, [sp, 0xC]\n\ - strh r0, [r1]\n\ - ldr r3, [sp, 0x20]\n\ - ldrb r0, [r3]\n\ - ldr r1, [sp, 0x10]\n\ - strb r0, [r1]\n\ - ldr r3, [sp, 0x24]\n\ - ldrb r0, [r3]\n\ - ldr r1, [sp, 0x14]\n\ - strb r0, [r1]\n\ - ldrb r0, [r5]\n\ - ldr r3, [sp, 0x18]\n\ - strb r0, [r3]\n\ - add sp, 0x28\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -void sub_81C171C(u8 taskId) -{ - sub_81C44F0(); - sub_81C4AF8(8); - gTasks[taskId].func = sub_81C174C; -} - -void sub_81C174C(u8 taskId) -{ - s16* data = gTasks[taskId].data; - - if (sub_81221EC() != 1) - { - if (gPaletteFade.active != 1) - { - if (gMain.newKeys & DPAD_UP) - { - data[0] = 4; - sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6); - } - else if (gMain.newKeys & DPAD_DOWN) - { - data[0] = 4; - sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6); - } - else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1) - { - sub_81C0A8C(taskId, -1); - } - else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2) - { - sub_81C0A8C(taskId, 1); - } - else if (gMain.newKeys & A_BUTTON) - { - if (sub_81C18A8() == TRUE) - { - sub_81C48F0(); - PlaySE(SE_SELECT); - gUnknown_0203CF21 = gUnknown_0203CF1C->unk40C6; - gSpecialVar_0x8005 = gUnknown_0203CF21; - sub_81C044C(taskId); - } - else - { - PlaySE(0x20); - sub_81C18F4(taskId); - } - } - else if (gMain.newKeys & B_BUTTON) - { - u32 var1; - sub_81C48F0(); - PlaySE(SE_SELECT); - gUnknown_0203CF21 = 4; - gSpecialVar_0x8005 = 4; - sub_81C044C(taskId); - } - } - } -} - -bool8 sub_81C18A8() -{ - if (gUnknown_0203CF1C->unk40C6 == 4 || gUnknown_0203CF1C->unk40C4 == 0 || sub_81B6D14(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]) != 1) - return TRUE; - else - return FALSE; -} - -void sub_81C18F4(u8 taskId) -{ - ClearWindowTilemap(14); - ClearWindowTilemap(15); - schedule_bg_copy_tilemap_to_vram(0); - sub_81C1DA4(0, 3); - sub_81C1EFC(0, 3, 0); - sub_81C4154(); - gTasks[taskId].func = sub_81C1940; -} - -void sub_81C1940(u8 taskId) -{ - s16* data = gTasks[taskId].data; - u16 move; - if (FuncIsActiveTask(sub_81C1E20) != 1) - { - if (gMain.newKeys & DPAD_UP) - { - data[1] = 1; - data[0] = 4; - sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C6); - data[1] = 0; - gTasks[taskId].func = sub_81C174C; - } - else if (gMain.newKeys & DPAD_DOWN) - { - data[1] = 1; - data[0] = 4; - sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C6); - data[1] = 0; - gTasks[taskId].func = sub_81C174C; - } - else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1) - { - if (gUnknown_0203CF1C->unk40C0 != 2) - { - - ClearWindowTilemap(19); - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - ClearWindowTilemap(13); - move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - gTasks[taskId].func = sub_81C174C; - sub_81C0A8C(taskId, -1); - sub_81C1DA4(9, -2); - sub_81C1EFC(9, -2, move); - } - } - else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2) - { - if (gUnknown_0203CF1C->unk40C0 != 3) - { - ClearWindowTilemap(19); - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - ClearWindowTilemap(13); - move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - gTasks[taskId].func = sub_81C174C; - sub_81C0A8C(taskId, 1); - sub_81C1DA4(9, -2); - sub_81C1EFC(9, -2, move); - } - } - else if (gMain.newKeys & (A_BUTTON | B_BUTTON)) - { - ClearWindowTilemap(19); - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - ClearWindowTilemap(13); - move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - sub_81C3E9C(move); - schedule_bg_copy_tilemap_to_vram(0); - sub_81C1DA4(9, -3); - sub_81C1EFC(9, -3, move); - gTasks[taskId].func = sub_81C174C; - } - } -} - -u8 sub_81C1B94() -{ - return gUnknown_0203CF21; -} - -void sub_81C1BA0() -{ - u16 *alloced = Alloc(32); - u8 i; - for (i = 0; i < 4; i++) - { - u8 j = i << 1; - if (i < gUnknown_0203CF1C->unk40C1) - { - alloced[j+0] = 0x40; - alloced[j+1] = 0x40; - alloced[j+8] = 0x50; - alloced[j+9] = 0x50; - } - else if (i > gUnknown_0203CF1C->unk40C2) - { - alloced[j+0] = 0x4A; - alloced[j+1] = 0x4A; - alloced[j+8] = 0x5A; - alloced[j+9] = 0x5A; - } - else if (i < gUnknown_0203CF1C->unk40C0) - { - alloced[j+0] = 0x46; - alloced[j+1] = 0x47; - alloced[j+8] = 0x56; - alloced[j+9] = 0x57; - } - else if (i == gUnknown_0203CF1C->unk40C0) - { - if (i != gUnknown_0203CF1C->unk40C2) - { - alloced[j+0] = 0x41; - alloced[j+1] = 0x42; - alloced[j+8] = 0x51; - alloced[j+9] = 0x52; - } - else - { - alloced[j+0] = 0x4B; - alloced[j+1] = 0x4C; - alloced[j+8] = 0x5B; - alloced[j+9] = 0x5C; - } - } - else if (i != gUnknown_0203CF1C->unk40C2) - { - alloced[j+0] = 0x43; - alloced[j+1] = 0x44; - alloced[j+8] = 0x53; - alloced[j+9] = 0x54; - } - else - { - alloced[j+0] = 0x48; - alloced[j+1] = 0x49; - alloced[j+8] = 0x58; - alloced[j+9] = 0x59; - } - } - CopyToBgTilemapBufferRect_ChangePalette(3, alloced, 11, 0, 8, 2, 16); - schedule_bg_copy_tilemap_to_vram(3); - Free(alloced); -} - -struct UnkStruct_61CC04 -{ - u8 *ptr; - u8 field_4; - u8 field_5; - u8 field_6; - u8 field_7; - u8 field_8; - u8 field_9; -}; - -#ifdef NONMATCHING -void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d) -{ - u8 *alloced = Alloc(a->field_6 * (a->field_7 << 1)); - CpuFill16(a->field_4, alloced, a->field_7*a->field_6); - if (a->field_6 != c) - { - if (!d) - { - for (d;d < a->field_7; d++) - { - CpuCopy16(&a->ptr + ((c + a->field_6*d)), alloced + ((a->field_6*d) << 1), (a->field_6 - c) * 2); - } - } - else - { - for (d = 0;d < a->field_7; d++) - { - CpuCopy16(&a->ptr + (a->field_6*d), alloced + ((c + a->field_6*d) << 1), (a->field_6 - c) * 2); - } - } - } - d = 0; - while (d < a->field_7) - { - CpuCopy16(alloced + ((a->field_6*d) << 1), b + ((((a->field_9 + d) << 5) + a->field_8) << 1), a->field_6 * 2); - d++; - } - Free(alloced); -} -#else -__attribute__((naked)) -void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r8\n\ - push {r7}\n\ - sub sp, 0x4\n\ - adds r4, r0, 0\n\ - mov r8, r1\n\ - lsls r2, 24\n\ - lsrs r6, r2, 24\n\ - lsls r3, 24\n\ - lsrs r5, r3, 24\n\ - ldrb r1, [r4, 0x6]\n\ - ldrb r0, [r4, 0x7]\n\ - lsls r0, 1\n\ - muls r0, r1\n\ - bl Alloc\n\ - adds r7, r0, 0\n\ - mov r1, sp\n\ - ldrh r0, [r4, 0x4]\n\ - strh r0, [r1]\n\ - ldrb r1, [r4, 0x7]\n\ - ldrb r0, [r4, 0x6]\n\ - adds r2, r1, 0\n\ - muls r2, r0\n\ - movs r0, 0x80\n\ - lsls r0, 17\n\ - orrs r2, r0\n\ - mov r0, sp\n\ - adds r1, r7, 0\n\ - bl CpuSet\n\ - ldrb r0, [r4, 0x6]\n\ - cmp r0, r6\n\ - beq _081C1D60\n\ - cmp r5, 0\n\ - bne _081C1D30\n\ - movs r5, 0\n\ - ldrb r0, [r4, 0x7]\n\ - cmp r5, r0\n\ - bcs _081C1D60\n\ -_081C1D00:\n\ - ldrb r2, [r4, 0x6]\n\ - adds r1, r2, 0\n\ - muls r1, r5\n\ - adds r3, r6, r1\n\ - lsls r3, 1\n\ - ldr r0, [r4]\n\ - adds r0, r3\n\ - lsls r1, 1\n\ - adds r1, r7, r1\n\ - subs r2, r6\n\ - ldr r3, =0x001fffff\n\ - ands r2, r3\n\ - bl CpuSet\n\ - adds r0, r5, 0x1\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ - ldrb r3, [r4, 0x7]\n\ - cmp r5, r3\n\ - bcc _081C1D00\n\ - b _081C1D60\n\ - .pool\n\ -_081C1D30:\n\ - movs r5, 0\n\ - ldrb r0, [r4, 0x7]\n\ - cmp r5, r0\n\ - bcs _081C1D60\n\ -_081C1D38:\n\ - ldrb r2, [r4, 0x6]\n\ - adds r1, r2, 0\n\ - muls r1, r5\n\ - lsls r3, r1, 1\n\ - ldr r0, [r4]\n\ - adds r0, r3\n\ - adds r1, r6, r1\n\ - lsls r1, 1\n\ - adds r1, r7, r1\n\ - subs r2, r6\n\ - ldr r3, =0x001fffff\n\ - ands r2, r3\n\ - bl CpuSet\n\ - adds r0, r5, 0x1\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ - ldrb r3, [r4, 0x7]\n\ - cmp r5, r3\n\ - bcc _081C1D38\n\ -_081C1D60:\n\ - movs r5, 0\n\ - b _081C1D8A\n\ - .pool\n\ -_081C1D68:\n\ - ldrb r2, [r4, 0x6]\n\ - adds r0, r2, 0\n\ - muls r0, r5\n\ - lsls r0, 1\n\ - adds r0, r7, r0\n\ - ldrb r1, [r4, 0x9]\n\ - adds r1, r5\n\ - lsls r1, 5\n\ - ldrb r3, [r4, 0x8]\n\ - adds r1, r3\n\ - lsls r1, 1\n\ - add r1, r8\n\ - bl CpuSet\n\ - adds r0, r5, 0x1\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ -_081C1D8A:\n\ - ldrb r0, [r4, 0x7]\n\ - cmp r5, r0\n\ - bcc _081C1D68\n\ - adds r0, r7, 0\n\ - bl Free\n\ - add sp, 0x4\n\ - pop {r3}\n\ - mov r8, r3\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .syntax divided\n"); -} -#endif - -void sub_81C1DA4(u16 a, s16 b) -{ - if (b > gUnknown_0861CC04.field_6) - b = gUnknown_0861CC04.field_6; - if (b == 0 || b == gUnknown_0861CC04.field_6) - { - sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], b, 1); - } - else - { - u8 taskId = FindTaskIdByFunc(sub_81C1E20); - if (taskId == 0xFF) - { - taskId = CreateTask(sub_81C1E20, 8); - } - gTasks[taskId].data[0] = b; - gTasks[taskId].data[1] = a; - } -} - -void sub_81C1E20(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - data[1] += data[0]; - if (data[1] < 0) - { - data[1] = 0; - } - else if (data[1] > gUnknown_0861CC04.field_6) - { - data[1] = gUnknown_0861CC04.field_6; - } - sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], data[1], 1); - if (data[1] <= 0 || data[1] >= gUnknown_0861CC04.field_6) - { - if (data[0] < 0) - { - if (gUnknown_0203CF1C->unk40C0 == 2) - PutWindowTilemap(14); - - } - else - { - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - PutWindowTilemap(13); - PutWindowTilemap(19); - } - schedule_bg_copy_tilemap_to_vram(0); - DestroyTask(taskId); - } - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); -} - -void sub_81C1EFC(u16 a, s16 b, u16 move) -{ - if (b > gUnknown_0861CC10.field_6) - b = gUnknown_0861CC10.field_6; - if (b == 0 || b == gUnknown_0861CC10.field_6) - sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], b, 1); - else - { - u8 taskId = FindTaskIdByFunc(sub_81C1F80); - if (taskId == 0xFF) - taskId = CreateTask(sub_81C1F80, 8); - gTasks[taskId].data[0] = b; - gTasks[taskId].data[1] = a; - gTasks[taskId].data[2] = move; - } -} - -void sub_81C1F80(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - data[1] += data[0]; - if (data[1] < 0) - { - data[1] = 0; - } - else if (data[1] > gUnknown_0861CC10.field_6) - { - data[1] = gUnknown_0861CC10.field_6; - } - sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], data[1], 1); - if (data[1] <= 0 || data[1] >= gUnknown_0861CC10.field_6) - { - if (data[0] < 0) - { - if (gUnknown_0203CF1C->unk40C0 == 3 && FuncIsActiveTask(sub_81C0B8C) == 0) - PutWindowTilemap(15); - sub_81C240C(data[2]); - } - else - { - if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) - { - PutWindowTilemap(13); - } - PutWindowTilemap(19); - } - schedule_bg_copy_tilemap_to_vram(0); - DestroyTask(taskId); - } - schedule_bg_copy_tilemap_to_vram(1); - schedule_bg_copy_tilemap_to_vram(2); -} - -void sub_81C2074(u16 a, s16 b) -{ - if (b > gUnknown_0861CBEC.field_6) - b = gUnknown_0861CBEC.field_6; - if (b == 0 || b == gUnknown_0861CBEC.field_6) - { - sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], b, 0); - sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], b, 0); - } - else - { - u8 taskId = CreateTask(sub_81C20F0, 8); - gTasks[taskId].data[0] = b; - gTasks[taskId].data[1] = a; - } -} - -void sub_81C20F0(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - data[1] += data[0]; - if (data[1] < 0) - data[1] = 0; - else if (data[1] > gUnknown_0861CBEC.field_6) - data[1] = gUnknown_0861CBEC.field_6; - sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0); - sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0); - schedule_bg_copy_tilemap_to_vram(3); - if (data[1] <= 0 || data[1] >= gUnknown_0861CBEC.field_6) - { - if (data[0] < 0) - { - sub_81C4A88(); - PutWindowTilemap(13); - schedule_bg_copy_tilemap_to_vram(0); - } - DestroyTask(taskId); - } -} - -// somebody send help this is a complete fucking mess -#ifdef NONMATCHING -void sub_81C2194(u16 *a, u16 b, u8 c) -{ - u16 i; - int var; - b *= 0x1000; - var = 0x56A; - - if (c == 0) - { - for (i = 0; i < 20; i++) - { - a[(i + var) << 1] = gUnknown_08DC3CD4[i] + b; - a[((i + var) << 1) + 0x40] = gUnknown_08DC3CD4[i] + b; - a[((i + var) << 1) + 0x80] = gUnknown_08DC3CD4[i + 20] + b; - } - } - else - { - for (i = 0; i < 20; i++) - { - a[(i + var)] = gUnknown_08DC3CD4[i + 20] + b; - a[((i + var)) + 0x40] = gUnknown_08DC3CD4[i + 40] + b; - a[((i + var)) + 0x80] = gUnknown_08DC3CD4[i + 40] + b; - } - } -} -#else -__attribute__((naked)) -void sub_81C2194(u16 *a, u16 b, u8 c) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - adds r6, r0, 0\n\ - lsls r2, 24\n\ - lsls r1, 28\n\ - lsrs r4, r1, 16\n\ - ldr r7, =0x0000056a\n\ - cmp r2, 0\n\ - bne _081C21E4\n\ - movs r3, 0\n\ - ldr r5, =gUnknown_08DC3CD4\n\ -_081C21A8:\n\ - adds r2, r7, r3\n\ - lsls r2, 1\n\ - adds r2, r6\n\ - lsls r0, r3, 1\n\ - adds r0, r5\n\ - ldrh r1, [r0]\n\ - adds r1, r4, r1\n\ - strh r1, [r2]\n\ - adds r0, r2, 0\n\ - adds r0, 0x40\n\ - strh r1, [r0]\n\ - adds r2, 0x80\n\ - adds r0, r3, 0\n\ - adds r0, 0x14\n\ - lsls r0, 1\n\ - adds r0, r5\n\ - ldrh r0, [r0]\n\ - adds r0, r4, r0\n\ - strh r0, [r2]\n\ - adds r0, r3, 0x1\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - cmp r3, 0x13\n\ - bls _081C21A8\n\ - b _081C221C\n\ - .pool\n\ -_081C21E4:\n\ - movs r3, 0\n\ - ldr r5, =gUnknown_08DC3CD4\n\ -_081C21E8:\n\ - adds r1, r7, r3\n\ - lsls r1, 1\n\ - adds r1, r6\n\ - adds r0, r3, 0\n\ - adds r0, 0x14\n\ - lsls r0, 1\n\ - adds r0, r5\n\ - ldrh r0, [r0]\n\ - adds r0, r4, r0\n\ - strh r0, [r1]\n\ - adds r2, r1, 0\n\ - adds r2, 0x40\n\ - adds r0, r3, 0\n\ - adds r0, 0x28\n\ - lsls r0, 1\n\ - adds r0, r5\n\ - ldrh r0, [r0]\n\ - adds r0, r4, r0\n\ - strh r0, [r2]\n\ - adds r1, 0x80\n\ - strh r0, [r1]\n\ - adds r0, r3, 0x1\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - cmp r3, 0x13\n\ - bls _081C21E8\n\ -_081C221C:\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -void sub_81C2228(struct Pokemon *mon) -{ - if (!CheckPartyPokerus(mon, 0) && CheckPartyHasHadPokerus(mon, 0)) - { - gUnknown_0203CF1C->unkTilemap0[0x223] = 0x2C; - gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x2C; - } - else - { - gUnknown_0203CF1C->unkTilemap0[0x223] = 0x81A; - gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x81A; - } - schedule_bg_copy_tilemap_to_vram(3); -} - -void sub_81C228C(u8 a) -{ - if (a == 0) - sub_8199C30(3, 1, 4, 8, 8, 0); - else - sub_8199C30(3, 1, 4, 8, 8, 5); - schedule_bg_copy_tilemap_to_vram(3); -} - -void sub_81C22CC(struct Pokemon *unused) -{ - s64 r6r7; - struct PokeSummary *summary = &gUnknown_0203CF1C->summary; - u16 *r9; - u8 i; - - if (summary->level < MAX_MON_LEVEL) - { - u32 r1 = gExperienceTables[gBaseStats[summary->species].growthRate][summary->level + 1] - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level]; - u32 r4 = summary->exp - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level]; - - r6r7 = r4 * 64 / r1; - if (r6r7 == 0 && r4 != 0) - r6r7 = 1; - } - else - { - r6r7 = 0; - } - - r9 = &gUnknown_0203CF1C->unkTilemap1_1[0x255]; - for (i = 0; i < 8; i++) - { - if (r6r7 > 7) - r9[i] = 0x206A; - else - r9[i] = 0x2062 + (r6r7 % 8); - r6r7 -= 8; - if (r6r7 < 0) - r6r7 = 0; - } - - if (GetBgTilemapBuffer(1) == gUnknown_0203CF1C->unkTilemap1) - schedule_bg_copy_tilemap_to_vram(1); - else - schedule_bg_copy_tilemap_to_vram(2); -} - -void sub_81C240C(u16 move) -{ - u16* r5 = &gUnknown_0203CF1C->unkTilemap3_1[0]; - u8 i; - u8 r4; - if (move != MOVE_NONE) - { - r4 = gContestEffects[gContestMoves[move].effect].appeal; - if (r4 != 0xFF) - r4 /= 10; - for (i = 0;i < 8; i++) - { - if (r4 != 0xFF && i < r4) - { - r5[((i>>2)*32)+(i&3)+0x1E6] = 0x103A; - } - else - r5[((i>>2)*32)+(i&3)+0x1E6] = 0x1039; - } - r4 = gContestEffects[gContestMoves[move].effect].jam; - if (r4 != 0xFF) - r4 /= 10; - for (i = 0;i < 8; i++) - { - if (r4 != 0xFF && i < r4) - { - r5[((i>>2)*32)+(i&3)+0x226] = 0x103C; - } - else - r5[((i>>2)*32)+(i&3)+0x226] = 0x103D; - } - } -} - -void sub_81C2524() -{ - if (gUnknown_0203CF1C->summary.isEgg != 0) - ChangeBgX(3, 0x10000, 0); - else - ChangeBgX(3, 0, 0); -} - -void sub_81C2554() -{ - u8 i; - InitWindows(&gUnknown_0861CC24); - DeactivateAllTextPrinters(); - for (i = 0; i < 20; i++) - FillWindowPixelBuffer(i, 0); - for (i = 0; i < 8; i++) - gUnknown_0203CF1C->unk40CB[i] |= 0xFF; -} - -void sub_81C25A4(u8 a, u8 *b, u8 c, u8 d, u8 e, u8 f) -{ - AddTextPrinterParametrized2(a, 1, c, d, 0, e, &gUnknown_0861CD2C[f], 0, b); -} - -void sub_81C25E8() -{ - FillWindowPixelBuffer(17, 0); - FillWindowPixelBuffer(18, 0); - FillWindowPixelBuffer(19, 0); - if (gUnknown_0203CF1C->summary.isEgg == 0) - sub_81C2628(); - else - sub_81C2794(); - schedule_bg_copy_tilemap_to_vram(0); -} - -void sub_81C2628() -{ - u8 strArray[16]; - struct Pokemon *mon = &gUnknown_0203CF1C->currentMon; - struct PokeSummary *summary = &gUnknown_0203CF1C->summary; - u16 r5 = SpeciesToPokedexNum(summary->species); - if (r5 != 0xFFFF) - { - StringCopy(gStringVar1, &gText_UnkCtrlF908Clear01[0]); - ConvertIntToDecimalStringN(gStringVar2, r5, 2, 3); - StringAppend(gStringVar1, gStringVar2); - if (IsMonShiny(mon) == 0) - { - sub_81C25A4(17, gStringVar1, 0, 1, 0, 1); - sub_81C228C(0); - } - else - { - sub_81C25A4(17, gStringVar1, 0, 1, 0, 7); - sub_81C228C(1); - } - PutWindowTilemap(17); - } - else - { - ClearWindowTilemap(17); - if (IsMonShiny(mon) == 0) - sub_81C228C(0); - else - sub_81C228C(1); - } - StringCopy(gStringVar1, &gText_LevelSymbol[0]); - ConvertIntToDecimalStringN(gStringVar2, summary->level, 0, 3); - StringAppend(gStringVar1, gStringVar2); - sub_81C25A4(19, gStringVar1, 0x18, 17, 0, 1); - GetMonNickname(mon, gStringVar1); - sub_81C25A4(18, gStringVar1, 0, 1, 0, 1); - strArray[0] = CHAR_SLASH; - StringCopy(&strArray[1], &gSpeciesNames[summary->species2][0]); - sub_81C25A4(19, &strArray[0], 0, 1, 0, 1); - sub_81C27DC(mon, summary->species2); - PutWindowTilemap(18); - PutWindowTilemap(19); -} - -void sub_81C2794() -{ - GetMonNickname(&gUnknown_0203CF1C->currentMon, gStringVar1); - sub_81C25A4(18, gStringVar1, 0, 1, 0, 1); - PutWindowTilemap(18); - ClearWindowTilemap(17); - ClearWindowTilemap(19); -} - -void sub_81C27DC(struct Pokemon *mon, u16 a) -{ - if (a != SPECIES_NIDORAN_M && a != SPECIES_NIDORAN_F) - { - u8 gender = GetMonGender(mon); - switch (gender) - { - case 0: - sub_81C25A4(0x13, &gText_MaleSymbol[0], 0x39, 17, 0, 3); - break; - case 0xFE: - sub_81C25A4(0x13, &gText_FemaleSymbol[0], 0x39, 17, 0, 4); - break; - } - } -} - -void sub_81C2838(u8 a, bool8 b, u32 c) -{ - BlitBitmapToWindow(a, (b) ? &gUnknown_0861CDD3[0] : &gUnknown_0861CDD3[0] - 0x80, c, 0, 16, 16); -} - -void sub_81C286C() -{ - int r4; - int r2; - int temp; - sub_81C25A4(0, gText_PkmnInfo, 2, 1, 0, 1); - sub_81C25A4(1, gText_PkmnSkills, 2, 1, 0, 1); - sub_81C25A4(2, gText_BattleMoves, 2, 1, 0, 1); - sub_81C25A4(3, gText_ContestMoves, 2, 1, 0, 1); - r4 = GetStringRightAlignXOffset(1, gText_Cancel2, 0x3E); - r2 = r4 - 16; - if (r2 < 0) - r2 = 0; - sub_81C2838(4, 0, r2); - sub_81C25A4(4, gText_Cancel2, r4, 1, 0, 0); - r4 = GetStringRightAlignXOffset(1, gText_Info, 0x3E); - r2 = r4 - 16; - if (r2 < 0) - r2 = 0; - sub_81C2838(5, 0, r2); - sub_81C25A4(5, gText_Info, r4, 1, 0, 0); - r4 = GetStringRightAlignXOffset(1, gText_Switch, 0x3E); - r2 = r4 - 16; - if (r2 < 0) - r2 = 0; - sub_81C2838(6, 0, r2); - sub_81C25A4(6, gText_Switch, r4, 1, 0, 0); - sub_81C25A4(8, gText_RentalPkmn, 0, 1, 0, 1); - sub_81C25A4(9, gText_TypeSlash, 0, 1, 0, 0); - temp = 6; - temp += GetStringCenterAlignXOffset(1, gText_HP4, 42); - sub_81C25A4(10, gText_HP4, temp, 1, 0, 1); - temp = 6; - temp += GetStringCenterAlignXOffset(1, gText_Attack3, 42); - sub_81C25A4(10, gText_Attack3, temp, 17, 0, 1); - temp = 6; - temp += GetStringCenterAlignXOffset(1, gText_Defense3, 42); - sub_81C25A4(10, gText_Defense3, temp, 33, 0, 1); - temp = 2; - temp += GetStringCenterAlignXOffset(1, gText_SpAtk4, 36); - sub_81C25A4(11, gText_SpAtk4, temp, 1, 0, 1); - temp = 2; - temp += GetStringCenterAlignXOffset(1, gText_SpDef4, 36); - sub_81C25A4(11, gText_SpDef4, temp, 17, 0, 1); - temp = 2; - temp += GetStringCenterAlignXOffset(1, gText_Speed2, 36); - sub_81C25A4(11, gText_Speed2, temp, 33, 0, 1); - sub_81C25A4(12, gText_ExpPoints, 6, 1, 0, 1); - sub_81C25A4(12, gText_NextLv, 6, 17, 0, 1); - sub_81C25A4(13, gText_Status, 2, 1, 0, 1); - sub_81C25A4(14, gText_Power, 0, 1, 0, 1); - sub_81C25A4(14, gText_Accuracy2, 0, 17, 0, 1); - sub_81C25A4(15, gText_Appeal, 0, 1, 0, 1); - sub_81C25A4(15, gText_Jam, 0, 17, 0, 1); -} - -void sub_81C2AFC(u8 a) -{ - u8 i; - ClearWindowTilemap(0); - ClearWindowTilemap(1); - ClearWindowTilemap(2); - ClearWindowTilemap(3); - switch (a) - { - case 0: - PutWindowTilemap(0); - PutWindowTilemap(4); - if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE) - PutWindowTilemap(8); - PutWindowTilemap(9); - break; - case 1: - PutWindowTilemap(1); - PutWindowTilemap(10); - PutWindowTilemap(11); - PutWindowTilemap(12); - break; - case 2: - PutWindowTilemap(2); - if (gUnknown_0203CF1C->unk40BC == 3) - { - if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - PutWindowTilemap(14); - } - else - PutWindowTilemap(5); - break; - case 3: - PutWindowTilemap(3); - if (gUnknown_0203CF1C->unk40BC == 3) - { - if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - PutWindowTilemap(15); - } - else - PutWindowTilemap(5); - break; - } - for (i = 0; i < 8; i++) - { - PutWindowTilemap(gUnknown_0203CF1C->unk40CB[i]); - } - schedule_bg_copy_tilemap_to_vram(0); -} - -void sub_81C2C38(u8 a) -{ - u8 i; - switch (a) - { - case 0: - ClearWindowTilemap(4); - if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE) - ClearWindowTilemap(8); - ClearWindowTilemap(9); - break; - case 1: - ClearWindowTilemap(10); - ClearWindowTilemap(11); - ClearWindowTilemap(12); - break; - case 2: - if (gUnknown_0203CF1C->unk40BC == 3) - { - if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - ClearWindowTilemap(14); - } - else - ClearWindowTilemap(5); - break; - case 3: - if (gUnknown_0203CF1C->unk40BC == 3) - { - if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - ClearWindowTilemap(15); - } - else - ClearWindowTilemap(5); - break; - } - for (i = 0; i < 8; i++) - sub_81C2D68(i); - schedule_bg_copy_tilemap_to_vram(0); -} - - - -#ifdef NONMATCHING -u8 sub_81C2D2C(struct WindowTemplate *template, u8 a) -{ - u8 *r4 = gUnknown_0203CF1C->unk40CB; - if (r4[a] == 0xFF) - { - r4[a] = AddWindow(&template[a]); - FillWindowPixelBuffer(r4[a], 0); - } - return r4[a]; -} -#else -__attribute__((naked)) -u8 sub_81C2D2C(struct WindowTemplate *template, u8 a) -{ - asm(".syntax unified\n\ - push {r4,lr}\n\ - adds r3, r0, 0\n\ - lsls r1, 24\n\ - lsrs r2, r1, 24\n\ - ldr r0, =gUnknown_0203CF1C\n\ - ldr r4, =0x000040cb\n\ - adds r1, r2, r4\n\ - ldr r0, [r0]\n\ - adds r4, r0, r1\n\ - ldrb r0, [r4]\n\ - cmp r0, 0xFF\n\ - bne _081C2D56\n\ - lsls r0, r2, 3\n\ - adds r0, r3, r0\n\ - bl AddWindow\n\ - strb r0, [r4]\n\ - ldrb r0, [r4]\n\ - movs r1, 0\n\ - bl FillWindowPixelBuffer\n\ -_081C2D56:\n\ - ldrb r0, [r4]\n\ - pop {r4}\n\ - pop {r1}\n\ - bx r1\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -#ifdef NONMATCHING -void sub_81C2D68(u8 a) -{ - u8 *r4 = gUnknown_0203CF1C->unk40CB; - if (r4[a] != 0xFF) - { - ClearWindowTilemap(r4[a]); - RemoveWindow(r4[a]); - r4[a] = 0xFF; - } -} -#else -__attribute__((naked)) -void sub_81C2D68(u8 a) -{ - asm(".syntax unified\n\ - push {r4,lr}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - ldr r1, =gUnknown_0203CF1C\n\ - ldr r2, =0x000040cb\n\ - adds r0, r2\n\ - ldr r1, [r1]\n\ - adds r4, r1, r0\n\ - ldrb r0, [r4]\n\ - cmp r0, 0xFF\n\ - beq _081C2D8C\n\ - bl ClearWindowTilemap\n\ - ldrb r0, [r4]\n\ - bl RemoveWindow\n\ - movs r0, 0xFF\n\ - strb r0, [r4]\n\ -_081C2D8C:\n\ - pop {r4}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -void sub_81C2D9C(u8 a) -{ - u16 i; - for (i = 0; i < 8; i++) - { - if (gUnknown_0203CF1C->unk40CB[i] != 0xFF) - FillWindowPixelBuffer(gUnknown_0203CF1C->unk40CB[i], 0); - } - gUnknown_0861CE54[a](); -} - -void sub_81C2DE4(u8 a) -{ - CreateTask(gUnknown_0861CE64[a], 16); -} - -void sub_81C2E00() -{ - if (gUnknown_0203CF1C->summary.isEgg) - { - sub_81C335C(); - sub_81C33CC(); - sub_81C3428(); - sub_81C349C(); - } - else - { - sub_81C2EC4(); - sub_81C2F5C(); - sub_81C2FD8(); - sub_81C302C(); - sub_81C307C(); - sub_81C3194(); - } -} - -void sub_81C2E40(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - s16 dataa = data[0] - 1; - switch (dataa) - { - case 0: - sub_81C2EC4(); - break; - case 1: - sub_81C2F5C(); - break; - case 2: - sub_81C2FD8(); - break; - case 3: - sub_81C302C(); - break; - case 4: - sub_81C307C(); - break; - case 5: - sub_81C3194(); - break; - case 6: - DestroyTask(taskId); - return; - } - data[0]++; -} - -void sub_81C2EC4() -{ - u8 r5; - int r2; - if (sub_81A6BF4() != 1 && sub_81B9E94() != 1) - { - r5 = sub_81C2D2C(&gUnknown_0861CCCC, 0); - sub_81C25A4(r5, gText_OTSlash, 0, 1, 0, 1); - r2 = GetStringWidth(1, gText_OTSlash, 0); - if (gUnknown_0203CF1C->summary.OTGender == 0) - sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 5); - else - sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 6); - } -} - -void sub_81C2F5C() -{ - int r4; - if (sub_81A6BF4() != TRUE && sub_81B9E94() != TRUE) - { - ConvertIntToDecimalStringN(StringCopy(gStringVar1, gText_UnkCtrlF907F908), (u16)gUnknown_0203CF1C->summary.OTID, 2, 5); - r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38); - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1); - } -} - -void sub_81C2FD8() -{ - u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility); - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityNames[ability], 0, 1, 0, 1); -} - -void sub_81C302C() -{ - u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility); - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityDescriptionPointers[ability], 0, 17, 0, 0); -} - -void sub_81C307C() -{ - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - u8 *text; - sub_81AFBF0(); - sub_81AFC0C(0, gUnknown_0861CE74); - sub_81AFC0C(1, gUnknown_0861CE7B); - sub_81C31C0(); - if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE || sub_81C3304() == TRUE) - sub_81AFC28(gStringVar4, gText_XNature); - else - { - u8 *alloced1 = Alloc(32); - u8 *alloced2 = Alloc(32); - sub_81C31F0(alloced1); - if (sum->metLocation <= 0xD4) - { - sub_8124610(alloced2, sum->metLocation); - sub_81AFC0C(4, alloced2); - } - if (sub_81C3220() == 1) - { - if (sum->metLevel == 0) - text = (sum->metLocation > 0xD4) ? gText_XNatureHatchedSomewhereAt : gText_XNatureHatchedAtYZ; - else - text = (sum->metLocation > 0xD4) ? gText_XNatureMetSomewhereAt : gText_XNatureMetAtYZ; - } - else if (sum->metLocation == 0xFF) - text = gText_XNatureFatefulEncounter; - else if (sum->metLocation != 0xFE && sub_81C32BC()) - text = (sum->metLocation > 0xD4) ? gText_XNatureObtainedInTrade : gText_XNatureProbablyMetAt; - else - text = gText_XNatureObtainedInTrade; - sub_81AFC28(gStringVar4, text); - Free(alloced1); - Free(alloced2); - } -} - -void sub_81C3194() -{ - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), gStringVar4, 0, 1, 0, 0); -} - -void sub_81C31C0() -{ - struct UnkSummaryStruct *sumStruct = gUnknown_0203CF1C; - sub_81AFC0C(2, gNatureNamePointers[sumStruct->summary.nature]); - sub_81AFC0C(5, gText_EmptyString5); -} - -void sub_81C31F0(u8 *a) -{ - u8 level = gUnknown_0203CF1C->summary.metLevel; - if (level == 0) - level = 5; - ConvertIntToDecimalStringN(a, level, 0, 3); - sub_81AFC0C(3, a); -} - -u8 sub_81C3220() -{ - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - u32 r4; - u8 r5; - if (gUnknown_0203CF1C->unk0 == (union UnkUnion *)&gEnemyParty) - { - u8 multiID = GetMultiplayerId()^1; - r4 = (u16)gLinkPlayers[multiID].trainerId; - r5 = gLinkPlayers[multiID].gender; - StringCopy(gStringVar1, gLinkPlayers[multiID].name); - } - else - { - r4 = GetPlayerIDAsU32() & 0xFFFF; - r5 = gSaveBlock2Ptr->playerGender; - StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); - } - if (r5 != sum->OTGender || r4 != (sum->OTID & 0xFFFF) || StringCompareWithoutExtCtrlCodes(gStringVar1, sum->OTName)) - { - return 0; - } - return 1; -} - -bool8 sub_81C32BC() -{ - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - u8 r0 = sum->metGame - 1; - if (r0 <= 4) - return TRUE; - return FALSE; -} - -bool8 sub_81C32E0() -{ - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - u8 r0 = sum->metGame - 1; - if (r0 <= 2) - return TRUE; - return FALSE; -} - -bool8 sub_81C3304() -{ - if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) && gMain.inBattle) - { - if (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5) - return TRUE; - } - return FALSE; -} - -#ifdef NONMATCHING -void sub_81C335C() -{ - u8 r4 = sub_81C2D2C(&gUnknown_0861CCCC, 0); - u32 r5 = GetStringWidth(1, gText_OTSlash, 0); - sub_81C25A4(r4, gText_OTSlash, 0, 1, 0, 1); - sub_81C25A4(r4, gText_FiveMarks, r5, 1, 0, 1); -} -#else -__attribute__((naked)) -void sub_81C335C() -{ - asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5,r6}\n\ - sub sp, 0x8\n\ - ldr r0, =gUnknown_0861CCCC\n\ - movs r1, 0\n\ - bl sub_81C2D2C\n\ - adds r4, r0, 0\n\ - lsls r4, 24\n\ - lsrs r4, 24\n\ - ldr r0, =gText_OTSlash\n\ - mov r8, r0\n\ - movs r0, 0x1\n\ - mov r1, r8\n\ - movs r2, 0\n\ - bl GetStringWidth\n\ - adds r5, r0, 0\n\ - movs r0, 0\n\ - mov r9, r0\n\ - str r0, [sp]\n\ - movs r6, 0x1\n\ - str r6, [sp, 0x4]\n\ - adds r0, r4, 0\n\ - mov r1, r8\n\ - movs r2, 0\n\ - movs r3, 0x1\n\ - bl sub_81C25A4\n\ - ldr r1, =gText_FiveMarks\n\ - lsls r5, 24\n\ - lsrs r5, 24\n\ - mov r0, r9\n\ - str r0, [sp]\n\ - str r6, [sp, 0x4]\n\ - adds r0, r4, 0\n\ - adds r2, r5, 0\n\ - movs r3, 0x1\n\ - bl sub_81C25A4\n\ - add sp, 0x8\n\ - pop {r3,r4}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - pop {r4-r6}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -void sub_81C33CC() -{ - int r4; - StringCopy(gStringVar1, gText_UnkCtrlF907F908); - StringAppend(gStringVar1, gText_FiveMarks); - r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38); - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1); -} - -void sub_81C3428() -{ - u8 *text; - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - if (gUnknown_0203CF1C->summary.sanity == 1) - text = gText_EggWillTakeALongTime; - else if (sum->friendship <= 5) - text = gText_EggAboutToHatch; - else if (sum->friendship <= 10) - text = gText_EggWillHatchSoon; - else if (sum->friendship <= 40) - text = gText_EggWillTakeSomeTime; - else - text = gText_EggWillTakeALongTime; - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), text, 0, 1, 0, 0); -} - -void sub_81C349C() -{ - u8 *text; - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - if (gUnknown_0203CF1C->summary.sanity != 1) - { - if (sum->metLocation == 0xFF) - text = gText_PeculiarEggNicePlace; - else if (sub_81C32BC() == 0 || sub_81C3220() == 0) - text = gText_PeculiarEggTrade; - else if (sum->metLocation == 0xFD) - text = (sub_81C32E0() == TRUE) ? gText_EggFromHotSprings : gText_EggFromTraveler; - else - text = gText_OddEggFoundByCouple; - } - else - text = gText_OddEggFoundByCouple; - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), text, 0, 1, 0, 0); -} - -void sub_81C3530() -{ - sub_81C35E4(); - sub_81C3690(); - sub_81C3710(); - sub_81C37D8(); - sub_81C3808(); - sub_81C3890(); - sub_81C38C0(); -} - -void sub_81C3554(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - s16 dataa = data[0] - 1; - switch (dataa) - { - case 0: - sub_81C35E4(); - break; - case 1: - sub_81C3690(); - break; - case 2: - sub_81C3710(); - break; - case 3: - sub_81C37D8(); - break; - case 4: - sub_81C3808(); - break; - case 5: - sub_81C3890(); - break; - case 6: - sub_81C38C0(); - break; - case 7: - DestroyTask(taskId); - return; - } - data[0]++; -} - -void sub_81C35E4() -{ - u8 *text; - int offset; - if (gUnknown_0203CF1C->summary.item == ITEM_ENIGMA_BERRY && sub_81B1250() == 1 && (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5)) - { - text = (u8*)ItemId_GetItem(ITEM_ENIGMA_BERRY); - } - else if (gUnknown_0203CF1C->summary.item == ITEM_NONE) - text = gText_None; - else - { - CopyItemName(gUnknown_0203CF1C->summary.item, gStringVar1); - text = gStringVar1; - } - offset = GetStringCenterAlignXOffset(1, text, 0x48) + 6; - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 0), text, offset, 1, 0, 0); -} - -void sub_81C3690() -{ - u8 *text; - int offset; - if (gUnknown_0203CF1C->summary.ribbons == 0) - text = gText_None; - else - { - ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.ribbons, 1, 2); - StringExpandPlaceholders(gStringVar4, gText_RibbonsVar1); - text = gStringVar4; - } - offset = GetStringCenterAlignXOffset(1, text, 0x46) + 6; - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 1), text, offset, 1, 0, 0); -} - -void sub_81C3710() -{ - u8 *alloced1 = Alloc(8); - u8 *alloced2 = Alloc(8); - u8 *alloced3 = Alloc(8); - u8 *alloced4 = Alloc(8); - ConvertIntToDecimalStringN(alloced1, gUnknown_0203CF1C->summary.currentHP, 1, 3); - ConvertIntToDecimalStringN(alloced2, gUnknown_0203CF1C->summary.maxHP, 1, 3); - ConvertIntToDecimalStringN(alloced3, gUnknown_0203CF1C->summary.atk, 1, 7); - ConvertIntToDecimalStringN(alloced4, gUnknown_0203CF1C->summary.def, 1, 7); - sub_81AFBF0(); - sub_81AFC0C(0, alloced1); - sub_81AFC0C(1, alloced2); - sub_81AFC0C(2, alloced3); - sub_81AFC0C(3, alloced4); - sub_81AFC28(gStringVar4, gUnknown_0861CE82); - Free(alloced1); - Free(alloced2); - Free(alloced3); - Free(alloced4); -} - -void sub_81C37D8() -{ - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 2), gStringVar4, 4, 1, 0, 0); -} - -void sub_81C3808() -{ - ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.spatk, 1, 3); - ConvertIntToDecimalStringN(gStringVar2, gUnknown_0203CF1C->summary.spdef, 1, 3); - ConvertIntToDecimalStringN(gStringVar3, gUnknown_0203CF1C->summary.speed, 1, 3); - sub_81AFBF0(); - sub_81AFC0C(0, gStringVar1); - sub_81AFC0C(1, gStringVar2); - sub_81AFC0C(2, gStringVar3); - sub_81AFC28(gStringVar4, gUnknown_0861CE8E); -} - -void sub_81C3890() -{ - sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 3), gStringVar4, 2, 1, 0, 0); -} - -void sub_81C38C0() -{ - struct PokeSummary *sum = &gUnknown_0203CF1C->summary; - u8 r6 = sub_81C2D2C(&gUnknown_0861CCEC, 4); - int offset; - u32 expToNextLevel; - ConvertIntToDecimalStringN(gStringVar1, sum->exp, 1, 7); - offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2; - sub_81C25A4(r6, gStringVar1, offset, 1, 0, 0); - if (sum->level < MAX_MON_LEVEL) - expToNextLevel = gExperienceTables[gBaseStats[sum->species].growthRate][sum->level + 1] - sum->exp; - else - expToNextLevel = 0; - ConvertIntToDecimalStringN(gStringVar1, expToNextLevel, 1, 6); - offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2; - sub_81C25A4(r6, gStringVar1, offset, 17, 0, 0); -} - -void sub_81C3984() -{ - sub_81C3B08(0); - sub_81C3B08(1); - sub_81C3B08(2); - sub_81C3B08(3); - if (gUnknown_0203CF1C->unk40BC == 3) - { - sub_81C3F44(); - if (gUnknown_0203CF1C->unk40C6 == 4) - { - if (gUnknown_0203CF1C->unk40C4 != 0) - sub_81C3E9C(gUnknown_0203CF1C->unk40C4); - } - else - sub_81C3E9C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]); - } -} - -void sub_81C39F0(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - s16 dataa = data[0] - 1; - - switch (dataa) - { - case 0: - sub_81C3B08(0); - break; - case 1: - sub_81C3B08(1); - break; - case 2: - sub_81C3B08(2); - break; - case 3: - sub_81C3B08(3); - break; - case 4: - if (gUnknown_0203CF1C->unk40BC == 3) - sub_81C3F44(); - break; - case 5: - if (gUnknown_0203CF1C->unk40BC == 3) - { - if (gUnknown_0203CF1C->unk40C6 == 4) - data[1] = gUnknown_0203CF1C->unk40C4; - else - data[1] = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; - } - break; - case 6: - if (gUnknown_0203CF1C->unk40BC == 3) - { - if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - sub_81C3E9C(data[1]); - } - break; - case 7: - DestroyTask(taskId); - return; - } - data[0]++; -} - -#ifdef NONMATCHING -void sub_81C3B08(u8 a) -{ - struct UnkSummaryStruct *r10 = gUnknown_0203CF1C; - u8 r8 = sub_81C2D2C(&gUnknown_0861CD14, 0); - u8 sp = sub_81C2D2C(&gUnknown_0861CD14, 1); - u8 r6; - u8 r5; - u8 *text; - int offset; - u16 move; - if (r10->summary.moves[a] != 0) - { - move = r10->summary.moves[a]; - r6 = CalculatePPWithBonus(move, r10->summary.ppBonuses, a); - sub_81C25A4(r8, gMoveNames[move], 0, (a<<4) + 1, 0, 1); - ConvertIntToDecimalStringN(gStringVar1, r10->summary.pp[a], 1, 2); - ConvertIntToDecimalStringN(gStringVar2, r6, 1, 2); - sub_81AFBF0(); - sub_81AFC0C(0, gStringVar1); - sub_81AFC0C(1, gStringVar2); - sub_81AFC28(gStringVar4, gUnknown_0861CE97); - text = gStringVar4; - r5 = GetCurrentPpToMaxPpState(r10->summary.pp[a], r6) + 9; - offset = GetStringRightAlignXOffset(1, text, 0x2C); - } - else - { - sub_81C25A4(r8, gText_OneDash, 0, (a<<4) + 1, 0, 1); - text = gText_TwoDashes; - r5 = 12; - offset = GetStringCenterAlignXOffset(1, text, 0x2C); - } - sub_81C25A4(sp, text, offset, (a<<4), 0, r5); -} -#else -__attribute__((naked)) -void sub_81C3B08(u8 a) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0xC\n\ - lsls r0, 24\n\ - lsrs r7, r0, 24\n\ - ldr r0, =gUnknown_0203CF1C\n\ - ldr r0, [r0]\n\ - mov r10, r0\n\ - ldr r4, =gUnknown_0861CD14\n\ - adds r0, r4, 0\n\ - movs r1, 0\n\ - bl sub_81C2D2C\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r8, r0\n\ - adds r0, r4, 0\n\ - movs r1, 0x1\n\ - bl sub_81C2D2C\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x8]\n\ - lsls r1, r7, 1\n\ - mov r0, r10\n\ - adds r0, 0x84\n\ - adds r0, r1\n\ - ldrh r5, [r0]\n\ - cmp r5, 0\n\ - beq _081C3C00\n\ - mov r0, r10\n\ - adds r0, 0xA4\n\ - ldrb r1, [r0]\n\ - adds r0, r5, 0\n\ - adds r2, r7, 0\n\ - bl CalculatePPWithBonus\n\ - adds r6, r0, 0\n\ - lsls r6, 24\n\ - lsrs r6, 24\n\ - movs r0, 0xD\n\ - adds r1, r5, 0\n\ - muls r1, r0\n\ - ldr r0, =gMoveNames\n\ - adds r1, r0\n\ - lsls r0, r7, 4\n\ - mov r9, r0\n\ - mov r3, r9\n\ - adds r3, 0x1\n\ - lsls r3, 24\n\ - lsrs r3, 24\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0x1\n\ - str r0, [sp, 0x4]\n\ - mov r0, r8\n\ - movs r2, 0\n\ - bl sub_81C25A4\n\ - ldr r0, =gStringVar1\n\ - mov r8, r0\n\ - mov r5, r10\n\ - adds r5, 0x8C\n\ - adds r5, r7\n\ - ldrb r1, [r5]\n\ - movs r2, 0x1\n\ - movs r3, 0x2\n\ - bl ConvertIntToDecimalStringN\n\ - ldr r4, =gStringVar2\n\ - adds r0, r4, 0\n\ - adds r1, r6, 0\n\ - movs r2, 0x1\n\ - movs r3, 0x2\n\ - bl ConvertIntToDecimalStringN\n\ - bl sub_81AFBF0\n\ - movs r0, 0\n\ - mov r1, r8\n\ - bl sub_81AFC0C\n\ - movs r0, 0x1\n\ - adds r1, r4, 0\n\ - bl sub_81AFC0C\n\ - ldr r4, =gStringVar4\n\ - ldr r1, =gUnknown_0861CE97\n\ - adds r0, r4, 0\n\ - bl sub_81AFC28\n\ - adds r7, r4, 0\n\ - ldrb r0, [r5]\n\ - adds r1, r6, 0\n\ - bl GetCurrentPpToMaxPpState\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r5, r0, 0\n\ - adds r5, 0x9\n\ - movs r0, 0x1\n\ - adds r1, r7, 0\n\ - movs r2, 0x2C\n\ - bl GetStringRightAlignXOffset\n\ - mov r4, r9\n\ - b _081C3C26\n\ - .pool\n\ -_081C3C00:\n\ - ldr r1, =gText_OneDash\n\ - lsls r4, r7, 4\n\ - adds r3, r4, 0x1\n\ - lsls r3, 24\n\ - lsrs r3, 24\n\ - str r5, [sp]\n\ - movs r0, 0x1\n\ - str r0, [sp, 0x4]\n\ - mov r0, r8\n\ - movs r2, 0\n\ - bl sub_81C25A4\n\ - ldr r7, =gText_TwoDashes\n\ - movs r5, 0xC\n\ - movs r0, 0x1\n\ - adds r1, r7, 0\n\ - movs r2, 0x2C\n\ - bl GetStringCenterAlignXOffset\n\ -_081C3C26:\n\ - lsls r2, r0, 24\n\ - lsrs r2, 24\n\ - adds r3, r4, 0x1\n\ - lsls r3, 24\n\ - lsrs r3, 24\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - lsls r0, r5, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x4]\n\ - ldr r0, [sp, 0x8]\n\ - adds r1, r7, 0\n\ - bl sub_81C25A4\n\ - add sp, 0xC\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .pool\n\ - .syntax divided\n"); -} -#endif - -void sub_81C3C5C(u16 move) -{ - u8 *text; - if (move != 0) - { - FillWindowPixelRect(14, 0, 0x35, 0, 0x13, 0x20); - if (gBattleMoves[move].power <= 1) - text = gText_ThreeDashes; - else - { - ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].power, 1, 3); - text = gStringVar1; - } - sub_81C25A4(14, text, 0x35, 1, 0, 0); - if (gBattleMoves[move].accuracy == 0) - text = gText_ThreeDashes; - else - { - ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].accuracy, 1, 3); - text = gStringVar1; - } - sub_81C25A4(14, text, 0x35, 17, 0, 0); - } -} - -void sub_81C3D08() -{ - sub_81C3B08(0); - sub_81C3B08(1); - sub_81C3B08(2); - sub_81C3B08(3); - if (gUnknown_0203CF1C->unk40BC == 3) - { - sub_81C3F44(); - sub_81C3E2C(gUnknown_0203CF1C->unk40C6); - } -} - -void sub_81C3D54(u8 taskId) -{ - s16 *data = gTasks[taskId].data; - s16 dataa = data[0] - 1; - - switch (dataa) - { - case 0: - sub_81C3B08(0); - break; - case 1: - sub_81C3B08(1); - break; - case 2: - sub_81C3B08(2); - break; - case 3: - sub_81C3B08(3); - break; - case 4: - if (gUnknown_0203CF1C->unk40BC == 3) - sub_81C3F44(); - break; - case 5: - if (gUnknown_0203CF1C->unk40BC == 3) - { - if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) - sub_81C3E2C(gUnknown_0203CF1C->unk40C6); - } - break; - case 6: - DestroyTask(taskId); - return; - } - data[0]++; -} \ No newline at end of file diff --git a/src/start_menu.c b/src/start_menu.c index 37331a922..be30d0e53 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -207,7 +207,7 @@ static bool32 PrintStartMenuItemsMultistep(s16 *index, u32 n) do { - if (sStartMenuItems[sCurrentStartMenuActions[_index]].func.u8_void == StartMenu_PlayerName) + if (sStartMenuItems[sCurrentStartMenuActions[_index]].func == StartMenu_PlayerName) { } diff --git a/src/tv.c b/src/tv.c index 3c822b394..7f64b46ac 100644 --- a/src/tv.c +++ b/src/tv.c @@ -2353,7 +2353,7 @@ void sub_80EDFB4(TVShow *show) show->secretBaseVisit.move = sTV_SecretBaseVisitMonsTemp[j].move; } -void TV_PutSecretBaseVisitOnTheAir(void) +void sub_80EE104(void) { TVShow *show; -- cgit v1.2.3 From 5b05811dd944e51ce055ad5ddca570808457c7a0 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 14:24:54 +0200 Subject: start link partner controller --- src/battle_controller_link_partner.c | 203 +++++++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) create mode 100644 src/battle_controller_link_partner.c (limited to 'src') diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c new file mode 100644 index 000000000..62361ebef --- /dev/null +++ b/src/battle_controller_link_partner.c @@ -0,0 +1,203 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "battle_ai_script_commands.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u8 gBankInMenu; +extern u16 gUnknown_020243FC; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gPartnerTrainerId; +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_020244B4[]; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern struct UnusedControllerStruct gUnknown_02022D0C; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; + +extern void sub_81358F4(void); +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); + +// this file's functions +void LinkPartnerHandleGetMonData(void); +void LinkPartnerHandleGetRawMonData(void); +void LinkPartnerHandleSetMonData(void); +void LinkPartnerHandleSetRawMonData(void); +void LinkPartnerHandleLoadMonSprite(void); +void LinkPartnerHandleSwitchInAnim(void); +void LinkPartnerHandleReturnMonToBall(void); +void LinkPartnerHandleDrawTrainerPic(void); +void LinkPartnerHandleTrainerSlide(void); +void LinkPartnerHandleTrainerSlideBack(void); +void LinkPartnerHandleFaintAnimation(void); +void LinkPartnerHandlePaletteFade(void); +void LinkPartnerHandleSuccessBallThrowAnim(void); +void LinkPartnerHandleBallThrowAnim(void); +void LinkPartnerHandlePause(void); +void LinkPartnerHandleMoveAnimation(void); +void LinkPartnerHandlePrintString(void); +void LinkPartnerHandlePrintStringPlayerOnly(void); +void LinkPartnerHandleChooseAction(void); +void LinkPartnerHandleUnknownYesNoBox(void); +void LinkPartnerHandleChooseMove(void); +void LinkPartnerHandleChooseItem(void); +void LinkPartnerHandleChoosePokemon(void); +void LinkPartnerHandleCmd23(void); +void LinkPartnerHandleHealthBarUpdate(void); +void LinkPartnerHandleExpUpdate(void); +void LinkPartnerHandleStatusIconUpdate(void); +void LinkPartnerHandleStatusAnimation(void); +void LinkPartnerHandleStatusXor(void); +void LinkPartnerHandleDataTransfer(void); +void LinkPartnerHandleDMA3Transfer(void); +void LinkPartnerHandlePlayBGM(void); +void LinkPartnerHandleCmd32(void); +void LinkPartnerHandleTwoReturnValues(void); +void LinkPartnerHandleChosenMonReturnValue(void); +void LinkPartnerHandleOneReturnValue(void); +void LinkPartnerHandleOneReturnValue_Duplicate(void); +void LinkPartnerHandleCmd37(void); +void LinkPartnerHandleCmd38(void); +void LinkPartnerHandleCmd39(void); +void LinkPartnerHandleCmd40(void); +void LinkPartnerHandleHitAnimation(void); +void LinkPartnerHandleCmd42(void); +void LinkPartnerHandleEffectivenessSound(void); +void LinkPartnerHandlePlayFanfareOrBGM(void); +void LinkPartnerHandleFaintingCry(void); +void LinkPartnerHandleIntroSlide(void); +void LinkPartnerHandleIntroTrainerBallThrow(void); +void LinkPartnerHandleDrawPartyStatusSummary(void); +void LinkPartnerHandleCmd49(void); +void LinkPartnerHandleCmd50(void); +void LinkPartnerHandleSpriteInvisibility(void); +void LinkPartnerHandleBattleAnimation(void); +void LinkPartnerHandleLinkStandbyMsg(void); +void LinkPartnerHandleResetActionMoveSelection(void); +void LinkPartnerHandleCmd55(void); +void nullsub_113(void); + +void LinkPartnerBufferRunCommand(void); +void LinkPartnerBufferExecCompleted(void); + +void (*const gLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + LinkPartnerHandleGetMonData, + LinkPartnerHandleGetRawMonData, + LinkPartnerHandleSetMonData, + LinkPartnerHandleSetRawMonData, + LinkPartnerHandleLoadMonSprite, + LinkPartnerHandleSwitchInAnim, + LinkPartnerHandleReturnMonToBall, + LinkPartnerHandleDrawTrainerPic, + LinkPartnerHandleTrainerSlide, + LinkPartnerHandleTrainerSlideBack, + LinkPartnerHandleFaintAnimation, + LinkPartnerHandlePaletteFade, + LinkPartnerHandleSuccessBallThrowAnim, + LinkPartnerHandleBallThrowAnim, + LinkPartnerHandlePause, + LinkPartnerHandleMoveAnimation, + LinkPartnerHandlePrintString, + LinkPartnerHandlePrintStringPlayerOnly, + LinkPartnerHandleChooseAction, + LinkPartnerHandleUnknownYesNoBox, + LinkPartnerHandleChooseMove, + LinkPartnerHandleChooseItem, + LinkPartnerHandleChoosePokemon, + LinkPartnerHandleCmd23, + LinkPartnerHandleHealthBarUpdate, + LinkPartnerHandleExpUpdate, + LinkPartnerHandleStatusIconUpdate, + LinkPartnerHandleStatusAnimation, + LinkPartnerHandleStatusXor, + LinkPartnerHandleDataTransfer, + LinkPartnerHandleDMA3Transfer, + LinkPartnerHandlePlayBGM, + LinkPartnerHandleCmd32, + LinkPartnerHandleTwoReturnValues, + LinkPartnerHandleChosenMonReturnValue, + LinkPartnerHandleOneReturnValue, + LinkPartnerHandleOneReturnValue_Duplicate, + LinkPartnerHandleCmd37, + LinkPartnerHandleCmd38, + LinkPartnerHandleCmd39, + LinkPartnerHandleCmd40, + LinkPartnerHandleHitAnimation, + LinkPartnerHandleCmd42, + LinkPartnerHandleEffectivenessSound, + LinkPartnerHandlePlayFanfareOrBGM, + LinkPartnerHandleFaintingCry, + LinkPartnerHandleIntroSlide, + LinkPartnerHandleIntroTrainerBallThrow, + LinkPartnerHandleDrawPartyStatusSummary, + LinkPartnerHandleCmd49, + LinkPartnerHandleCmd50, + LinkPartnerHandleSpriteInvisibility, + LinkPartnerHandleBattleAnimation, + LinkPartnerHandleLinkStandbyMsg, + LinkPartnerHandleResetActionMoveSelection, + LinkPartnerHandleCmd55, + nullsub_113 +}; + +void nullsub_112(void) +{ +} + +void SetBankFuncToLinkPartnerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; +} + +void LinkPartnerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gLinkPartnerBufferCommands)) + gLinkPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + LinkPartnerBufferExecCompleted(); + } +} -- cgit v1.2.3 From 356eb34e3213c95a7ce072bdfc860601dbf464fe Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 14:40:22 +0200 Subject: undo revert --- src/decoration.c | 2781 +++++++++++++++++++++++++++++ src/decoration_inventory.c | 189 ++ src/international_string_util.c | 8 +- src/pokemon_summary_screen.c | 3679 +++++++++++++++++++++++++++++++++++++++ src/start_menu.c | 2 +- src/tv.c | 2 +- 6 files changed, 6655 insertions(+), 6 deletions(-) create mode 100644 src/decoration.c create mode 100644 src/decoration_inventory.c create mode 100755 src/pokemon_summary_screen.c (limited to 'src') diff --git a/src/decoration.c b/src/decoration.c new file mode 100644 index 000000000..0179d36a1 --- /dev/null +++ b/src/decoration.c @@ -0,0 +1,2781 @@ + +// Includes +#include "global.h" +#include "decompress.h" +#include "malloc.h" +#include "string_util.h" +#include "international_string_util.h" +#include "script.h" +#include "task.h" +#include "main.h" +#include "palette.h" +#include "songs.h" +#include "overworld.h" +#include "fieldmap.h" +#include "metatile_behavior.h" +#include "field_weather.h" +#include "field_player_avatar.h" +#include "field_camera.h" +#include "field_screen.h" +#include "field_map_obj.h" +#include "list_menu.h" +#include "menu_helpers.h" +#include "new_menu_helpers.h" +#include "menu_indicators.h" +#include "sound.h" +#include "event_scripts.h" +#include "event_data.h" +#include "region_map.h" +#include "player_pc.h" +#include "strings.h" +#include "tv.h" +#include "secret_base.h" +#include "tilesets.h" +#include "item_icon.h" +#include "trader.h" +#include "map_object_constants.h" +#include "decoration_inventory.h" +#include "decoration.h" +#include "graphics.h" + +// Static type declarations + +#define OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG 0xbe5 +#define OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG 0x008 + +struct DecorPCBuffer { + struct ListMenuItem items[41]; + u8 names[41][24]; + u8 unk_520; + u8 unk_521; + u8 unk_522; +}; + +struct PlaceDecorationGraphicsDataBuffer { + /*0x000; 0x0203a190*/ const struct Decoration *decoration; + /*0x004; 0x0203a194*/ u16 tiles[0x40]; + /*0x084; 0x0203a214*/ u8 image[0x800]; + /*0x884; 0x0203aa14*/ u16 palette[16]; +}; + +struct DecorRearrangementDataBuffer { + u8 idx; + u8 width; + u8 height; + u16 flagId; +}; + +// Static RAM declarations + +EWRAM_DATA u8 *gCurDecorInventoryItems = NULL; +EWRAM_DATA u8 sSecretBasePCMenuCursorPos = 0; +EWRAM_DATA u8 sCurDecorCatCount = 0; +EWRAM_DATA u8 sSecretBaseItemsIndicesBuffer[16] = {}; +EWRAM_DATA u8 sPlayerRoomItemsIndicesBuffer[12] = {}; +EWRAM_DATA u16 sSecretBasePCSelectDecorLineNo = 0; +EWRAM_DATA u16 sSecretBasePCSelectDecorPageNo = 0; +EWRAM_DATA u8 gCurDecorationIndex = 0; +EWRAM_DATA u8 sCurDecorationCategory = DECORCAT_DESK; +EWRAM_DATA u32 filler_0203a174[2] = {}; +EWRAM_DATA struct DecorPCPointers gUnknown_0203A17C = {}; +EWRAM_DATA u8 sDecorMenuWindowIndices[4] = {}; +EWRAM_DATA struct DecorPCBuffer *sDecorPCBuffer = NULL; +EWRAM_DATA struct PlaceDecorationGraphicsDataBuffer sPlaceDecorationGraphicsDataBuffer = {}; +EWRAM_DATA u16 sCurDecorMapX = 0; +EWRAM_DATA u16 sCurDecorMapY = 0; +EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx1 = 0; +EWRAM_DATA u8 sDecor_CameraSpriteObjectIdx2 = 0; +EWRAM_DATA u8 sDecorationLastDirectionMoved = 0; +EWRAM_DATA struct OamData sDecorSelectorOam = {}; +EWRAM_DATA struct DecorRearrangementDataBuffer sDecorRearrangementDataBuffer[16] = {}; +EWRAM_DATA u8 sCurDecorSelectedInRearrangement = 0; + +// Static ROM declarations + +void sub_8126B80(u8 taskId); +void sub_8126C08(void); +void SecretBasePC_Decorate(u8 taskId); +void SecretBasePC_PutAway(u8 taskId); +void SecretBasePC_Toss(u8 taskId); +void sub_8126DA4(u8 taskId); +void SecretBasePC_Cancel(u8 taskId); +void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId); +void sub_8126DFC(u8 taskId); +void sub_8126E8C(u8 taskId); +void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed); +void sub_8127058(u8 *str, bool8 flag); +void sub_8127088(u8 taskId); +void sub_81270E8(u8 taskId); +void sub_8127180(u8 taskId); +void sub_812719C(u8 taskId); +void sub_81271CC(u8 taskId); +void sub_8127268(u8 taskId); +void sub_8127454(u8 *dest, u16 decorId); +void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu); +void sub_81274A0(u8 a0, s32 a1, u8 a2); +void sub_8127620(u8 taskId); +void sub_812764C(u8 taskId); +void sub_8127744(u32 a0); +void sub_81277A8(void); +bool8 sub_81277BC(u8 idx); +bool8 sub_81277E8(u8 idx); +void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId); +void sub_812759C(u8 taskId); +void sub_8127718(u8 decorCat); +void sub_8127A30(u8 taskId); +void sub_8127A8C(u8 taskId); +void sub_8127F68(u8 taskId); +void sub_8128060(u8 taskId); +void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor); +void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data); +void sub_812826C(u8 taskId); +void sub_81283BC(u8 taskId); +void sub_8128414(u8 taskId); +void sub_8128950(u8 taskId); +void sub_81289D0(u8 taskId); +void sub_81289F0(u8 taskId); +void sub_8128AAC(u8 taskId); +void sub_8128B80(u8 taskId); +void sub_8128BA0(u8 taskId); +void sub_8128BBC(u8 taskId); +void c1_overworld_prev_quest(u8 taskId); +void sub_8128CD4(void); +void sub_8128DE0(void); +void sub_8128FD8(u8 taskId); +void sub_8129020(u8 taskId); +void sub_81292D0(struct Sprite *sprite); +void sub_81292E8(struct Sprite *sprite); +u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor); +const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode); +bool8 sub_81299AC(u8 taskId); +void sub_8129ABC(u8 taskId); +void sub_8129B34(u8 taskId); +void sub_8129BCC(u8 taskId); +void sub_8129BF8(u8 taskId); +void sub_8129C74(u8 taskId); +void sub_8129D64(u8 taskId); +void sub_812A0E8(u8 taskId); +void sub_812A1A0(u8 taskId); +void sub_812A1C0(u8 taskId); +void sub_812A1F0(u8 taskId); +void sub_812A210(u8 taskId); +void sub_812A22C(u8 taskId); +void sub_812A25C(u8 taskId); +void sub_812A334(void); +void sub_812A36C(struct Sprite *sprite); +void sub_812A39C(void); +void sub_812A3C8(void); +void sub_812A3D4(u8 taskId); +void sub_812A458(u8 taskId); +void sub_812A478(u8 taskId); + +// .rodata + +#include "data/decoration/tiles.h" +#include "data/decoration/description.h" +#include "data/decoration/header.h" + +const u8 *const sDecorCatNames[] = { + gText_Desk, + gText_Chair, + gText_Plant, + gText_Ornament, + gText_Mat, + gText_Poster, + gText_Doll, + gText_Cushion +}; + +const struct MenuAction sSecretBasePCMenuActions[] = { + { + gText_Decorate, {.void_u8=SecretBasePC_Decorate} + }, { + gText_PutAway, {.void_u8=SecretBasePC_PutAway} + }, { + gText_Toss2, {.void_u8=SecretBasePC_Toss} + }, { + gText_Cancel, {.void_u8=SecretBasePC_Cancel} + } +}; + +const u8 *const sSecretBasePCMenuItemDescriptions[] = { + gText_PutOutSelectedDecorItem, + gText_StoreChosenDecorInPC, + gText_ThrowAwayUnwantedDecors, + gText_GoBackPrevMenu +}; + +void (*const SecretBasePC_SelectedDecorActions[][2])(u8 taskId) = { + { + sub_8127F68, sub_8127A8C + }, { + sub_812A3D4, sub_8127A8C + }, { + sub_8133DA0, sub_8127A8C + } +}; + +const struct WindowTemplate gUnknown_085A6B90[4] = { + { 0, 1, 1, 18, 8, 15, 0x0001 }, + { 0, 1, 1, 13, 18, 13, 0x0091 }, + { 0, 17, 1, 12, 2, 15, 0x017b }, + { 0, 16, 13, 13, 6, 15, 0x0193 } +}; + +const u16 gUnknown_085A6BB0[] = INCBIN_U16("graphics/decorations/unk_85a6bb0.gbapal"); + +const struct ListMenuTemplate gUnknown_085A6BD0 = { + NULL, + sub_8127480, + sub_81274A0, + 0, 0, + 0, 0, 8, 0, + 9, 2, 1, 3, FALSE, 0, FALSE, 7 +}; + +#include "data/decoration/icon.h" +#include "data/decoration/tilemaps.h" + +const struct { + u8 shape; + u8 size; + u8 x; + u8 y; +} gUnknown_085A7250[] = { + {0, 1, 0x78, 0x4e}, + {1, 2, 0x80, 0x4e}, + {1, 3, 0x90, 0x56}, + {1, 3, 0x90, 0x46}, + {0, 2, 0x80, 0x46}, + {2, 2, 0x78, 0x46}, + {2, 3, 0x80, 0x56}, + {2, 3, 0x80, 0x36}, + {0, 3, 0x90, 0x46}, + {1, 3, 0x90, 0x46} +}; + +const union AnimCmd gUnknown_085A7278[] = { + ANIMCMD_FRAME(0, 0, FALSE, FALSE), + ANIMCMD_END +}; + +const union AnimCmd *const sDecorSelectorAnims[] = { + gUnknown_085A7278 +}; + +const struct SpriteFrameImage sDecorSelectorSpriteFrameImages = { + (const u8 *)&sPlaceDecorationGraphicsDataBuffer.image, 0x800 +}; + +const struct SpriteTemplate sDecorSelectorSpriteTemplate = { + 0xffff, + OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG, + &sDecorSelectorOam, + sDecorSelectorAnims, + &sDecorSelectorSpriteFrameImages, + gDummySpriteAffineAnimTable, + SpriteCallbackDummy +}; + +const struct SpriteTemplate sDecorWhilePlacingSpriteTemplate = { + 0x0000, + 0x0000, + &sDecorSelectorOam, + sDecorSelectorAnims, + NULL, + gDummySpriteAffineAnimTable, + SpriteCallbackDummy +}; + +const struct SpritePalette gUnknown_085A72BC = { + (const u16 *)&sPlaceDecorationGraphicsDataBuffer.palette, OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG +}; + +const struct YesNoFuncTable gUnknown_085A72C4 = { + sub_81289F0, + sub_8128FD8 +}; + +const struct YesNoFuncTable gUnknown_085A72CC = { + sub_8128BA0, + sub_8128FD8 +}; + +const struct YesNoFuncTable gUnknown_085A72D4[] = { + { + sub_81283BC, + sub_8128414 + }, { + sub_8129BCC, + sub_8129BF8 + } +}; + +const u8 gUnknown_085A72E4[] = { + 0x04, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x00 +}; + +const u8 gUnknown_085A72EC[] = { + 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x03, 0x00 +}; + +const u16 gUnknown_085A72F4[] = { + 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x20 +}; + +const u16 Unknown_085A7308[] = INCBIN_U16("graphics/decorations/unk_85a7308.gbapal"); + +const u16 Unknown_085A7328[] = INCBIN_U16("graphics/decorations/unk_85a7328.gbapal"); + +const struct YesNoFuncTable gUnknown_085A7348 = { + sub_812A1C0, + sub_8129B34 +}; + +const struct YesNoFuncTable gUnknown_085A7350 = { + sub_812A210, + sub_8129B34 +}; + +const u8 Unknown_085A7358[] = INCBIN_U8("graphics/misc/decoration_unk_85a7358.4bpp"); + +const struct SpritePalette gUnknown_085A73D8 = { + Unknown_085A7308, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG +}; + +const struct SpritePalette gUnknown_085A73E0 = { + Unknown_085A7328, OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG +}; + +const struct OamData Unknown_085A73E8 = { + .size = 1, .priority = 1 +}; + +const union AnimCmd Unknown_085A73F0[] = { + ANIMCMD_FRAME(0, 0, 0), + ANIMCMD_END +}; + +const union AnimCmd *const Unknown_085A73F8[] = { + Unknown_085A73F0 +}; + +const struct SpriteFrameImage Unknown_085A73FC = { + Unknown_085A7358, 0x80 +}; + +const struct SpriteTemplate gUnknown_085A7404 = { + 0xFFFF, + OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG, + &Unknown_085A73E8, + Unknown_085A73F8, + &Unknown_085A73FC, + gDummySpriteAffineAnimTable, + sub_812A36C +}; + +const struct YesNoFuncTable gUnknown_085A741C = { + sub_812A478, + sub_8127A30 +}; + +// .text + +void sub_8126968(void) +{ + if (sCurDecorationCategory < 8) + { + gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items; + } + if (gUnknown_0203A17C.isPlayerRoom == FALSE) + { + gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations; + gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos; + } + if (gUnknown_0203A17C.isPlayerRoom == TRUE) + { + gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor; + gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos; + } +} + +u8 sub_81269D4(u8 idx) +{ + u8 *winidx; + struct WindowTemplate template; + + winidx = &sDecorMenuWindowIndices[idx]; + if (idx == 0) + { + template = gUnknown_085A6B90[0]; + template.width = GetMaxWidthInMenuTable(sSecretBasePCMenuActions, 4); + if (template.width > 18) + { + template.width = 18; + } + *winidx = AddWindow(&template); + } + else + { + *winidx = AddWindow(&gUnknown_085A6B90[idx]); + } + SetWindowBorderStyle(*winidx, 0, 0x214, 0xe); + schedule_bg_copy_tilemap_to_vram(0); + return *winidx; +} + +void sub_8126A58(u8 idx) +{ + sub_8198070(sDecorMenuWindowIndices[idx], FALSE); + ClearWindowTilemap(sDecorMenuWindowIndices[idx]); + RemoveWindow(sDecorMenuWindowIndices[idx]); + schedule_bg_copy_tilemap_to_vram(0); +} + +void sub_8126A88(void) +{ + u8 idx; + + idx = sub_81269D4(0); + PrintMenuTable(idx, 4, sSecretBasePCMenuActions); + InitMenuInUpperLeftCornerPlaySoundWhenAPressed(idx, 4, sSecretBasePCMenuCursorPos); +} + +void sub_8126ABC(void) +{ + sSecretBasePCMenuCursorPos = 0; + ScriptContext2_Enable(); + sub_8126A88(); + sub_8126C08(); +} + +void sub_8126AD8(u8 taskId) +{ + sub_8126ABC(); + gUnknown_0203A17C.items = gSaveBlock1Ptr->secretBases[0].decorations; + gUnknown_0203A17C.pos = gSaveBlock1Ptr->secretBases[0].decorationPos; + gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->secretBases[0].decorations); + gUnknown_0203A17C.isPlayerRoom = FALSE; + gTasks[taskId].func = sub_8126B80; +} + +void sub_8126B2C(u8 taskId) +{ + sub_8126ABC(); + gUnknown_0203A17C.items = gSaveBlock1Ptr->playerRoomDecor; + gUnknown_0203A17C.pos = gSaveBlock1Ptr->playerRoomDecorPos; + gUnknown_0203A17C.size = sizeof(gSaveBlock1Ptr->playerRoomDecor); + gUnknown_0203A17C.isPlayerRoom = TRUE; + gTasks[taskId].func = sub_8126B80; +} + +void sub_8126B80(u8 taskId) +{ + u8 menuPos; + + if (!gPaletteFade.active) + { + menuPos = GetMenuCursorPos(); + switch (ProcessMenuInput()) + { + default: + PlaySE(SE_SELECT); + sSecretBasePCMenuActions[sSecretBasePCMenuCursorPos].func.void_u8(taskId); + break; + case -2: + sSecretBasePCMenuCursorPos = GetMenuCursorPos(); + if ((s8)menuPos != sSecretBasePCMenuCursorPos) + { + sub_8126C08(); + } + break; + case -1: + PlaySE(SE_SELECT); + SecretBasePC_Cancel(taskId); + break; + } + } +} + +void sub_8126C08(void) +{ + FillWindowPixelBuffer(0, 0x11); + AddTextPrinterParametrized(0, 1, sSecretBasePCMenuItemDescriptions[sSecretBasePCMenuCursorPos], 0, 0, 2, 1, 3); +} + +void SecretBasePC_Decorate(u8 taskId) +{ + if (CountDecorations() == 0) + { + StringExpandPlaceholders(gStringVar4, gText_NoDecorations); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); + } + else + { + gTasks[taskId].data[11] = 0; + sCurDecorationCategory = DECORCAT_DESK; + SecretBasePC_PrepMenuForSelectingStoredDecors(taskId); + } +} + +void SecretBasePC_PutAway(u8 taskId) +{ + if (!sub_81299AC(taskId)) + { + StringExpandPlaceholders(gStringVar4, gText_NoDecorationsInUse); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); + } + else + { + sub_8126A58(0); + sub_8197434(0, 0); + fade_screen(1, 0); + gTasks[taskId].data[2] = 0; + gTasks[taskId].func = sub_8129ABC; + } +} + +void SecretBasePC_Toss(u8 taskId) +{ + if (CountDecorations() == 0) + { + StringExpandPlaceholders(gStringVar4, gText_NoDecorations); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8126DA4); + } + else + { + gTasks[taskId].data[11] = 1; + sCurDecorationCategory = DECORCAT_DESK; + SecretBasePC_PrepMenuForSelectingStoredDecors(taskId); + } +} + +void SecretBasePC_Cancel(u8 taskId) +{ + sub_8126A58(0); + if (!gUnknown_0203A17C.isPlayerRoom) + { + ScriptContext1_SetupScript(gUnknown_0823B4E8); + DestroyTask(taskId); + } + else + { + sub_816B060(taskId); + } +} + +void sub_8126DA4(u8 taskId) +{ + sub_8126C08(); + gTasks[taskId].func = sub_8126B80; +} + +void SecretBasePC_PrepMenuForSelectingStoredDecors(u8 taskId) +{ + LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20); + sub_8197434(0, 0); + sub_8126A58(0); + sub_8126DFC(taskId); +} + +void sub_8126DFC(u8 taskId) +{ + u8 winIdx; + + winIdx = sub_81269D4(1); + sub_8126E8C(taskId); + InitMenuInUpperLeftCornerPlaySoundWhenAPressed(winIdx, 9, sCurDecorationCategory); + gTasks[taskId].func = sub_8127088; +} + +void sub_8126E44(u8 taskId) +{ + FillWindowPixelBuffer(sDecorMenuWindowIndices[1], 0x11); + sub_8126E8C(taskId); + InitMenuInUpperLeftCornerPlaySoundWhenAPressed(sDecorMenuWindowIndices[1], 9, sCurDecorationCategory); + gTasks[taskId].func = sub_8127088; +} + +void sub_8126E8C(u8 taskId) +{ + s16 *data; + u8 r5; + bool8 r8; + u8 i; + bool8 fl; + + data = gTasks[taskId].data; + r5 = sDecorMenuWindowIndices[1]; + fl = gUnknown_0203A17C.isPlayerRoom; + r8 = FALSE; + if (fl == TRUE && data[11] == 0) + { + r8 = TRUE; + } + for (i = 0; i < 8; i ++) + { + if (r8 == TRUE && i != DECORCAT_DOLL && i != DECORCAT_CUSHION) + { + sub_8126F68(r5, i, 8, i << 4, TRUE, 0xFF); + } + else + { + sub_8126F68(r5, i, 8, i << 4, FALSE, 0xFF); + } + } + PrintTextOnWindow(r5, 1, gTasks[taskId].data[11] == 2 ? gText_Exit : gText_Cancel, 8, (i << 4) + 1, 0, 0); + schedule_bg_copy_tilemap_to_vram(0); +} + +void sub_8126F68(u8 winid, u8 decorCat, u8 x, u8 y, bool8 flag, u8 speed) +{ + u8 width; + u8 *strbuf; + + width = x == 8 ? 0x68 : 0x60; + y ++; + sub_8127058(gStringVar4, flag); + strbuf = StringLength(gStringVar4) + gStringVar4; + StringCopy(strbuf, sDecorCatNames[decorCat]); + PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL); + strbuf = ConvertIntToDecimalStringN(strbuf, CountDecorationCategoryN(decorCat), STR_CONV_MODE_RIGHT_ALIGN, 2); + *strbuf++ = CHAR_SLASH; + ConvertIntToDecimalStringN(strbuf, gDecorationInventories[decorCat].size, STR_CONV_MODE_RIGHT_ALIGN, 2); + x = GetStringRightAlignXOffset(1, gStringVar4, width); + PrintTextOnWindow(winid, 1, gStringVar4, x, y, speed, NULL); +} + +void sub_8127058(u8 *str, bool8 flag) +{ + StringCopy(str, gText_Color161Shadow161); + if (flag == TRUE) + { + str[2] = 0x04; // RED + str[5] = 0x05; // LIGHT_RED + } + else + { + str[2] = 0x02; // DARK_GREY + str[5] = 0x03; // LIGHT_GREY + } +} + +void sub_8127088(u8 taskId) +{ + s8 input; + + if (!gPaletteFade.active) + { + input = ProcessMenuInput(); + switch (input) + { + case -1: + case 8: + PlaySE(SE_SELECT); + sub_812719C(taskId); + break; + case -2: + break; + default: + PlaySE(SE_SELECT); + sCurDecorationCategory = input; + sub_81270E8(taskId); + break; + } + } +} + +void sub_81270E8(u8 taskId) +{ + sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory); + if (sCurDecorCatCount != 0) + { + CondenseDecorationCategoryN(sCurDecorationCategory); + gCurDecorInventoryItems = gDecorationInventories[sCurDecorationCategory].items; + IdentifyOwnedDecorationsCurrentlyInUse(taskId); + sSecretBasePCSelectDecorPageNo = 0; + sSecretBasePCSelectDecorLineNo = 0; + gTasks[taskId].func = sub_8127620; + } + else + { + sub_8126A58(1); + StringExpandPlaceholders(gStringVar4, gText_NoDecorations); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127180); + } +} + +void sub_8127180(u8 taskId) +{ + sub_8197434(0, 0); + sub_8126DFC(taskId); +} + +void sub_812719C(u8 taskId) +{ + if (gTasks[taskId].data[11] != 2) + { + sub_81271CC(taskId); + } + else + { + sub_8127268(taskId); + } +} + +void sub_81271CC(u8 taskId) +{ + sub_8126A58(1); + sub_8126A88(); + sub_81973C4(0, 0); + sub_8126C08(); + gTasks[taskId].func = sub_8126B80; +} + +void sub_8127208(u8 taskId) +{ + LoadPalette(gUnknown_085A6BB0, 0xd0, 0x20); + sub_8197434(0, 0); + gTasks[taskId].data[11] = 2; + sCurDecorationCategory = DECORCAT_DESK; + sub_8126DFC(taskId); +} + +void sub_8127250(u8 *dest, u8 decorCat) +{ + StringCopy(dest, sDecorCatNames[decorCat]); +} + +void sub_8127268(u8 taskId) +{ + sub_8126A58(1); + sub_8133E1C(taskId); +} + +void sub_8127284(void) +{ + sDecorPCBuffer->unk_520 = sCurDecorCatCount + 1; + if (sDecorPCBuffer->unk_520 > 8) + { + sDecorPCBuffer->unk_521 = 8; + } + else + { + sDecorPCBuffer->unk_521 = sDecorPCBuffer->unk_520; + } +} + +void sub_81272C8(void) +{ + sub_812225C(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520); +} + +void sub_81272F8(void) +{ + sub_8122298(&sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo, sDecorPCBuffer->unk_521, sDecorPCBuffer->unk_520, 8); +} + +void sub_8127330(u8 taskId) +{ + s16 *data; + u16 i; + + data = gTasks[taskId].data; + if ((sCurDecorationCategory < DECORCAT_DOLL || sCurDecorationCategory > DECORCAT_CUSHION) && gUnknown_0203A17C.isPlayerRoom == TRUE && data[11] == 0) + { + sub_8127058(gStringVar1, TRUE); + } + else + { + sub_8127058(gStringVar1, FALSE); + } + for (i = 0; i < sDecorPCBuffer->unk_520 - 1; i ++) + { + sub_8127454(sDecorPCBuffer->names[i], gCurDecorInventoryItems[i]); + sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i]; + sDecorPCBuffer->items[i].unk_04 = i; + } + StringCopy(sDecorPCBuffer->names[i], gText_Cancel); + sDecorPCBuffer->items[i].unk_00 = sDecorPCBuffer->names[i]; + sDecorPCBuffer->items[i].unk_04 = -2; + gUnknown_03006310 = gUnknown_085A6BD0; + gUnknown_03006310.unk_10 = sDecorMenuWindowIndices[1]; + gUnknown_03006310.unk_0c = sDecorPCBuffer->unk_520; + gUnknown_03006310.unk_00 = sDecorPCBuffer->items; + gUnknown_03006310.unk_0e = sDecorPCBuffer->unk_521; +} + +void sub_8127454(u8 *dest, u16 decorId) +{ + StringCopy(dest, gStringVar1); + StringAppend(dest, gDecorations[decorId].name); +} + +void sub_8127480(u32 a0, bool8 flag, struct ListMenu *menu) +{ + if (flag != TRUE) + { + PlaySE(SE_SELECT); + } + sub_8127744(a0); +} + +void sub_81274A0(u8 a0, s32 a1, u8 a2) +{ + if (a1 != -2) + { + if (sub_81277BC(a1 + 1) == TRUE) + { + blit_move_info_icon(a0, 0x18, 0x5c, a2 + 2); + } + else if (sub_81277E8(a1 + 1) == TRUE) + { + blit_move_info_icon(a0, 0x19, 0x5c, a2 + 2); + } + } +} + +void sub_8127500(void) +{ + if (sDecorPCBuffer->unk_522 == 0xFF) + { + sDecorPCBuffer->unk_522 = AddScrollIndicatorArrowPairParametrized(0x02, 0x3c, 0x0c, 0x94, sDecorPCBuffer->unk_520 - sDecorPCBuffer->unk_521, 0x6e, 0x6e, &sSecretBasePCSelectDecorPageNo); + } +} + +void sub_8127554(void) +{ + if (sDecorPCBuffer->unk_522 != 0xFF) + { + RemoveScrollIndicatorArrowPair(sDecorPCBuffer->unk_522); + sDecorPCBuffer->unk_522 = 0xFF; + } +} + +void sub_8127580(u8 taskId) +{ + sub_81269D4(1); + sub_812759C(taskId); +} + +void sub_812759C(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + sub_81269D4(3); + sub_8127718(sCurDecorationCategory); + sDecorPCBuffer = calloc(1, sizeof(struct DecorPCBuffer)); + sDecorPCBuffer->unk_522 = 0xFF; + sub_8127284(); + sub_81272C8(); + sub_81272F8(); + sub_8127330(taskId); + data[13] = ListMenuInit(&gUnknown_03006310, sSecretBasePCSelectDecorPageNo, sSecretBasePCSelectDecorLineNo); + sub_8127500(); +} + +void sub_8127620(u8 taskId) +{ + sub_812759C(taskId); + gTasks[taskId].func = sub_812764C; +} + +void sub_812764C(u8 taskId) +{ + s16 *data; + s32 input; + + data = gTasks[taskId].data; + if (!gPaletteFade.active) + { + input = ListMenuHandleInput(data[13]); + get_coro_args_x18_x1A(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo); + switch (input) + { + case -1: + break; + case -2: + PlaySE(SE_SELECT); + SecretBasePC_SelectedDecorActions[data[11]][1](taskId); + break; + default: + PlaySE(SE_SELECT); + gCurDecorationIndex = input; + sub_8127554(); + sub_81AE6C8(data[13], &sSecretBasePCSelectDecorPageNo, &sSecretBasePCSelectDecorLineNo); + sub_8126A58(1); + sub_81277A8(); + free(sDecorPCBuffer); + SecretBasePC_SelectedDecorActions[data[11]][0](taskId); + break; + } + } +} + +void sub_8127718(u8 decorCat) +{ + sub_8126F68(sub_81269D4(2), decorCat, 0, 0, 0, 0); +} + +void sub_8127744(u32 a0) +{ + u8 winidx; + const u8 *txt; + + winidx = sDecorMenuWindowIndices[3]; + FillWindowPixelBuffer(winidx, 0x11); + if (a0 >= sCurDecorCatCount) + { + txt = gText_GoBackPrevMenu; + } + else + { + txt = gDecorations[gCurDecorInventoryItems[a0]].description; + } + PrintTextOnWindow(winidx, 1, txt, 0, 1, 0, 0); +} + +void sub_81277A8(void) +{ + sub_8126A58(3); + sub_8126A58(2); +} + +bool8 sub_81277BC(u8 idx) +{ + u8 i; + + for (i = 0; i < 16; i ++) + { + if (sSecretBaseItemsIndicesBuffer[i] == idx) + { + return TRUE; + } + } + return FALSE; +} + +bool8 sub_81277E8(u8 idx) +{ + u8 i; + + for (i = 0; i < 12; i ++) + { + if (sPlayerRoomItemsIndicesBuffer[i] == idx) + { + return TRUE; + } + } + return FALSE; +} + +void IdentifyOwnedDecorationsCurrentlyInUseInternal(u8 taskId) +{ + u16 i; + u16 j; + u16 k; + u16 cnt; + + cnt = 0; + memset(sSecretBaseItemsIndicesBuffer, 0, 16); + memset(sPlayerRoomItemsIndicesBuffer, 0, 12); + for (i = 0; i < 16; i ++) + { + if (gSaveBlock1Ptr->secretBases[0].decorations[i] != DECOR_NONE) + { + for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++) + { + if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->secretBases[0].decorations[i]) + { + for (k = 0; k < cnt && sSecretBaseItemsIndicesBuffer[k] != j + 1; k ++); + if (k == cnt) + { + sSecretBaseItemsIndicesBuffer[cnt] = j + 1; + cnt ++; + break; + } + } + } + } + } + cnt = 0; + for (i = 0; i < 12; i ++) + { + if (gSaveBlock1Ptr->playerRoomDecor[i] != DECOR_NONE) + { + for (j = 0; j < gDecorationInventories[sCurDecorationCategory].size; j ++) + { + if (gCurDecorInventoryItems[j] == gSaveBlock1Ptr->playerRoomDecor[i] && sub_81277BC(j + 1) != TRUE) + { + for (k = 0; k < cnt && sPlayerRoomItemsIndicesBuffer[k] != j + 1; k ++); + if (k == cnt) + { + sPlayerRoomItemsIndicesBuffer[cnt] = j + 1; + cnt ++; + break; + } + } + } + } + } +} + +void IdentifyOwnedDecorationsCurrentlyInUse(u8 taskId) +{ + IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); +} + +bool8 IsSelectedDecorInThePC(void) +{ + u16 i; + for (i = 0; i < 16; i ++) + { + if (sSecretBaseItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1) + { + return FALSE; + } + if (i < 12 && sPlayerRoomItemsIndicesBuffer[i] == sSecretBasePCSelectDecorPageNo + sSecretBasePCSelectDecorLineNo + 1) + { + return FALSE; + } + } + return TRUE; +} + +void sub_8127A14(u8 taskId) +{ + sub_81269D4(1); + sub_8127620(taskId); +} + +void sub_8127A30(u8 taskId) +{ + sub_8197434(0, 0); + gTasks[taskId].func = sub_8127A14; +} + +void sub_8127A5C(u8 taskId) +{ + if (gMain.newKeys & (A_BUTTON | B_BUTTON)) + { + sub_8197434(0, 0); + sub_81269D4(1); + sub_8127620(taskId); + } +} + +void sub_8127A8C(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + sub_8127554(); + sub_81277A8(); + sub_81AE6C8(data[13], NULL, NULL); + free(sDecorPCBuffer); + sub_8126E44(taskId); +} + +void sub_8127ACC(u8 taskId) +{ + gTasks[taskId].data[3] = gSaveBlock1Ptr->pos.x; + gTasks[taskId].data[4] = gSaveBlock1Ptr->pos.y; + PlayerGetDestCoords(&gTasks[taskId].data[0], &gTasks[taskId].data[1]); +} + +void sub_8127B04(u8 taskId) +{ + DrawWholeMapView(); + Overworld_SetWarpDestination(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, gTasks[taskId].data[3], gTasks[taskId].data[4]); + warp_in(); +} + +u16 sub_8127B54(u8 decor, u8 a1) +{ + u16 resp; + + resp = -1; + switch (decor) + { + case DECOR_STAND: + resp = gUnknown_085A72E4[a1] << 12; + return resp; + case DECOR_SLIDE: + resp = gUnknown_085A72EC[a1] << 12; + return resp; + default: + return resp; + } +} + +void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor) +{ + u16 i; + u16 j; + u16 behavior; + u16 flags; + u16 v0; + u16 v1; + s16 decLeft; + s16 decBottom; + + for (i = 0; i < decHeight; i ++) + { + decBottom = mapY - decHeight + 1 + i; + for (j = 0; j < decWidth; j ++) + { + decLeft = mapX + j; + behavior = GetBehaviorByMetatileId(0x200 + gDecorations[decor].tiles[i * decWidth + j]); + if (MetatileBehavior_IsMB_B9(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12))) + { + flags = 0xc00; + } + else + { + flags = 0x000; + } + if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE) + { + v0 = 1; + } + else + { + v0 = 0; + } + v1 = sub_8127B54(gDecorations[decor].id, i * decWidth + j); + if (v1 != 0xFFFF) + { + MapGridSetMetatileEntryAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags | v1); + } + else + { + MapGridSetMetatileIdAt(decLeft, decBottom, (gDecorations[decor].tiles[i * decWidth + j] + (0x200 | v0)) | flags); + } + } + } +} + +void sub_8127D38(u16 mapX, u16 mapY, u16 decor) +{ + switch (gDecorations[decor].shape) + { + case DECORSHAPE_1x1: + sub_8127B90(mapX, mapY, 1, 1, decor); + break; + case DECORSHAPE_2x1: + sub_8127B90(mapX, mapY, 2, 1, decor); + break; + case DECORSHAPE_3x1: // unused + sub_8127B90(mapX, mapY, 3, 1, decor); + break; + case DECORSHAPE_4x2: + sub_8127B90(mapX, mapY, 4, 2, decor); + break; + case DECORSHAPE_2x2: + sub_8127B90(mapX, mapY, 2, 2, decor); + break; + case DECORSHAPE_1x2: + sub_8127B90(mapX, mapY, 1, 2, decor); + break; + case DECORSHAPE_1x3: // unused + sub_8127B90(mapX, mapY, 1, 3, decor); + break; + case DECORSHAPE_2x4: + sub_8127B90(mapX, mapY, 2, 4, decor); + break; + case DECORSHAPE_3x3: + sub_8127B90(mapX, mapY, 3, 3, decor); + break; + case DECORSHAPE_3x2: + sub_8127B90(mapX, mapY, 3, 2, decor); + break; + } +} + +void sub_8127E18(void) +{ + u8 i; + u8 j; + + for (i = 0; i < 14; i ++) + { + if (FlagGet(0xAE + i) == TRUE) + { + FlagClear(0xAE + i); + for (j = 0; j < gMapHeader.events->mapObjectCount; j ++) + { + if (gMapHeader.events->mapObjects[j].flagId == 0xAE + i) + { + break; + } + } + VarSet(0x3F20 + gMapHeader.events->mapObjects[j].graphicsId, sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0]); + gSpecialVar_0x8005 = gMapHeader.events->mapObjects[j].localId; + gSpecialVar_0x8006 = sCurDecorMapX; + gSpecialVar_0x8007 = sCurDecorMapY; + show_sprite(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); + sub_808EBA8(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, gSpecialVar_0x8006, gSpecialVar_0x8007); + sub_808F254(gSpecialVar_0x8005, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); + break; + } + } +} + +bool8 sub_8127F38(void) +{ + u16 i; + + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + if (gUnknown_0203A17C.items[i] == DECOR_NONE) + { + return TRUE; + } + } + return FALSE; +} + +void sub_8127F68(u8 taskId) +{ + if (gUnknown_0203A17C.isPlayerRoom == TRUE && sCurDecorationCategory != DECORCAT_DOLL && sCurDecorationCategory != DECORCAT_CUSHION) + { + StringExpandPlaceholders(gStringVar4, gText_CantPlaceInRoom); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); + } + else if (IsSelectedDecorInThePC() == TRUE) + { + if (sub_8127F38() == TRUE) + { + fade_screen(1, 0); + gTasks[taskId].data[2] = 0; + gTasks[taskId].func = sub_8128060; + } + else + { + ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203A17C.size, STR_CONV_MODE_RIGHT_ALIGN, 2); + if (gUnknown_0203A17C.isPlayerRoom == FALSE) { + StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations); + } + else + { + StringExpandPlaceholders(gStringVar4, gText_NoMoreDecorations2); + } + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); + } + } + else + { + StringExpandPlaceholders(gStringVar4, gText_InUseAlready); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); + } +} + +void sub_8128060(u8 taskId) +{ + switch (gTasks[taskId].data[2]) + { + case 0: + if (!gPaletteFade.active) + { + sub_8127ACC(taskId); + gTasks[taskId].data[2] = 1; + } + break; + case 1: + gPaletteFade.bufferTransferDisabled = TRUE; + ConfigureCameraObjectForPlacingDecoration(&sPlaceDecorationGraphicsDataBuffer, gCurDecorInventoryItems[gCurDecorationIndex]); + sub_812826C(taskId); + SetUpPlacingDecorationPlayerAvatar(taskId, &sPlaceDecorationGraphicsDataBuffer); + pal_fill_black(); + gPaletteFade.bufferTransferDisabled = FALSE; + gTasks[taskId].data[2] = 2; + break; + case 2: + if (sub_80ABDFC() == TRUE) + { + gTasks[taskId].data[12] = 0; + sub_8128FD8(taskId); + } + break; + } +} + +void ConfigureCameraObjectForPlacingDecoration(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor) +{ + sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0; + gUnknown_03005DD0.unk4 = gpu_pal_decompress_alloc_tag_and_upload(data, decor); + gSprites[gUnknown_03005DD0.unk4].oam.priority = 1; + gSprites[gUnknown_03005DD0.unk4].callback = sub_81292D0; + gSprites[gUnknown_03005DD0.unk4].pos1.x = gUnknown_085A7250[data->decoration->shape].x; + gSprites[gUnknown_03005DD0.unk4].pos1.y = gUnknown_085A7250[data->decoration->shape].y; +} + +void SetUpPlacingDecorationPlayerAvatar(u8 taskId, struct PlaceDecorationGraphicsDataBuffer *data) +{ + u8 v0; + + v0 = 16 * (u8)gTasks[taskId].data[5] + gUnknown_085A7250[data->decoration->shape].x - 8 * ((u8)gTasks[taskId].data[5] - 1); + if (data->decoration->shape == DECORSHAPE_3x1 || data->decoration->shape == DECORSHAPE_3x3 || data->decoration->shape == DECORSHAPE_3x2) + { + v0 -= 8; + } + if (gSaveBlock2Ptr->playerGender == MALE) + { + sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, v0, 0x48, 0); + } + else + { + sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, v0, 0x48, 0); + } + gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1; + DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]); + sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4; +} + +void sub_812826C(u8 taskId) +{ + switch (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].shape) + { + case DECORSHAPE_1x1: + gTasks[taskId].data[5] = 1; + gTasks[taskId].data[6] = 1; + break; + case DECORSHAPE_2x1: + gTasks[taskId].data[5] = 2; + gTasks[taskId].data[6] = 1; + break; + case DECORSHAPE_3x1: + gTasks[taskId].data[5] = 3; + gTasks[taskId].data[6] = 1; + break; + case DECORSHAPE_4x2: + gTasks[taskId].data[5] = 4; + gTasks[taskId].data[6] = 2; + break; + case DECORSHAPE_2x2: + gTasks[taskId].data[5] = 2; + gTasks[taskId].data[6] = 2; + break; + case DECORSHAPE_1x2: + gTasks[taskId].data[5] = 1; + gTasks[taskId].data[6] = 2; + break; + case DECORSHAPE_1x3: + gTasks[taskId].data[5] = 1; + gTasks[taskId].data[6] = 3; + gTasks[taskId].data[1]++; + break; + case DECORSHAPE_2x4: + gTasks[taskId].data[5] = 2; + gTasks[taskId].data[6] = 4; + break; + case DECORSHAPE_3x3: + gTasks[taskId].data[5] = 3; + gTasks[taskId].data[6] = 3; + break; + case DECORSHAPE_3x2: + gTasks[taskId].data[5] = 3; + gTasks[taskId].data[6] = 2; + break; + } +} + +void sub_81283BC(u8 taskId) +{ + gTasks[taskId].data[10] = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1; + gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1; + sub_8128DE0(); + sub_8128950(taskId); +} + +void sub_8128414(u8 taskId) +{ + gTasks[taskId].data[10] = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 1; + gSprites[sDecor_CameraSpriteObjectIdx2].data7 = 1; + sub_8128DE0(); + StringExpandPlaceholders(gStringVar4, gText_CancelDecorating); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8128B80); +} + +bool8 sub_8128484(u8 behaviorAt, u16 behaviorBy) +{ + if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE || behaviorBy != 0) + { + return FALSE; + } + return TRUE; +} + +bool8 sub_81284AC(u8 taskId, s16 x, s16 y, u16 decor) +{ + if (x == gTasks[taskId].data[3] + 7 && y == gTasks[taskId].data[4] + 7 && decor != DECOR_NONE) + { + return FALSE; + } + return TRUE; +} + +bool8 sub_81284F4(u16 behaviorAt, const struct Decoration *decoration) +{ + if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE) + { + if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsMB_C2(behaviorAt) == TRUE) + { + return TRUE; + } + if (MetatileBehavior_IsNormal(behaviorAt)) + { + return TRUE; + } + } + return FALSE; +} + +bool8 sub_812853C(u8 taskId, const struct Decoration *decoration) +{ + u8 i; + u8 j; + u8 behaviorAt; + u16 behaviorBy; + u8 mapY; + u8 mapX; + s16 curY; + s16 curX; + mapY = gTasks[taskId].data[6]; + mapX = gTasks[taskId].data[5]; + + switch (decoration->permission) + { + case DECORPERM_SOLID_FLOOR: + case DECORPERM_PASS_FLOOR: + for (i=0; itiles[(mapY - 1 - i) * mapX + j]) & 0xf000; + if (!sub_81284F4(behaviorAt, decoration)) + { + return FALSE; + } + if (!sub_81284AC(taskId, curX, curY, behaviorBy)) + { + return FALSE; + } + behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0); + if (behaviorAt != 0 && behaviorAt != 16) + { + return FALSE; + } + } + } + break; + case DECORPERM_BEHIND_FLOOR: + for (i=0; itiles[(mapY - 1 - i) * mapX + j]) & 0xf000; + if (!MetatileBehavior_IsNormal(behaviorAt) && !sub_8128484(behaviorAt, behaviorBy)) + { + return FALSE; + } + if (!sub_81284AC(taskId, curX, curY, behaviorBy)) + { + return FALSE; + } + if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16) + { + return FALSE; + } + } + } + curY = gTasks[taskId].data[1] - mapY + 1; + for (j=0; jtiles[j]) & 0xf000; + if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsMB_B7(behaviorAt)) + { + return FALSE; + } + if (!sub_81284AC(taskId, curX, curY, behaviorBy)) + { + return FALSE; + } + behaviorAt = GetFieldObjectIdByXYZ(curX, curY, 0); + if (behaviorAt != 0 && behaviorAt != 16) + { + return FALSE; + } + } + break; + case DECORPERM_NA_WALL: + for (i=0; ishape == DECORSHAPE_1x2) + { + if (!MetatileBehavior_IsMB_C3(behaviorAt)) + { + return FALSE; + } + } + else if (!MetatileBehavior_IsMB_B5(behaviorAt)) + { + if (!MetatileBehavior_IsMB_C3(behaviorAt)) + { + return FALSE; + } + } + if (GetFieldObjectIdByXYZ(curX, curY, 0) != 16) + { + return FALSE; + } + } + break; + } + return TRUE; +} + +void sub_8128950(u8 taskId) +{ + if (sub_812853C(taskId, &gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]]) == TRUE) + { + StringExpandPlaceholders(gStringVar4, gText_PlaceItHere); + DisplayItemMessageOnField(taskId, gStringVar4, sub_81289D0); + } + else + { + PlaySE(SE_HAZURE); + StringExpandPlaceholders(gStringVar4, gText_CantBePlacedHere); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8129020); + } +} + +void sub_81289D0(u8 taskId) +{ + sub_8197930(); + sub_8121F68(taskId, &gUnknown_085A72C4); +} + +void sub_81289F0(u8 taskId) +{ + sub_8197434(0, 0); + sub_8128AAC(taskId); + if (gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].permission != DECORPERM_SOLID_MAT) + { + sub_8127D38(gTasks[taskId].data[0], gTasks[taskId].data[1], gCurDecorInventoryItems[gCurDecorationIndex]); + } + else + { + sCurDecorMapX = gTasks[taskId].data[0] - 7; + sCurDecorMapY = gTasks[taskId].data[1] - 7; + ScriptContext1_SetupScript(gUnknown_08275D1F); + } + gSprites[sDecor_CameraSpriteObjectIdx1].pos1.y += 2; + if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE) + { + TV_PutSecretBaseVisitOnTheAir(); + } + sub_8128BBC(taskId); +} + +void sub_8128AAC(u8 taskId) +{ + u16 i; + + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + if (gUnknown_0203A17C.items[i] == DECOR_NONE) + { + gUnknown_0203A17C.items[i] = gCurDecorInventoryItems[gCurDecorationIndex]; + gUnknown_0203A17C.pos[i] = ((gTasks[taskId].data[0] - 7) << 4) + (gTasks[taskId].data[1] - 7); + break; + } + } + if (!gUnknown_0203A17C.isPlayerRoom) + { + for (i = 0; i < 16; i ++) + { + if (sSecretBaseItemsIndicesBuffer[i] == 0) + { + sSecretBaseItemsIndicesBuffer[i] = gCurDecorationIndex + 1; + break; + } + } + } + else + { + for (i = 0; i < 12; i ++) + { + if (sPlayerRoomItemsIndicesBuffer[i] == 0) + { + sPlayerRoomItemsIndicesBuffer[i] = gCurDecorationIndex + 1; + break; + } + } + } +} + +void sub_8128B80(u8 taskId) +{ + sub_8197930(); + sub_8121F68(taskId, &gUnknown_085A72CC); +} + +void sub_8128BA0(u8 taskId) +{ + sub_8197434(0, 0); + sub_8128BBC(taskId); +} + +void sub_8128BBC(u8 taskId) +{ + fade_screen(1, 0); + gTasks[taskId].data[2] = 0; + gTasks[taskId].func = c1_overworld_prev_quest; +} + +void c1_overworld_prev_quest(u8 taskId) +{ + switch (gTasks[taskId].data[2]) + { + case 0: + ScriptContext2_Enable(); + if (!gPaletteFade.active) + { + sub_8127B04(taskId); + gTasks[taskId].data[2] = 1; + } + break; + case 1: + sub_812A3C8(); + FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG); + gFieldCallback = sub_8128CD4; + SetMainCallback2(c2_exit_to_overworld_2_switch); + DestroyTask(taskId); + break; + } +} + +void sub_8128C64(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + switch (data[2]) + { + case 0: + sub_80E9578(); + data[2] ++; + break; + case 1: + ScriptContext1_SetupScript(gUnknown_08275D0C); + data[2] ++; + break; + case 2: + ScriptContext2_Enable(); + data[2] ++; + break; + case 3: + if (sub_80ABDFC() == TRUE) + { + gTasks[taskId].func = sub_812764C; + } + break; + } +} + +void sub_8128CD4(void) +{ + u8 taskId; + + ScriptContext2_Enable(); + pal_fill_black(); + taskId = CreateTask(sub_8128C64, 8); + sub_8127580(taskId); + gTasks[taskId].data[2] = 0; +} + +bool8 sub_8128D10(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + if (sDecorationLastDirectionMoved == DIR_SOUTH && data[1] - data[6] - 6 < 0) + { + data[1] ++; + return FALSE; + } + if (sDecorationLastDirectionMoved == DIR_NORTH && data[1] - 7 >= gMapHeader.mapData->height) + { + data[1] --; + return FALSE; + } + if (sDecorationLastDirectionMoved == DIR_WEST && data[0] - 7 < 0) + { + data[0] ++; + return FALSE; + } + if (sDecorationLastDirectionMoved == DIR_EAST && data[0] + data[5] - 8 >= gMapHeader.mapData->width) + { + data[0] --; + return FALSE; + } + return TRUE; +} + +bool8 sub_8128DB4(void) +{ + u16 heldKeys; + + heldKeys = gMain.heldKeys & 0x0F0; + if (heldKeys != DPAD_UP && heldKeys != DPAD_DOWN && heldKeys != DPAD_LEFT && heldKeys != DPAD_RIGHT) + { + return FALSE; + } + return TRUE; +} + +void sub_8128DE0(void) +{ + sDecorationLastDirectionMoved = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; +} + +void sub_8128E18(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + if (!gSprites[sDecor_CameraSpriteObjectIdx1].data4) + { + if (data[10] == 1) + { + gUnknown_085A72D4[data[12]].yesFunc(taskId); + return; + } else if (data[10] == 2) + { + gUnknown_085A72D4[data[12]].noFunc(taskId); + return; + } + if ((gMain.heldKeys & 0x0F0) == DPAD_UP) + { + sDecorationLastDirectionMoved = DIR_SOUTH; + gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data3 = -2; + data[1]--; + } + if ((gMain.heldKeys & 0x0F0) == DPAD_DOWN) + { + sDecorationLastDirectionMoved = DIR_NORTH; + gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 2; + data[1]++; + } + if ((gMain.heldKeys & 0x0F0) == DPAD_LEFT) + { + sDecorationLastDirectionMoved = DIR_WEST; + gSprites[sDecor_CameraSpriteObjectIdx1].data2 = -2; + gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; + data[0]--; + } + if ((gMain.heldKeys & 0x0F0) == DPAD_RIGHT) + { + sDecorationLastDirectionMoved = DIR_EAST; + gSprites[sDecor_CameraSpriteObjectIdx1].data2 = 2; + gSprites[sDecor_CameraSpriteObjectIdx1].data3 = 0; + data[0]++; + } + if (!sub_8128DB4() || !sub_8128D10(taskId)) + { + sub_8128DE0(); + } + } + if (sDecorationLastDirectionMoved) + { + gSprites[sDecor_CameraSpriteObjectIdx1].data4++; + gSprites[sDecor_CameraSpriteObjectIdx1].data4 &= 7; + } + if (!data[10]) + { + if (gMain.newKeys & A_BUTTON) + { + data[10] = A_BUTTON; + } + if (gMain.newKeys & B_BUTTON) + { + data[10] = B_BUTTON; + } + } +} + +void sub_8128FD8(u8 taskId) +{ + sub_8197434(0, 1); + gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0; + gTasks[taskId].data[10] = 0; + gTasks[taskId].func = sub_8128E18; +} + +void sub_8129020(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + { + sub_8128FD8(taskId); + } +} + +void sub_8129048(struct PlaceDecorationGraphicsDataBuffer *data) +{ + CpuFill16(0, data, sizeof(*data)); +} + +void sub_8129068(u16 *dest, u16 pal) +{ + CpuFastCopy(&((u16 *)gTilesetPointer_SecretBase->palettes)[pal << 4], dest, 32); +} + +void sub_8129088(u8 *dest, u16 tile) +{ + u8 buffer[32]; + u16 mode; + u16 i; + + mode = tile >> 10; + if (tile != 0) + { + tile &= 0x03FF; + } + CpuFastCopy(&((u8 *)gTilesetPointer_SecretBase->tiles)[tile << 5], buffer, 32); + switch (mode) + { + case 0: + CpuFastCopy(buffer, dest, 32); + break; + case 1: + for (i = 0; i < 8; i ++) + { + dest[4 * i] = (buffer[4 * (i + 1) - 1] >> 4) + ((buffer[4 * (i + 1) - 1] & 0x0F) << 4); + dest[4 * i + 1] = (buffer[4 * (i + 1) - 2] >> 4) + ((buffer[4 * (i + 1) - 2] & 0x0F) << 4); + dest[4 * i + 2] = (buffer[4 * (i + 1) - 3] >> 4) + ((buffer[4 * (i + 1) - 3] & 0x0F) << 4); + dest[4 * i + 3] = (buffer[4 * (i + 1) - 4] >> 4) + ((buffer[4 * (i + 1) - 4] & 0x0F) << 4); + } + break; + case 2: + for (i = 0; i < 8; i ++) + { + dest[4 * i] = buffer[4 * (7 - i)]; + dest[4 * i + 1] = buffer[4 * (7 - i) + 1]; + dest[4 * i + 2] = buffer[4 * (7 - i) + 2]; + dest[4 * i + 3] = buffer[4 * (7 - i) + 3]; + } + break; + case 3: + for (i = 0; i < 32; i ++) + { + dest[i] = (buffer[31 - i] >> 4) + ((buffer[31 - i] & 0x0F) << 4); + } + break; + } +} + +void sub_81291A4(struct PlaceDecorationGraphicsDataBuffer *data) +{ + u16 i; + for (i = 0; i < 64; i ++) + { + sub_8129088(&data->image[i * 32], data->tiles[i]); + } +} + +u16 sub_81291CC(u16 tile) +{ + return ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[tile] & 0xFFF; +} + +void sub_81291E8(struct PlaceDecorationGraphicsDataBuffer *data) +{ + u8 i; + u8 shape; + + shape = data->decoration->shape; + for (i = 0; i < gUnknown_085A71B0[shape].size; i ++) + { + data->tiles[gUnknown_085A71B0[shape].tiles[i]] = sub_81291CC(data->decoration->tiles[gUnknown_085A71B0[shape].y[i]] * 8 + gUnknown_085A71B0[shape].x[i]); + } +} + +void SetDecorSelectionBoxOamAttributes(u8 decorShape) +{ + sDecorSelectorOam.y = 0; + sDecorSelectorOam.affineMode = ST_OAM_AFFINE_OFF; + sDecorSelectorOam.objMode = ST_OAM_OBJ_NORMAL; + sDecorSelectorOam.mosaic = 0; + sDecorSelectorOam.bpp = ST_OAM_4BPP; + sDecorSelectorOam.shape = gUnknown_085A7250[decorShape].shape; + sDecorSelectorOam.x = 0; + sDecorSelectorOam.matrixNum = 0; + sDecorSelectorOam.size = gUnknown_085A7250[decorShape].size; + sDecorSelectorOam.tileNum = 0; + sDecorSelectorOam.priority = 0; + sDecorSelectorOam.paletteNum = 0; +} + +void sub_81292D0(struct Sprite *sprite) +{ + sprite->data2 = 0; + sprite->data3 = 0; + sprite->data4 = 0; + sprite->data5 = 0; + sprite->data6 = 0; + sprite->data7 = 0; + sprite->callback = sub_81292E8; +} + +void sub_81292E8(struct Sprite *sprite) +{ + if (sprite->data7 == 0) + { + if (sprite->data6 < 15) + { + sprite->invisible = FALSE; + } + else + { + sprite->invisible = TRUE; + } + sprite->data6 ++; + sprite->data6 &= 0x1F; + } + else + { + sprite->invisible = FALSE; + } +} + +u8 gpu_pal_decompress_alloc_tag_and_upload(struct PlaceDecorationGraphicsDataBuffer *data, u8 decor) +{ + sub_8129048(data); + data->decoration = &gDecorations[decor]; + if (data->decoration->permission == DECORPERM_SOLID_MAT) + { + return AddPseudoFieldObject(data->decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1); + } + FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_SELECTOR_PAL_TAG); + sub_81291E8(data); + SetDecorSelectionBoxOamAttributes(data->decoration->shape); + sub_81291A4(data); + sub_8129068(data->palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(data->decoration->tiles[0] * 8) + 7] >> 12); + LoadSpritePalette(&gUnknown_085A72BC); + return CreateSprite(&sDecorSelectorSpriteTemplate, 0, 0, 0); +} + +u8 AddDecorationIconObjectFromIconTable(u16 tilesTag, u16 paletteTag, u8 decor) +{ + struct SpriteSheet sheet; + struct CompressedSpritePalette palette; + struct SpriteTemplate *template; + u8 spriteId; + + if (!AllocItemIconTemporaryBuffers()) + { + return MAX_SPRITES; + } + LZDecompressWram(GetDecorationIconPicOrPalette(decor, 0), gUnknown_0203CEBC); + CopyItemIconPicTo4x4Buffer(gUnknown_0203CEBC, gUnknown_0203CEC0); + sheet.data = gUnknown_0203CEC0; + sheet.size = 0x200; + sheet.tag = tilesTag; + LoadSpriteSheet(&sheet); + palette.data = GetDecorationIconPicOrPalette(decor, 1); + palette.tag = paletteTag; + LoadCompressedObjectPalette(&palette); + template = malloc(sizeof(struct SpriteTemplate)); + *template = gUnknown_08614FF4; + template->tileTag = tilesTag; + template->paletteTag = paletteTag; + spriteId = CreateSprite(template, 0, 0, 0); + FreeItemIconTemporaryBuffers(); + free(template); + return spriteId; +} + +const u8 *GetDecorationIconPicOrPalette(u16 decor, u8 mode) +{ + if (decor > 120) + { + decor = DECOR_NONE; + } + return gUnknown_085A6BE8[decor][mode]; +} + +u8 AddDecorationIconObjectFromFieldObject(u16 tilesTag, u16 paletteTag, u8 decor) +{ + u8 spriteId; + struct SpriteSheet sheet; + struct SpritePalette palette; + struct SpriteTemplate *template; + + sub_8129048(&sPlaceDecorationGraphicsDataBuffer); + sPlaceDecorationGraphicsDataBuffer.decoration = &gDecorations[decor]; + if (sPlaceDecorationGraphicsDataBuffer.decoration->permission != DECORPERM_SOLID_MAT) + { + sub_81291E8(&sPlaceDecorationGraphicsDataBuffer); + SetDecorSelectionBoxOamAttributes(sPlaceDecorationGraphicsDataBuffer.decoration->shape); + sub_81291A4(&sPlaceDecorationGraphicsDataBuffer); + sub_8129068(sPlaceDecorationGraphicsDataBuffer.palette, ((u16 *)gTilesetPointer_SecretBaseRedCave->metatiles)[(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0] * 8) + 7] >> 12); + sheet.data = sPlaceDecorationGraphicsDataBuffer.image; + sheet.size = gUnknown_085A72F4[sPlaceDecorationGraphicsDataBuffer.decoration->shape] << 5; + sheet.tag = tilesTag; + LoadSpriteSheet(&sheet); + palette.data = sPlaceDecorationGraphicsDataBuffer.palette; + palette.tag = paletteTag; + LoadSpritePalette(&palette); + template = Alloc(sizeof(struct SpriteTemplate)); + *template = sDecorWhilePlacingSpriteTemplate; + template->tileTag = tilesTag; + template->paletteTag = paletteTag; + spriteId = CreateSprite(template, 0, 0, 0); + free(template); + } + else + { + spriteId = AddPseudoFieldObject(sPlaceDecorationGraphicsDataBuffer.decoration->tiles[0], SpriteCallbackDummy, 0, 0, 1); + } + return spriteId; +} + +u8 AddDecorationIconObject(u8 decor, s16 x, s16 y, u8 priority, u16 tilesTag, u16 paletteTag) +{ + u8 spriteId; + + if (decor > 120) + { + spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, DECOR_NONE); + if (spriteId == MAX_SPRITES) + { + return MAX_SPRITES; + } + gSprites[spriteId].pos2.x = x + 4; + gSprites[spriteId].pos2.y = y + 4; + } + else if (gUnknown_085A6BE8[decor][0] == NULL) + { + spriteId = AddDecorationIconObjectFromFieldObject(tilesTag, paletteTag, decor); + if (spriteId == MAX_SPRITES) + { + return MAX_SPRITES; + } + gSprites[spriteId].pos2.x = x; + if (decor == DECOR_SILVER_SHIELD || decor == DECOR_GOLD_SHIELD) + { + gSprites[spriteId].pos2.y = y - 4; + } + else + { + gSprites[spriteId].pos2.y = y; + } + } + else + { + spriteId = AddDecorationIconObjectFromIconTable(tilesTag, paletteTag, decor); + if (spriteId == MAX_SPRITES) + { + return MAX_SPRITES; + } + gSprites[spriteId].pos2.x = x + 4; + gSprites[spriteId].pos2.y = y + 4; + } + gSprites[spriteId].oam.priority = priority; + return spriteId; +} + +void sub_81296EC(u8 idx) +{ + gUnknown_0203A17C.items[idx] = 0; + gUnknown_0203A17C.pos[idx] = 0; +} + +void sub_8129708(void) +{ + u16 i; + + gSpecialVar_0x8005 = 0; + gScriptResult = 0; + if (gSpecialVar_0x8004 == sCurDecorSelectedInRearrangement) + { + gScriptResult = 1; + } + else if (gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx]].permission == DECORPERM_SOLID_MAT) + { + gSpecialVar_0x8005 = sDecorRearrangementDataBuffer[gSpecialVar_0x8004].flagId; + sub_81296EC(sDecorRearrangementDataBuffer[gSpecialVar_0x8004].idx); + for (i = 0; i < gMapHeader.events->mapObjectCount; i ++) + { + if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8005) + { + gSpecialVar_0x8006 = gMapHeader.events->mapObjects[i].localId; + break; + } + } + } +} + +void sub_81297AC(void) +{ + u8 i; + + for (i = 0; i < gMapHeader.events->mapObjectCount; i ++) + { + if (gMapHeader.events->mapObjects[i].flagId == gSpecialVar_0x8004) + { + gSpecialVar_0x8005 = gMapHeader.events->mapObjects[i].localId; + break; + } + } +} + +void sub_81297F8(void) +{ + u8 i; + u8 y; + u8 x; + int posX; + int posY; + u8 perm; + + for (i = 0; i < sCurDecorSelectedInRearrangement; i ++) + { + perm = gDecorations[gUnknown_0203A17C.items[sDecorRearrangementDataBuffer[i].idx]].permission; + posX = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] >> 4; + posY = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[i].idx] & 0x0F; + if (perm != DECORPERM_SOLID_MAT) + { + for (y = 0; y < sDecorRearrangementDataBuffer[i].height; y ++) + { + for (x = 0; x < sDecorRearrangementDataBuffer[i].width; x ++) + { + MapGridSetMetatileEntryAt(posX + 7 + x, posY + 7 - y, gMapHeader.mapData->map[posX + x + gMapHeader.mapData->width * (posY - y)] | 0x3000); + } + } + sub_81296EC(sDecorRearrangementDataBuffer[i].idx); + } + } +} + +void sub_81298EC(u8 taskId) +{ + switch (gTasks[taskId].data[2]) + { + case 0: + sub_81297F8(); + gTasks[taskId].data[2] = 1; + break; + case 1: + if (!gPaletteFade.active) { + DrawWholeMapView(); + ScriptContext1_SetupScript(gUnknown_08275D2E); + sub_8197434(0, 1); + gTasks[taskId].data[2] = 2; + } + break; + case 2: + ScriptContext2_Enable(); + IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); + pal_fill_black(); + gTasks[taskId].data[2] = 3; + break; + case 3: + if (sub_80ABDFC() == TRUE) + { + StringExpandPlaceholders(gStringVar4, gText_DecorationReturnedToPC); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64); + if (gMapHeader.regionMapSectionId == REGION_MAP_SECRET_BASE) + { + TV_PutSecretBaseVisitOnTheAir(); + } + } + break; + } +} + + +bool8 sub_81299AC(u8 taskId) +{ + u16 i; + + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + if (gUnknown_0203A17C.items[i] != DECOR_NONE) + { + return TRUE; + } + } + return FALSE; +} + +void SetUpPuttingAwayDecorationPlayerAvatar(void) +{ + player_get_direction_lower_nybble(); + sDecor_CameraSpriteObjectIdx1 = gSprites[gUnknown_03005DD0.unk4].data0; + sub_812A39C(); + gUnknown_03005DD0.unk4 = CreateSprite(&gUnknown_085A7404, 0x78, 0x50, 0); + if (gSaveBlock2Ptr->playerGender == MALE) + { + sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC1, SpriteCallbackDummy, 0x88, 0x48, 0); + } + else + { + sDecor_CameraSpriteObjectIdx2 = AddPseudoFieldObject(0xC2, SpriteCallbackDummy, 0x88, 0x48, 0); + } + gSprites[sDecor_CameraSpriteObjectIdx2].oam.priority = 1; + DestroySprite(&gSprites[sDecor_CameraSpriteObjectIdx1]); + sDecor_CameraSpriteObjectIdx1 = gUnknown_03005DD0.unk4; + gSprites[sDecor_CameraSpriteObjectIdx1].oam.priority = 1; +} + +void sub_8129ABC(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + switch (data[2]) + { + case 0: + if (!gPaletteFade.active) + { + sub_8127ACC(taskId); + data[2] = 1; + data[6] = 1; + data[5] = 1; + } + break; + case 1: + SetUpPuttingAwayDecorationPlayerAvatar(); + pal_fill_black(); + data[2] = 2; + break; + case 2: + if (sub_80ABDFC() == TRUE) + { + data[12] = 1; + sub_8129B34(taskId); + } + break; + } +} + +void sub_8129B34(u8 taskId) +{ + sub_8197434(0, 1); + gSprites[sDecor_CameraSpriteObjectIdx1].data7 = 0; + gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; + gSprites[sDecor_CameraSpriteObjectIdx1].callback = sub_812A36C; + gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = 0x88; + gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = 0x48; + gTasks[taskId].data[10] = 0; + gTasks[taskId].func = sub_8128E18; +} + +void sub_8129BCC(u8 taskId) +{ + gTasks[taskId].data[10] = 0; + sub_8128DE0(); + sub_8129C74(taskId); +} + +void sub_8129BF8(u8 taskId) +{ + gTasks[taskId].data[10] = 0; + sub_8128DE0(); + gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; + gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; + StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations); + DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0); +} + +void sub_8129C74(u8 taskId) +{ + s16 *data; + u8 behavior; + + sub_812A0E8(taskId); + if (sCurDecorSelectedInRearrangement != 0) + { + StringExpandPlaceholders(gStringVar4, gText_ReturnDecorationToPC); + DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1A0); + } + else + { + data = gTasks[taskId].data; + behavior = MapGridGetMetatileBehaviorAt(data[0], data[1]); + if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsMB_C5(behavior) == TRUE) + { + gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; + gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; + StringExpandPlaceholders(gStringVar4, gText_StopPuttingAwayDecorations); + DisplayItemMessageOnField(taskId, gStringVar4, sub_812A1F0); + } + else + { + StringExpandPlaceholders(gStringVar4, gText_NoDecorationHere); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8129D64); + } + } +} + +void sub_8129D64(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + { + sub_8129B34(taskId); + } +} + +void sub_8129D8C(u8 decor, struct DecorRearrangementDataBuffer *data) +{ + if (gDecorations[decor].shape == DECORSHAPE_1x1) + { + data->width = 1; + data->height = 1; + } else if (gDecorations[decor].shape == DECORSHAPE_2x1) + { + data->width = 2; + data->height = 1; + } else if (gDecorations[decor].shape == DECORSHAPE_3x1) + { + data->width = 3; + data->height = 1; + } else if (gDecorations[decor].shape == DECORSHAPE_4x2) + { + data->width = 4; + data->height = 2; + } else if (gDecorations[decor].shape == DECORSHAPE_2x2) + { + data->width = 2; + data->height = 2; + } else if (gDecorations[decor].shape == DECORSHAPE_1x2) + { + data->width = 1; + data->height = 2; + } else if (gDecorations[decor].shape == DECORSHAPE_1x3) + { + data->width = 1; + data->height = 3; + } else if (gDecorations[decor].shape == DECORSHAPE_2x4) + { + data->width = 2; + data->height = 4; + } else if (gDecorations[decor].shape == DECORSHAPE_3x3) + { + data->width = 3; + data->height = 3; + } else if (gDecorations[decor].shape == DECORSHAPE_3x2) + { + data->width = 3; + data->height = 2; + } +} + +void sub_8129E0C(u8 x, u8 y) +{ + gSprites[sDecor_CameraSpriteObjectIdx1].invisible = TRUE; + gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; + gSprites[sDecor_CameraSpriteObjectIdx2].pos1.x = (x << 4) + 0x88; + gSprites[sDecor_CameraSpriteObjectIdx2].pos1.y = (y << 4) + 0x48; +} + +bool8 sub_8129E74(u8 taskId, u8 idx, struct DecorRearrangementDataBuffer *data) +{ + u8 x; + u8 y; + u8 xOff; + u8 yOff; + u8 ht; + + x = gTasks[taskId].data[0] - 7; + y = gTasks[taskId].data[1] - 7; + xOff = gUnknown_0203A17C.pos[idx] >> 4; + yOff = gUnknown_0203A17C.pos[idx] & 0x0F; + ht = data->height; + if (gUnknown_0203A17C.items[idx] == DECOR_SAND_ORNAMENT && MapGridGetMetatileIdAt(xOff + 7, yOff + 7) == 0x28C) + { + ht --; + } + if (x >= xOff && x < xOff + data->width && y > yOff - ht && y <= yOff) + { + sub_8129E0C(data->width - (x - xOff + 1), yOff - y); + return TRUE; + } + return FALSE; +} + +void sub_8129F20(void) +{ + u8 xOff; + u8 yOff; + u16 i; + + xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] >> 4; + yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx] & 0x0F; + for (i = 0; i < 0x40; i ++) + { + if (gSaveBlock1Ptr->mapObjectTemplates[i].x == xOff && gSaveBlock1Ptr->mapObjectTemplates[i].y == yOff && !FlagGet(gSaveBlock1Ptr->mapObjectTemplates[i].flagId)) + { + sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].flagId = gSaveBlock1Ptr->mapObjectTemplates[i].flagId; + break; + } + } +} + +bool8 sub_8129FC8(u8 taskId) +{ + u16 i; + + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + if (gUnknown_0203A17C.items[i] != 0) + { + if (gDecorations[gUnknown_0203A17C.items[i]].permission == DECORPERM_SOLID_MAT) + { + sub_8129D8C(gUnknown_0203A17C.items[i], sDecorRearrangementDataBuffer); + if (sub_8129E74(taskId, i, sDecorRearrangementDataBuffer) == TRUE) + { + sDecorRearrangementDataBuffer->idx = i; + sub_8129F20(); + sCurDecorSelectedInRearrangement = 1; + return TRUE; + } + } + } + } + return FALSE; +} + +void sub_812A040(u8 left, u8 top, u8 right, u8 bottom) +{ + u8 i; + u8 xOff; + u8 yOff; + u8 decorIdx; + + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + decorIdx = gUnknown_0203A17C.items[i]; + xOff = gUnknown_0203A17C.pos[i] >> 4; + yOff = gUnknown_0203A17C.pos[i] & 0x0F; + if (decorIdx != 0 && gDecorations[decorIdx].permission == DECORPERM_SOLID_MAT && left <= xOff && top <= yOff && right >= xOff && bottom >= yOff) + { + sDecorRearrangementDataBuffer[sCurDecorSelectedInRearrangement].idx = i; + sub_8129F20(); + sCurDecorSelectedInRearrangement++; + } + } +} + +#ifdef NONMATCHING +void sub_812A0E8(u8 taskId) +{ + u8 i; + u8 xOff; + u8 yOff; + u8 decor; + register u8 decor asm("r1"); + struct DecorRearrangementDataBuffer *data; + + sCurDecorSelectedInRearrangement = 0; + if (sub_8129FC8(taskId) != TRUE) + { + for (i = 0; i < gUnknown_0203A17C.size; i ++) + { + decor = gUnknown_0203A17C.items[i]; + if (decor != DECOR_NONE) + { + data = &sDecorRearrangementDataBuffer[0]; + sub_8129D8C(decor, data); + if (sub_8129E74(taskId, i, data) == TRUE) + { + data->idx = i; + sCurDecorSelectedInRearrangement ++; + break; + } + } + } + if (sCurDecorSelectedInRearrangement != 0) + { + xOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] >> 4; + yOff = gUnknown_0203A17C.pos[sDecorRearrangementDataBuffer[0].idx] & 0x0F; + sub_812A040(xOff, yOff - sDecorRearrangementDataBuffer[0].height + 1, xOff + sDecorRearrangementDataBuffer[0].width - 1, yOff); // Arithmetic register swap at the r2 argument: `add r2, r0, r2` instead of `add r2, r2, r0` + } + } +} +#else +__attribute__((naked)) void sub_812A0E8(u8 taskId) +{ + asm_unified("\tpush {r4-r7,lr}\n" + "\tlsls r0, 24\n" + "\tlsrs r6, r0, 24\n" + "\tldr r4, =sCurDecorSelectedInRearrangement\n" + "\tmovs r0, 0\n" + "\tstrb r0, [r4]\n" + "\tadds r0, r6, 0\n" + "\tbl sub_8129FC8\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r0, 0x1\n" + "\tbeq _0812A18C\n" + "\tmovs r5, 0\n" + "\tldr r0, =gUnknown_0203A17C\n" + "\tldrb r1, [r0, 0x8]\n" + "\tcmp r5, r1\n" + "\tbcs _0812A15A\n" + "\tadds r7, r4, 0\n" + "_0812A10E:\n" + "\tldr r0, [r0]\n" + "\tadds r0, r5\n" + "\tldrb r1, [r0]\n" + "\tcmp r1, 0\n" + "\tbeq _0812A14C\n" + "\tldr r4, =sDecorRearrangementDataBuffer\n" + "\tadds r0, r1, 0\n" + "\tadds r1, r4, 0\n" + "\tbl sub_8129D8C\n" + "\tadds r0, r6, 0\n" + "\tadds r1, r5, 0\n" + "\tadds r2, r4, 0\n" + "\tbl sub_8129E74\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r0, 0x1\n" + "\tbne _0812A14C\n" + "\tstrb r5, [r4]\n" + "\tldrb r0, [r7]\n" + "\tadds r0, 0x1\n" + "\tstrb r0, [r7]\n" + "\tb _0812A15A\n" + "\t.pool\n" + "_0812A14C:\n" + "\tadds r0, r5, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r5, r0, 24\n" + "\tldr r0, =gUnknown_0203A17C\n" + "\tldrb r1, [r0, 0x8]\n" + "\tcmp r5, r1\n" + "\tbcc _0812A10E\n" + "_0812A15A:\n" + "\tldr r0, =sCurDecorSelectedInRearrangement\n" + "\tldrb r0, [r0]\n" + "\tcmp r0, 0\n" + "\tbeq _0812A18C\n" + "\tldr r0, =gUnknown_0203A17C\n" + "\tldr r2, =sDecorRearrangementDataBuffer\n" + "\tldrb r1, [r2]\n" + "\tldr r0, [r0, 0x4]\n" + "\tadds r0, r1\n" + "\tldrb r1, [r0]\n" + "\tlsrs r0, r1, 4\n" + "\tmovs r3, 0xF\n" + "\tands r3, r1\n" + "\tldrb r1, [r2, 0x2]\n" + "\tsubs r1, r3, r1\n" + "\tadds r1, 0x1\n" + "\tlsls r1, 24\n" + "\tlsrs r1, 24\n" + "\tldrb r2, [r2, 0x1]\n" + "\tadds r2, r0\n" + "\tsubs r2, 0x1\n" + "\tlsls r2, 24\n" + "\tlsrs r2, 24\n" + "\tbl sub_812A040\n" + "_0812A18C:\n" + "\tpop {r4-r7}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.pool"); +} +#endif + +void sub_812A1A0(u8 taskId) +{ + sub_8197930(); + sub_8121F68(taskId, &gUnknown_085A7348); +} + +void sub_812A1C0(u8 taskId) +{ + fade_screen(1, 0); + gTasks[taskId].data[2] = 0; + gTasks[taskId].func = sub_81298EC; +} + +void sub_812A1F0(u8 taskId) +{ + sub_8197930(); + sub_8121F68(taskId, &gUnknown_085A7350); +} + +void sub_812A210(u8 taskId) +{ + sub_8197434(0, 0); + sub_812A22C(taskId); +} + +void sub_812A22C(u8 taskId) +{ + fade_screen(1, 0); + gTasks[taskId].data[2] = 0; + gTasks[taskId].func = sub_812A25C; +} + +void sub_812A25C(u8 taskId) +{ + switch (gTasks[taskId].data[2]) + { + case 0: + if (!gPaletteFade.active) + { + sub_8127B04(taskId); + gTasks[taskId].data[2] = 1; + } + break; + case 1: + sub_812A3C8(); + gFieldCallback = sub_812A334; + SetMainCallback2(c2_exit_to_overworld_2_switch); + DestroyTask(taskId); + break; + } +} + +void sub_812A2C4(u8 taskId) +{ + s16 *data; + + data = gTasks[taskId].data; + switch (data[2]) + { + case 0: + sub_80E9578(); + data[2] ++; + break; + case 1: + ScriptContext1_SetupScript(gUnknown_08275D0C); + data[2] ++; + break; + case 2: + ScriptContext2_Enable(); + data[2] ++; + break; + case 3: + if (sub_80ABDFC() == TRUE) + { + gTasks[taskId].func = sub_8126B80; + } + break; + } +} + +void sub_812A334(void) +{ + u8 taskId; + + pal_fill_black(); + sub_81973C4(0, 1); + sub_8126ABC(); + taskId = CreateTask(sub_812A2C4, 8); + gTasks[taskId].data[2] = 0; +} + +void sub_812A36C(struct Sprite *sprite) +{ + sprite->data0 ++; + sprite->data0 &= 0x1F; + if (sprite->data0 > 15) + { + sprite->invisible = TRUE; + } + else + { + sprite->invisible = FALSE; + } +} + +void sub_812A39C(void) +{ + if (gSaveBlock2Ptr->playerGender == MALE) + { + LoadSpritePalette(&gUnknown_085A73D8); + } + else + { + LoadSpritePalette(&gUnknown_085A73E0); + } +} + +void sub_812A3C8(void) +{ + FreeSpritePaletteByTag(OVERWORLD_PLACE_DECOR_PLAYER_PAL_TAG); +} + +void sub_812A3D4(u8 taskId) +{ + if (IsSelectedDecorInThePC() == TRUE) + { + StringCopy(gStringVar1, gDecorations[gCurDecorInventoryItems[gCurDecorationIndex]].name); + StringExpandPlaceholders(gStringVar4, gText_DecorationWillBeDiscarded); + DisplayItemMessageOnField(taskId, gStringVar4, sub_812A458); + } + else + { + StringExpandPlaceholders(gStringVar4, gText_CantThrowAwayInUse); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); + } +} + +void sub_812A458(u8 taskId) +{ + sub_8197930(); + sub_8121F68(taskId, &gUnknown_085A741C); +} + +void sub_812A478(u8 taskId) +{ + gCurDecorInventoryItems[gCurDecorationIndex] = DECOR_NONE; + sCurDecorCatCount = CountDecorationCategoryN(sCurDecorationCategory); + CondenseDecorationCategoryN(sCurDecorationCategory); + IdentifyOwnedDecorationsCurrentlyInUseInternal(taskId); + StringExpandPlaceholders(gStringVar4, gText_DecorationThrownAway); + DisplayItemMessageOnField(taskId, gStringVar4, sub_8127A5C); +} diff --git a/src/decoration_inventory.c b/src/decoration_inventory.c new file mode 100644 index 000000000..03ab6c00c --- /dev/null +++ b/src/decoration_inventory.c @@ -0,0 +1,189 @@ + +// Includes +#include "global.h" +#include "decoration.h" +#include "decoration_inventory.h" + +// Static type declarations + +// Static RAM declarations + +EWRAM_DATA struct DecorationInventory gDecorationInventories[8] = {}; + +// Static ROM declarations + +// .rodata + +// .text + +#define SET_DECOR_INV(i, ptr) {\ + gDecorationInventories[i].items = ptr;\ + gDecorationInventories[i].size = sizeof(ptr);\ +} + +void SetDecorationInventoriesPointers(void) +{ + SET_DECOR_INV(0, gSaveBlock1Ptr->decorDesk); + SET_DECOR_INV(1, gSaveBlock1Ptr->decorChair); + SET_DECOR_INV(2, gSaveBlock1Ptr->decorPlant); + SET_DECOR_INV(3, gSaveBlock1Ptr->decorOrnament); + SET_DECOR_INV(4, gSaveBlock1Ptr->decorMat); + SET_DECOR_INV(5, gSaveBlock1Ptr->decorPoster); + SET_DECOR_INV(6, gSaveBlock1Ptr->decorDoll); + SET_DECOR_INV(7, gSaveBlock1Ptr->decorCushion); + sub_8126968(); +} + +static void ClearDecorationInventory(u8 idx) +{ + u8 i; + + for (i = 0; i < gDecorationInventories[idx].size; i ++) + { + gDecorationInventories[idx].items[i] = DECOR_NONE; + } +} + +void ClearDecorationInventories(void) +{ + u8 idx; + + for (idx = 0; idx < 8; idx ++) + { + ClearDecorationInventory(idx); + } +} + +s8 GetFirstEmptyDecorSlot(u8 idx) +{ + s8 i; + + for (i = 0; i < (s8)gDecorationInventories[idx].size; i ++) + { + if (gDecorationInventories[idx].items[i] == DECOR_NONE) + { + return i; + } + } + return -1; +} + +bool8 CheckHasDecoration(u8 decor) +{ + u8 i; + u8 category; + + category = gDecorations[decor].category; + for (i = 0; i < gDecorationInventories[category].size; i ++) + { + if (gDecorationInventories[category].items[i] == decor) + { + return TRUE; + } + } + return FALSE; +} + +bool8 DecorationAdd(u8 decor) +{ + u8 category; + s8 idx; + + if (decor == DECOR_NONE) + { + return FALSE; + } + category = gDecorations[decor].category; + idx = GetFirstEmptyDecorSlot(category); + if (idx == -1) + { + return FALSE; + } + gDecorationInventories[category].items[idx] = decor; + return TRUE; +} + +bool8 DecorationCheckSpace(u8 decor) +{ + if (decor == DECOR_NONE) + { + return FALSE; + } + if (GetFirstEmptyDecorSlot(gDecorations[decor].category) == -1) + { + return FALSE; + } + return TRUE; +} + +s8 DecorationRemove(u8 decor) +{ + u8 i; + u8 idx; + + i = 0; + if (decor == DECOR_NONE) + { + return 0; + } + for (i = 0; i < gDecorationInventories[gDecorations[decor].category].size; i ++) + { + idx = gDecorations[decor].category; + if (gDecorationInventories[idx].items[i] == decor) + { + gDecorationInventories[idx].items[i] = DECOR_NONE; + CondenseDecorationCategoryN(idx); + return 1; + } + } + return 0; +} + +void CondenseDecorationCategoryN(u8 idx) +{ + u8 i; + u8 j; + u8 tmp; + + for (i = 0; i < gDecorationInventories[idx].size; i ++) + { + for (j = i + 1; j < gDecorationInventories[idx].size; j ++) + { + if (gDecorationInventories[idx].items[j] != DECOR_NONE && (gDecorationInventories[idx].items[i] == DECOR_NONE || gDecorationInventories[idx].items[i] > gDecorationInventories[idx].items[j])) + { + tmp = gDecorationInventories[idx].items[i]; + gDecorationInventories[idx].items[i] = gDecorationInventories[idx].items[j]; + gDecorationInventories[idx].items[j] = tmp; + } + } + } +} + +u8 CountDecorationCategoryN(u8 idx) +{ + u8 i; + u8 ct; + + ct = 0; + for (i = 0; i < gDecorationInventories[idx].size; i ++) + { + if (gDecorationInventories[idx].items[i] != DECOR_NONE) + { + ct ++; + } + } + return ct; +} + +u8 CountDecorations(void) +{ + u8 idx; + u8 ct; + + ct = 0; + for (idx = 0; idx < 8; idx ++) + { + ct += CountDecorationCategoryN(idx); + } + return ct; +} diff --git a/src/international_string_util.c b/src/international_string_util.c index c77b4f8ff..81985d614 100644 --- a/src/international_string_util.c +++ b/src/international_string_util.c @@ -28,13 +28,13 @@ s32 GetStringWidthDifference(s32 fontId, const u8 *str, s32 totalWidth, s32 lett return 0; } -s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1) +s32 GetMaxWidthInMenuTable(const struct MenuAction *str, s32 arg1) { s32 i, var; for (var = 0, i = 0; i < arg1; i++) { - s32 stringWidth = GetStringWidth(1, str[i * 2], 0); + s32 stringWidth = GetStringWidth(1, str[i].text, 0); if (stringWidth > var) var = stringWidth; } @@ -42,13 +42,13 @@ s32 GetMaxWidthInMenuTable(const u8 **str, s32 arg1) return convert_pixel_width_to_tile_width(var); } -s32 sub_81DB3D8(const u8 **str, u8* arg1, s32 arg2) +s32 sub_81DB3D8(const struct MenuAction *str, u8* arg1, s32 arg2) { s32 i, var; for (var = 0, i = 0; i < arg2; i++) { - s32 stringWidth = GetStringWidth(1, str[arg1[i] * 2], 0); + s32 stringWidth = GetStringWidth(1, str[arg1[i]].text, 0); if (stringWidth > var) var = stringWidth; } diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c new file mode 100755 index 000000000..37ecdc982 --- /dev/null +++ b/src/pokemon_summary_screen.c @@ -0,0 +1,3679 @@ +#include "global.h" +#include "battle.h" +#include "bg.h" +#include "decompress.h" +#include "item.h" +#include "items.h" +#include "link.h" +#include "m4a.h" +#include "main.h" +#include "malloc.h" +#include "moves.h" +#include "palette.h" +#include "pokemon.h" +#include "songs.h" +#include "sound.h" +#include "species.h" +#include "sprite.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "window.h" + +struct ContestMove +{ + u8 effect; + u8 type; + u8 comboID; + u8 combo[4]; +}; + +struct ContestEffect +{ + u8 type; + u8 appeal; + u8 jam; +}; + + + +extern struct UnkSummaryStruct* gUnknown_0203CF1C; +extern struct BgTemplate gUnknown_0861CBB4; +extern u8 gUnknown_0203CF20; +extern struct MusicPlayerInfo gMPlay_BGM; +extern s8 gUnknown_0861CC1C[]; +extern u8 gUnknown_08329D22[]; +extern u8 gUnknown_0203CF21; +extern u16 gSpecialVar_0x8005; +extern struct UnkStruct_61CC04 gUnknown_0861CC04; +extern struct UnkStruct_61CC04 gUnknown_0861CC10; +extern struct UnkStruct_61CC04 gUnknown_0861CBEC; +extern struct UnkStruct_61CC04 gUnknown_0861CBF8; +extern u16 gUnknown_08DC3CD4[]; +extern struct ContestMove gContestMoves[]; +extern struct ContestEffect gContestEffects[]; +extern struct WindowTemplate gUnknown_0861CC24; +extern struct TextColor gUnknown_0861CD2C[]; +extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1]; +extern u8 gText_MaleSymbol[]; +extern u8 gText_FemaleSymbol[]; +extern u8 gUnknown_0861CDD3[]; +extern void (*const gUnknown_0861CE54[])(); +extern void (*const gUnknown_0861CE64[])(u8 taskId); +extern struct WindowTemplate gUnknown_0861CCCC; +extern u8 gUnknown_0861CE74[]; +extern u8 gUnknown_0861CE7B[]; +extern struct WindowTemplate gUnknown_0861CCEC; +extern struct WindowTemplate gUnknown_0861CD14; + +extern void sub_806F2AC(u8 a, u8 b); +void sub_81C488C(u8 a); +extern void do_scheduled_bg_tilemap_copies_to_vram(void); +extern u8 sub_81221EC(); +extern u8 sub_81221AC(); +extern void SetVBlankHBlankCallbacksToNull(); +extern void sub_8121DA0(); +extern void clear_scheduled_bg_copies_to_vram(); +extern void remove_some_task(); +extern void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable); +extern void ShowBg(u8 a); +extern void SetGpuReg(u8 regOffset, u16 value); +extern void schedule_bg_copy_tilemap_to_vram(u8 a); +extern void SetBgTilemapBuffer(u8 bg, void *tilemap); +extern u8 gUnknown_08D9862C; +extern u8 gUnknown_08D98CC8; +extern u8 gUnknown_08D987FC; +extern u8 gUnknown_08D9898C; +extern u8 gUnknown_08D98B28; +extern u8 gUnknown_08D9853C; +extern u8 gUnknown_08D85620; +extern struct CompressedSpriteSheet gUnknown_0861CFBC; +extern struct CompressedSpriteSheet gUnknown_0861D074; +extern struct CompressedSpriteSheet gUnknown_0861D0F8; +extern struct CompressedSpritePalette gUnknown_0861D100; +extern struct CompressedSpritePalette gUnknown_0861D07C; +extern u8 gUnknown_08D97B84; +extern u8 gUnknown_08D97D0C; +extern void reset_temp_tile_data_buffers(); +extern void decompress_and_copy_tile_data_to_vram(u8 a, void* tiledata, u8 b, u8 c, u8 d); +extern u8 free_temp_tile_data_buffers_if_possible(); +extern void sub_8069004(struct BoxPokemon* a, void* b); +extern void sub_81C1E20(u8 taskId); +extern u8 *GetMonNickname(struct Pokemon *mon, u8 *dest); +extern u16 SpeciesToPokedexNum(u16 species); +extern u8 gText_UnkCtrlF908Clear01[]; +extern u8 gText_LevelSymbol[]; +extern u8 gText_PkmnInfo[]; +extern u8 gText_PkmnSkills[]; +extern u8 gText_BattleMoves[]; +extern u8 gText_ContestMoves[]; +extern u8 gText_Cancel2[]; +extern u8 gText_Info[]; +extern u8 gText_Switch[]; +extern u8 gText_RentalPkmn[]; +extern u8 gText_TypeSlash[]; +extern u8 gText_HP4[]; +extern u8 gText_Attack3[]; +extern u8 gText_Defense3[]; +extern u8 gText_SpAtk4[]; +extern u8 gText_SpDef4[]; +extern u8 gText_Speed2[]; +extern u8 gText_ExpPoints[]; +extern u8 gText_NextLv[]; +extern u8 gText_Status[]; +extern u8 gText_Power[]; +extern u8 gText_Accuracy2[]; +extern u8 gText_Appeal[]; +extern u8 gText_Jam[]; +extern u8 gText_OTSlash[]; +extern u8 gText_UnkCtrlF907F908[]; +extern u8 gAbilityNames[][13]; +extern u8 *gAbilityDescriptionPointers[]; +extern u8 gText_XNature[]; +extern u8 gText_XNatureHatchedAtYZ[]; +extern u8 gText_XNatureHatchedSomewhereAt[]; +extern u8 gText_XNatureMetAtYZ[]; +extern u8 gText_XNatureMetSomewhereAt[]; +extern u8 gText_XNatureFatefulEncounter[]; +extern u8 gText_XNatureProbablyMetAt[]; +extern u8 gText_XNatureObtainedInTrade[]; +extern u8 *gNatureNamePointers[]; +extern u8 gText_EmptyString5[]; +extern u32 gBattleTypeFlags; +extern u8 gText_FiveMarks[]; +extern u8 gText_EggWillTakeALongTime[]; +extern u8 gText_EggAboutToHatch[]; +extern u8 gText_EggWillHatchSoon[]; +extern u8 gText_EggWillTakeSomeTime[]; +extern u8 gText_PeculiarEggNicePlace[]; +extern u8 gText_PeculiarEggTrade[]; +extern u8 gText_EggFromTraveler[]; +extern u8 gText_EggFromHotSprings[]; +extern u8 gText_OddEggFoundByCouple[]; +extern u8 gText_None[]; +extern u8 gText_RibbonsVar1[]; +extern u8 gUnknown_0861CE82[]; +extern u8 gUnknown_0861CE8E[]; +extern u8 gText_OneDash[]; +extern u8 gText_TwoDashes[]; +extern u8 gText_ThreeDashes[]; +extern u8 gUnknown_0861CE97[]; +extern struct BattleMove gBattleMoves[]; + +extern u32 ChangeBgX(u8 bg, u32 value, u8 op); +extern void sub_8199C30(u8 a, u8 b, u8 c, u8 d, u8 e, u8 f); +extern void AddTextPrinterParametrized2(u8 windowId, u8 fontId, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, struct TextColor* colors, s8 speed, u8 *str); +extern s32 GetStringCenterAlignXOffset(u8 fontId, u8 *str, s32 totalWidth); +extern s32 GetStringRightAlignXOffset(u8 fontId, u8 *str, s32 totalWidth); +extern bool8 sub_81A6BF4(); +extern bool8 sub_81B9E94(); +extern void sub_81AFBF0(); +extern u8 sub_81AFC0C(u8 a, u8 *b); +extern void sub_81AFC28(u8 *a, u8 *b); +extern void sub_8124610(u8 *a, u8 b); +extern int GetPlayerIDAsU32(); +extern u8 GetCurrentPpToMaxPpState(u8 a, u8 b); + +void sub_81BFAE4(void); +void sub_81BFE24(); +u8 sub_81BFEB0(); +void sub_81C2554(); +void sub_81C1BA0(); +void sub_81C0098(struct Pokemon* a); +bool8 sub_81C00F0(struct Pokemon* a); +void sub_81C25E8(); +void sub_81C286C(); +void sub_81C2D9C(u8 a); +void sub_81C0348(); +void sub_81C2AFC(u8 a); +void sub_81C4190(); +void sub_81C42C8(); +u8 sub_81C45F4(void* a, u16* b); +void sub_81C4984(); +void sub_81C4A08(); +void sub_81C4A88(); +void sub_81C4280(); +void sub_81C0510(u8 taskId); +void sub_81C171C(u8 taskId); +void sub_8121E10(); +u8 sub_81B205C(struct Pokemon* a); +void sub_81C1DA4(u16 a, s16 b); +void sub_81C1EFC(u16 a, s16 b, u16 c); +void sub_81C240C(u16 a); +void sub_81C2194(u16 *a, u16 b, u8 c); +void sub_81C2074(u16 a, s16 b); +void sub_81C2524(); +void sub_81C2228(struct Pokemon* mon); +void sub_81C0484(u8 taskId); +void sub_81C4898(); +void sub_806F47C(u8 a); +u8 GetLRKeysState(); +void sub_81C0604(u8 taskId, s8 a); +void sub_81C0A8C(u8 taskId, s8 a); +void sub_81C48F0(); +void sub_81C0E48(u8 taskId); +void sub_81C0704(u8 taskId); +s8 sub_81C09B4(s8 a); +s8 sub_81C08F8(s8 a); +void sub_81C4204(u8 a, u8 b); +void sub_81C20F0(u8 taskId); +bool8 sub_81C0A50(struct Pokemon* mon); +void sub_81C49E0(); +void sub_81C0E24(); +void sub_81C2C38(u8 a); +void sub_81C0B8C(u8 taskId); +void sub_81C0CC4(u8 taskId); +void sub_81C2DE4(u8 a); +void sub_81C424C(); +void sub_81C0C68(u8 taskId); +void sub_81C0D44(u8 taskId); +void sub_81C22CC(struct Pokemon* mon); +void sub_81C0F44(u8 taskId); +void sub_81C3E9C(u16 a); +void sub_81C3F44(); +void sub_81C44F0(); +void sub_81C4AF8(u8 a); +void sub_81C1070(s16* a, s8 b, u8* c); +void sub_81C11F4(u8 a); +void sub_81C129C(u8 a); +bool8 sub_81C1040(); +void sub_81C4064(); +void sub_81C4C60(u8 a); +void sub_81C12E4(u8 taskId); +void sub_81C4C84(u8 a); +void sub_81C13B0(u8 a, u8 b); +void sub_81C14BC(struct Pokemon *mon, u8 a, u8 b); +void sub_81C15EC(struct BoxPokemon *mon, u8 a, u8 b); +void sub_81C40A0(u8 a, u8 b); +void sub_81C4568(u8 a, u8 b); +void sub_81C174C(u8 taskId); +bool8 sub_81C18A8(); +void sub_81C18F4(u8 a); +u8 sub_81B6D14(u16 a); +void sub_81C1940(u8 taskId); +void sub_81C4154(); +void sub_81C1F80(u8 taskId); +void sub_81C2628(); +void sub_81C2794(); +void sub_81C27DC(struct Pokemon *mon, u16 a); +void sub_81C2D68(u8 a); +void sub_81C335C(); +void sub_81C33CC(); +void sub_81C3428(); +void sub_81C349C(); +void sub_81C2EC4(); +void sub_81C2F5C(); +void sub_81C2FD8(); +void sub_81C302C(); +void sub_81C307C(); +void sub_81C3194(); +void sub_81C31C0(); +bool8 sub_81C3304(); +void sub_81C31F0(u8 *a); +u8 sub_81C3220(); +bool8 sub_81C32BC(); +void sub_81C35E4(); +void sub_81C3690(); +void sub_81C3710(); +void sub_81C37D8(); +void sub_81C3808(); +void sub_81C3890(); +void sub_81C38C0(); +void sub_81C3B08(u8 a); +void sub_81C3E2C(u8 a); +void sub_81C4D18(); + +void SetBgAttribute(u8 bg, u8 attributeId, u8 value); + +bool8 sub_81BFB10(); +u8 sub_81B1250(); + +union UnkUnion +{ + struct Pokemon mon[6]; + struct BoxPokemon boxMon[6]; +}; + + +u8 sub_80D214C(union UnkUnion* a, u8 b, u8 c, u8 d); + +struct PokeSummary +{ + u16 species; // 0x0 + u16 species2; // 0x2 + u8 isEgg; // 0x4 + u8 level; // 0x5 + u8 ribbons; // 0x6 + u8 unk7; // 0x7 + u8 altAbility; // 0x8 + u8 metLocation; // 0x9 + u8 metLevel; // 0xA + u8 metGame; // 0xB + u32 pid; // 0xC + u32 exp; // 0x10 + u16 moves[4]; // 0x14 + u8 pp[4]; // 0x1C + u16 currentHP; // 0x20 + u16 maxHP; // 0x22 + u16 atk; // 0x24 + u16 def; // 0x26 + u16 spatk; // 0x28 + u16 spdef; // 0x2A + u16 speed; // 0x2C + u16 item; // 0x2E + u16 friendship; // 0x30 + u8 OTGender; // 0x32 + u8 nature; // 0x33 + u8 ppBonuses; // 0x34 + u8 sanity; // 0x35 + u8 OTName[8]; // 0x36 + u8 unk3E[9]; // 0x3E + u32 OTID; // 0x48 +}; + +struct UnkSummaryStruct +{ + /*0x00*/ union UnkUnion *unk0; + /*0x04*/ void *unk4; + /*0x08*/ void *unk8; + /*0x0C*/ struct Pokemon currentMon; + /*0x70*/ struct PokeSummary summary; + u16 unkTilemap0[0x400]; + u16 unkTilemap0_1[0x400]; + u16 unkTilemap1[0x400]; + u16 unkTilemap1_1[0x400]; + u16 unkTilemap2[0x400]; + u16 unkTilemap2_1[0x400]; + u16 unkTilemap3[0x400]; + u16 unkTilemap3_1[0x400]; + u8 unk40BC; + u8 unk40BD; + u8 unk40BE; + u8 unk40BF; + u8 unk40C0; + u8 unk40C1; + u8 unk40C2; + u8 unk40C3; + u16 unk40C4; + u8 unk40C6; + u8 unk40C7; + u8 unk40C8; + u8 unk40C9; + u8 unk40CA; + u8 unk40CB[8]; + u8 unk40D3; + u8 unk40D4; + u8 unk40D5; + u8 unk_filler5[0x19]; + u8 unk40EF; + s16 unk40F0; + u8 unk_filler4[6]; +}; + +void sub_81BF8EC(u8 a, void *b, u8 c, u8 d, void *e) +{ + u8 byte; + gUnknown_0203CF1C = AllocZeroed(sizeof(struct UnkSummaryStruct)); + gUnknown_0203CF1C->unk40BC = a; + gUnknown_0203CF1C->unk0 = b; + gUnknown_0203CF1C->unk40BE = c; + gUnknown_0203CF1C->unk40BF = d; + gUnknown_0203CF1C->unk4 = e; + if (a == 2) + gUnknown_0203CF1C->unk40BD = 1; + else + gUnknown_0203CF1C->unk40BD = 0; + switch (a) + { + case 0: + case 2: + gUnknown_0203CF1C->unk40C1 = 0; + gUnknown_0203CF1C->unk40C2 = 3; + break; + case 1: + gUnknown_0203CF1C->unk40C1 = 0; + gUnknown_0203CF1C->unk40C2 = 3; + gUnknown_0203CF1C->unk40C8 = 1; + break; + case 3: + gUnknown_0203CF1C->unk40C1 = 2; + gUnknown_0203CF1C->unk40C2 = 3; + gUnknown_0203CF1C->unk40C3 = 1; + break; + } + byte = gUnknown_0203CF1C->unk40C1; + gUnknown_0203CF1C->unk40C0 = byte; + sub_81C488C(0xFF); + if (gMonSpritesGfxPtr == 0) + sub_806F2AC(0, 0); + SetMainCallback2(sub_81BFAE4); +} + +void sub_81BFA38(void *a, u8 b, u8 c, void *d, u16 e) +{ + sub_81BF8EC(3, a, b, c, d); + gUnknown_0203CF1C->unk40C4 = e; +} + +void sub_81BFA80(u8 a, void *b, u8 c, u8 d, void *e) +{ + sub_81BF8EC(a, b, c, d, e); + gUnknown_0203CF1C->unk40EF = 1; +} + +void sub_81BFAB4(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + do_scheduled_bg_tilemap_copies_to_vram(); + UpdatePaletteFade(); +} + +void sub_81BFAD0(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void sub_81BFAE4() +{ + while (1) + { + if (sub_81221EC() == 1 || sub_81BFB10() == TRUE || sub_81221AC() == 1) + break; + } +} + +bool8 sub_81BFB10(void) +{ + switch (gMain.state) + { + case 0: + SetVBlankHBlankCallbacksToNull(); + sub_8121DA0(); + clear_scheduled_bg_copies_to_vram(); + gMain.state++; + break; + case 1: + remove_some_task(); + gMain.state++; + break; + case 2: + ResetPaletteFade(); + gPaletteFade.bufferTransferDisabled = 1; + gMain.state++; + break; + case 3: + ResetSpriteData(); + gMain.state++; + break; + case 4: + FreeAllSpritePalettes(); + gMain.state++; + break; + case 5: + sub_81BFE24(); + gUnknown_0203CF1C->unk40F0 = 0; + gMain.state++; + break; + case 6: + if (sub_81BFEB0() != 0) + gMain.state++; + break; + case 7: + sub_81C2554(); + gMain.state++; + break; + case 8: + sub_81C1BA0(); + gMain.state++; + break; + case 9: + sub_81C0098(&gUnknown_0203CF1C->currentMon); + gUnknown_0203CF1C->unk40F0 = 0; + gMain.state++; + break; + case 10: + if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) != 0) + gMain.state++; + break; + case 11: + sub_81C25E8(); + gMain.state++; + break; + case 12: + sub_81C286C(); + gMain.state++; + break; + case 13: + sub_81C2D9C(gUnknown_0203CF1C->unk40C0); + gMain.state++; + break; + case 14: + sub_81C0348(); + gMain.state++; + break; + case 15: + sub_81C2AFC(gUnknown_0203CF1C->unk40C0); + gMain.state++; + break; + case 16: + sub_81C4190(); + sub_81C42C8(); + gUnknown_0203CF1C->unk40F0 = 0; + gMain.state++; + break; + case 17: + gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &gUnknown_0203CF1C->unk40F0); + if (gUnknown_0203CF1C->unk40D3 != 0xFF) + { + gUnknown_0203CF1C->unk40F0 = 0; + gMain.state++; + } + break; + case 18: + sub_81C4984(&gUnknown_0203CF1C->currentMon); + gMain.state++; + break; + case 19: + sub_81C4A08(&gUnknown_0203CF1C->currentMon); + gMain.state++; + break; + case 20: + sub_81C4A88(); + gMain.state++; + break; + case 21: + sub_81C4280(); + gMain.state++; + break; + case 22: + if (gUnknown_0203CF1C->unk40BC != 3) + CreateTask(sub_81C0510, 0); + else + CreateTask(sub_81C171C, 0); + gMain.state++; + break; + case 23: + BlendPalettes(-1, 16, 0); + gMain.state++; + break; + case 24: + BeginNormalPaletteFade(-1, 0, 16, 0, 0); + gPaletteFade.bufferTransferDisabled = 0; + gMain.state++; + break; + default: + SetVBlankCallback(sub_81BFAD0); + SetMainCallback2(sub_81BFAB4); + return TRUE; + } + return FALSE; +} + +void sub_81BFE24() +{ + ResetBgsAndClearDma3BusyFlags(0); + InitBgsFromTemplates(0, &gUnknown_0861CBB4, 4); + SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap2); + SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap1); + SetBgTilemapBuffer(3, &gUnknown_0203CF1C->unkTilemap0); + sub_8121E10(); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + schedule_bg_copy_tilemap_to_vram(3); + SetGpuReg(REG_OFFSET_DISPCNT, 0x1040); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + ShowBg(0); + ShowBg(1); + ShowBg(2); + ShowBg(3); +} + +u8 sub_81BFEB0() +{ + switch (gUnknown_0203CF1C->unk40F0) + { + case 0: + reset_temp_tile_data_buffers(); + decompress_and_copy_tile_data_to_vram(1, &gUnknown_08D97D0C, 0, 0, 0); + gUnknown_0203CF1C->unk40F0++; + break; + case 1: + if (free_temp_tile_data_buffers_if_possible() != 1) + { + LZDecompressWram(&gUnknown_08D9862C, gUnknown_0203CF1C->unkTilemap0); + gUnknown_0203CF1C->unk40F0++; + } + break; + case 2: + LZDecompressWram(&gUnknown_08D98CC8, gUnknown_0203CF1C->unkTilemap0_1); + gUnknown_0203CF1C->unk40F0++; + break; + case 3: + LZDecompressWram(&gUnknown_08D987FC, gUnknown_0203CF1C->unkTilemap1_1); + gUnknown_0203CF1C->unk40F0++; + break; + case 4: + LZDecompressWram(&gUnknown_08D9898C, gUnknown_0203CF1C->unkTilemap2_1); + gUnknown_0203CF1C->unk40F0++; + break; + case 5: + LZDecompressWram(&gUnknown_08D98B28, gUnknown_0203CF1C->unkTilemap3_1); + gUnknown_0203CF1C->unk40F0++; + break; + case 6: + LoadCompressedPalette(&gUnknown_08D9853C, 0, 0x100); + LoadPalette(&gUnknown_08D85620, 0x81, 0x1E); + gUnknown_0203CF1C->unk40F0++; + break; + case 7: + LoadCompressedObjectPic(&gUnknown_0861CFBC); + gUnknown_0203CF1C->unk40F0++; + break; + case 8: + LoadCompressedObjectPic(&gUnknown_0861D074); + gUnknown_0203CF1C->unk40F0++; + break; + case 9: + LoadCompressedObjectPic(&gUnknown_0861D0F8); + gUnknown_0203CF1C->unk40F0++; + break; + case 10: + LoadCompressedObjectPalette(&gUnknown_0861D100); + gUnknown_0203CF1C->unk40F0++; + break; + case 11: + LoadCompressedObjectPalette(&gUnknown_0861D07C); + gUnknown_0203CF1C->unk40F0++; + break; + case 12: + LoadCompressedPalette(&gUnknown_08D97B84, 0x1D0, 0x60); + gUnknown_0203CF1C->unk40F0 = 0; + return 1; + } + return 0; +} + +void sub_81C0098(struct Pokemon *mon) +{ + if (gUnknown_0203CF1C->unk40BD == 0) + { + struct Pokemon *partyMon = gUnknown_0203CF1C->unk0->mon; + *mon = partyMon[gUnknown_0203CF1C->unk40BE]; + } + else + { + struct BoxPokemon *boxMon = gUnknown_0203CF1C->unk0->boxMon; + sub_8069004(&boxMon[gUnknown_0203CF1C->unk40BE], mon); + } +} + +bool8 sub_81C00F0(struct Pokemon *a) +{ + u32 i; + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + switch (gUnknown_0203CF1C->unk40F0) + { + case 0: + sum->species = GetMonData(a, MON_DATA_SPECIES); + sum->species2 = GetMonData(a, MON_DATA_SPECIES2); + sum->exp = GetMonData(a, MON_DATA_EXP); + sum->level = GetMonData(a, MON_DATA_LEVEL); + sum->altAbility = GetMonData(a, MON_DATA_ALT_ABILITY); + sum->item = GetMonData(a, MON_DATA_HELD_ITEM); + sum->pid = GetMonData(a, MON_DATA_PERSONALITY); + sum->sanity = GetMonData(a, MON_DATA_SANITY_BIT1); + if (sum->sanity != 0) + sum->isEgg = 1; + else + sum->isEgg = GetMonData(a, MON_DATA_IS_EGG); + break; + case 1: + for (i = 0; i < 4; i++) + { + sum->moves[i] = GetMonData(a, MON_DATA_MOVE1+i); + sum->pp[i] = GetMonData(a, MON_DATA_PP1+i); + } + sum->ppBonuses = GetMonData(a, MON_DATA_PP_BONUSES); + break; + case 2: + if ((struct Pokemon*)gUnknown_0203CF1C->unk0 == gPlayerParty || gUnknown_0203CF1C->unk40BC == 2 || gUnknown_0203CF1C->unk40EF == 1) + { + sum->nature = GetNature(a); + sum->currentHP = GetMonData(a, MON_DATA_HP); + sum->maxHP = GetMonData(a, MON_DATA_MAX_HP); + sum->atk = GetMonData(a, MON_DATA_ATK); + sum->def = GetMonData(a, MON_DATA_DEF); + sum->spatk = GetMonData(a, MON_DATA_SPATK); + sum->spdef = GetMonData(a, MON_DATA_SPDEF); + sum->speed = GetMonData(a, MON_DATA_SPD); + } + else + { + sum->nature = GetNature(a); + sum->currentHP = GetMonData(a, MON_DATA_HP); + sum->maxHP = GetMonData(a, MON_DATA_MAX_HP); + sum->atk = GetMonData(a, MON_DATA_ATK2); + sum->def = GetMonData(a, MON_DATA_DEF2); + sum->spatk = GetMonData(a, MON_DATA_SPATK2); + sum->spdef = GetMonData(a, MON_DATA_SPDEF2); + sum->speed = GetMonData(a, MON_DATA_SPD2); + } + break; + case 3: + GetMonData(a, MON_DATA_OT_NAME, &sum->OTName); + ConvertInternationalString((u8*)&sum->OTName, GetMonData(a, MON_DATA_LANGUAGE)); + sum->unk7 = sub_81B205C(a); + sum->OTGender = GetMonData(a, MON_DATA_OT_GENDER); + sum->OTID = GetMonData(a, MON_DATA_OT_ID); + sum->metLocation = GetMonData(a, MON_DATA_MET_LOCATION); + sum->metLevel = GetMonData(a, MON_DATA_MET_LEVEL); + sum->metGame = GetMonData(a, MON_DATA_MET_GAME); + sum->friendship = GetMonData(a, MON_DATA_FRIENDSHIP); + break; + default: + sum->ribbons = GetMonData(a, MON_DATA_RIBBON_COUNT); + return TRUE; + } + gUnknown_0203CF1C->unk40F0++; + return FALSE; +} + +void sub_81C0348(void) +{ + if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3) + { + sub_81C1DA4(0, 255); + sub_81C1EFC(0, 255, 0); + } + else + { + sub_81C240C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]); + sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0); + sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0); + SetBgTilemapBuffer(1, &gUnknown_0203CF1C->unkTilemap3); + SetBgTilemapBuffer(2, &gUnknown_0203CF1C->unkTilemap2); + ChangeBgX(2, 0x10000, 1); + ClearWindowTilemap(0x13); + ClearWindowTilemap(0xD); + } + if (gUnknown_0203CF1C->summary.unk7 == 0) + { + sub_81C2074(0, 0xFF); + } + else + { + if (gUnknown_0203CF1C->unk40C0 != 2 && gUnknown_0203CF1C->unk40C0 != 3) + PutWindowTilemap(0xD); + } + sub_81C2524(); + sub_81C2228(&gUnknown_0203CF1C->currentMon); +} + +void sub_81C0434() +{ + FreeAllWindowBuffers(); + Free(gUnknown_0203CF1C); +} + +void sub_81C044C(u8 taskId) +{ + BeginNormalPaletteFade(-1, 0, 0, 16, 0); + gTasks[taskId].func = sub_81C0484; +} + +void sub_81C0484(u8 taskId) +{ + if (sub_81221EC() != 1 && !gPaletteFade.active) + { + SetMainCallback2(gUnknown_0203CF1C->unk4); + gUnknown_0203CF20 = gUnknown_0203CF1C->unk40BE; + sub_81C4898(); + ResetSpriteData(); + FreeAllSpritePalettes(); + StopCryAndClearCrySongs(); + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + if (gMonSpritesGfxPtr == 0) + sub_806F47C(0); + sub_81C0434(); + DestroyTask(taskId); + } +} + +void sub_81C0510(u8 taskId) +{ + if (sub_81221EC() != 1 && !gPaletteFade.active) + { + if (gMain.newKeys & DPAD_UP) + { + sub_81C0604(taskId, -1); + } + else if (gMain.newKeys & DPAD_DOWN) + { + sub_81C0604(taskId, 1); + } + else if ((gMain.newKeys & DPAD_LEFT) || GetLRKeysState() == 1) + { + sub_81C0A8C(taskId, -1); + } + else if ((gMain.newKeys & DPAD_RIGHT) || GetLRKeysState() == 2) + { + sub_81C0A8C(taskId, 1); + } + else if (gMain.newKeys & A_BUTTON) + { + if (gUnknown_0203CF1C->unk40C0 != 1) + { + if (gUnknown_0203CF1C->unk40C0 == 0) + { + sub_81C48F0(); + PlaySE(SE_SELECT); + sub_81C044C(taskId); + } + else + { + PlaySE(SE_SELECT); + sub_81C0E48(taskId); + } + } + } + else if (gMain.newKeys & B_BUTTON) + { + sub_81C48F0(); + PlaySE(SE_SELECT); + sub_81C044C(taskId); + } + } +} + +void sub_81C0604(u8 taskId, s8 a) +{ + s8 r4_2; + + if (gUnknown_0203CF1C->unk40C3 == 0) + { + if (gUnknown_0203CF1C->unk40BD == 1) + { + if (gUnknown_0203CF1C->unk40C0 != 0) + { + if (a == 1) + a = 0; + else + a = 2; + } + else + { + if (a == 1) + a = 1; + else + a = 3; + } + r4_2 = sub_80D214C(gUnknown_0203CF1C->unk0, gUnknown_0203CF1C->unk40BE, gUnknown_0203CF1C->unk40BF, a); + } + else if (sub_81B1250() == 1) + { + r4_2 = sub_81C09B4(a); + } + else + { + r4_2 = sub_81C08F8(a); + } + + if (r4_2 != -1) + { + PlaySE(SE_SELECT); + if (gUnknown_0203CF1C->summary.unk7 != 0) + { + sub_81C4204(2, 1); + ClearWindowTilemap(0xD); + schedule_bg_copy_tilemap_to_vram(0); + sub_81C2074(0, 2); + } + gUnknown_0203CF1C->unk40BE = r4_2; + gTasks[taskId].data[0] = 0; + gTasks[taskId].func = sub_81C0704; + } + } +} + +void sub_81C0704(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + switch (data[0]) + { + case 0: + StopCryAndClearCrySongs(); + break; + case 1: + sub_81C4898(); + DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D3]); + break; + case 2: + DestroySpriteAndFreeResources(&gSprites[gUnknown_0203CF1C->unk40D4]); + break; + case 3: + sub_81C0098(&gUnknown_0203CF1C->currentMon); + gUnknown_0203CF1C->unk40F0 = 0; + break; + case 4: + if (sub_81C00F0(&gUnknown_0203CF1C->currentMon) == FALSE) + return; + break; + case 5: + sub_81C49E0(&gUnknown_0203CF1C->currentMon); + break; + case 6: + sub_81C4A08(&gUnknown_0203CF1C->currentMon); + break; + case 7: + if (gUnknown_0203CF1C->summary.unk7) + sub_81C2074(10, -2); + sub_81C2228(&gUnknown_0203CF1C->currentMon); + data[1] = 0; + break; + case 8: + gUnknown_0203CF1C->unk40D3 = sub_81C45F4(&gUnknown_0203CF1C->currentMon, &data[1]); + if (gUnknown_0203CF1C->unk40D3 == 0xFF) + return; + gSprites[gUnknown_0203CF1C->unk40D3].data2 = 1; + sub_81C0E24(); + data[1] = 0; + break; + case 9: + sub_81C4280(); + break; + case 10: + sub_81C25E8(); + break; + case 11: + sub_81C2D9C(gUnknown_0203CF1C->unk40C0); + sub_81C2524(); + break; + case 12: + gSprites[gUnknown_0203CF1C->unk40D3].data2 = 0; + break; + default: + if (sub_81221EC() == 0 && FuncIsActiveTask(sub_81C20F0) == 0) + { + data[0] = 0; + gTasks[taskId].func = sub_81C0510; + } + return; + } + data[0]++; +} + +s8 sub_81C08F8(s8 a) +{ + struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon; + + if (gUnknown_0203CF1C->unk40C0 == 0) + { + if (a == -1 && gUnknown_0203CF1C->unk40BE == 0) + return -1; + if (a == 1 && gUnknown_0203CF1C->unk40BE >= gUnknown_0203CF1C->unk40BF) + return -1; + return gUnknown_0203CF1C->unk40BE + a; + } + else + { + s8 index = gUnknown_0203CF1C->unk40BE; + + do + { + index += a; + if (index < 0 || index > gUnknown_0203CF1C->unk40BF) + return -1; + } while (GetMonData(&mon[index], MON_DATA_IS_EGG) != 0); + return index; + } +} + +s8 sub_81C09B4(s8 a) +{ + struct Pokemon *mon = gUnknown_0203CF1C->unk0->mon; + s8 r5 = 0; + u8 i; + + for (i = 0; i < 6; i++) + { + if (gUnknown_0861CC1C[i] == gUnknown_0203CF1C->unk40BE) + { + r5 = i; + break; + } + } + + while (1) + { + int b; + s8* c = &gUnknown_0861CC1C[0]; + + r5 += a; + if (r5 < 0 || r5 >= 6) + return -1; + b = c[r5]; + if (sub_81C0A50(&mon[b]) == TRUE) + return b; + } +} + +bool8 sub_81C0A50(struct Pokemon* mon) +{ + if (GetMonData(mon, MON_DATA_SPECIES) == 0) + return FALSE; + else if (gUnknown_0203CF1C->unk40BE != 0 || GetMonData(mon, MON_DATA_IS_EGG) == 0) + return TRUE; + else + return FALSE; +} + +void sub_81C0A8C(u8 taskId, s8 b) +{ + struct PokeSummary *summary = &gUnknown_0203CF1C->summary; + s16 *data = gTasks[taskId].data; + + if (summary->isEgg) + return; + if (b == -1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C1) + return; + if (b == 1 && gUnknown_0203CF1C->unk40C0 == gUnknown_0203CF1C->unk40C2) + return; + PlaySE(SE_SELECT); + sub_81C2C38(gUnknown_0203CF1C->unk40C0); + gUnknown_0203CF1C->unk40C0 += b; + data[0] = 0; + if (b == 1) + SetTaskFuncWithFollowupFunc(taskId, sub_81C0B8C, gTasks[taskId].func); + else + SetTaskFuncWithFollowupFunc(taskId, sub_81C0CC4, gTasks[taskId].func); + sub_81C2DE4(gUnknown_0203CF1C->unk40C0); + sub_81C424C(); +} + +void sub_81C0B8C(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + if (data[0] == 0) + { + if (gUnknown_0203CF1C->unk40C9 == 0) + { + data[1] = 1; + SetBgAttribute(1, 7, 1); + SetBgAttribute(2, 7, 2); + schedule_bg_copy_tilemap_to_vram(1); + } + else + { + data[1] = 2; + SetBgAttribute(2, 7, 1); + SetBgAttribute(1, 7, 2); + schedule_bg_copy_tilemap_to_vram(2); + } + ChangeBgX(data[1], 0, 0); + SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xBC)); + ShowBg(1); + ShowBg(2); + } + ChangeBgX(data[1], 0x2000, 1); + data[0] += 32; + if (data[0] > 0xFF) + gTasks[taskId].func = sub_81C0C68; +} + +void sub_81C0C68(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + gUnknown_0203CF1C->unk40C9 ^= 1; + data[1] = 0; + data[0] = 0; + sub_81C1BA0(); + sub_81C2AFC(gUnknown_0203CF1C->unk40C0); + sub_81C4280(); + sub_81C0E24(); + SwitchTaskToFollowupFunc(taskId); +} + +void sub_81C0CC4(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + if (data[0] == 0) + { + if (gUnknown_0203CF1C->unk40C9 == 0) + data[1] = 2; + else + data[1] = 1; + ChangeBgX(data[1], 0x10000, 0); + } + ChangeBgX(data[1], 0x2000, 2); + data[0] += 32; + if (data[0] > 0xFF) + gTasks[taskId].func = sub_81C0D44; +} + +void sub_81C0D44(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + if (gUnknown_0203CF1C->unk40C9 == 0) + { + SetBgAttribute(1, 7, 1); + SetBgAttribute(2, 7, 2); + schedule_bg_copy_tilemap_to_vram(2); + } + else + { + SetBgAttribute(2, 7, 1); + SetBgAttribute(1, 7, 2); + schedule_bg_copy_tilemap_to_vram(1); + } + if (gUnknown_0203CF1C->unk40C0 > 1) + { + SetBgTilemapBuffer(data[1], (u8*)gUnknown_0203CF1C + ((gUnknown_0203CF1C->unk40C0 << 12) + 0xFFFFF0BC)); + ChangeBgX(data[1], 0x10000, 0); + } + ShowBg(1); + ShowBg(2); + gUnknown_0203CF1C->unk40C9 ^= 1; + data[1] = 0; + data[0] = 0; + sub_81C1BA0(); + sub_81C2AFC(gUnknown_0203CF1C->unk40C0); + sub_81C4280(); + sub_81C0E24(); + SwitchTaskToFollowupFunc(taskId); +} + +void sub_81C0E24() +{ + if (gUnknown_0203CF1C->unk40C0 == 1) + sub_81C22CC(&gUnknown_0203CF1C->currentMon); +} + +void sub_81C0E48(u8 taskId) +{ + u16 move; + gUnknown_0203CF1C->unk40C6 = 0; + move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + ClearWindowTilemap(0x13); + if (gSprites[gUnknown_0203CF1C->unk40D5].invisible == 0) + ClearWindowTilemap(0xD); + sub_81C1DA4(9, -3); + sub_81C1EFC(9, -3, move); + if (gUnknown_0203CF1C->unk40C8 == 0) + { + ClearWindowTilemap(5); + PutWindowTilemap(6); + } + sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 0); + sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 0); + sub_81C3E9C(move); + sub_81C3F44(); + sub_81C44F0(); + schedule_bg_copy_tilemap_to_vram(0); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + sub_81C4AF8(8); + gTasks[taskId].func = sub_81C0F44; +} + +void sub_81C0F44(u8 taskId) +{ + u8 id = taskId; + s16 *data = gTasks[taskId].data; + + if (sub_81221EC() != 1) + { + if (gMain.newKeys & DPAD_UP) + { + data[0] = 4; + sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6); + } + else if (gMain.newKeys & DPAD_DOWN) + { + data[0] = 4; + sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6); + } + else if (gMain.newKeys & A_BUTTON) + { + if (gUnknown_0203CF1C->unk40C8 == 1 + || (gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + { + PlaySE(SE_SELECT); + sub_81C11F4(taskId); + } + else if (sub_81C1040() == TRUE) + { + PlaySE(SE_SELECT); + sub_81C129C(taskId); + } + else + { + PlaySE(SE_HAZURE); + } + } + else if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + sub_81C11F4(id); + } + } +} + +bool8 sub_81C1040(void) +{ + u8 i; + for (i = 1; i < 4; i++) + { + if (gUnknown_0203CF1C->summary.moves[i] != 0) + return TRUE; + } + return FALSE; +} + +void sub_81C1070(s16 *a, s8 b, u8 *c) +{ + s8 i; + s8 moveIndex; + u16 move; + + PlaySE(SE_SELECT); + moveIndex = *c; + for (i = 0; i < 4; i++) + { + moveIndex += b; + if (moveIndex > a[0]) + moveIndex = 0; + else if (moveIndex < 0) + moveIndex = a[0]; + if (moveIndex == 4) + { + move = gUnknown_0203CF1C->unk40C4; + break; + } + move = gUnknown_0203CF1C->summary.moves[moveIndex]; + if (move != 0) + break; + } + sub_81C240C(move); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + sub_81C3E9C(move); + if ((*c == 4 && gUnknown_0203CF1C->unk40C4 == 0) || a[1] == 1) + { + ClearWindowTilemap(19); + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + ClearWindowTilemap(13); + schedule_bg_copy_tilemap_to_vram(0); + sub_81C1DA4(9, -3); + sub_81C1EFC(9, -3, move); + } + if (*c != 4 && moveIndex == 4 && gUnknown_0203CF1C->unk40C4 == 0) + { + ClearWindowTilemap(14); + ClearWindowTilemap(15); + schedule_bg_copy_tilemap_to_vram(0); + sub_81C1DA4(0, 3); + sub_81C1EFC(0, 3, 0); + } + *c = moveIndex; + if (c == &gUnknown_0203CF1C->unk40C6) + sub_81C4D18(8); + else + sub_81C4D18(18); +} + +void sub_81C11F4(u8 taskId) +{ + sub_81C4C60(8); + ClearWindowTilemap(6); + PutWindowTilemap(5); + sub_81C3E9C(0); + sub_81C2194(&gUnknown_0203CF1C->unkTilemap2[0], 3, 1); + sub_81C2194(&gUnknown_0203CF1C->unkTilemap3[0], 1, 1); + sub_81C4064(); + if (gUnknown_0203CF1C->unk40C6 != 4) + { + ClearWindowTilemap(14); + ClearWindowTilemap(15); + sub_81C1DA4(0, 3); + sub_81C1EFC(0, 3, 0); + } + schedule_bg_copy_tilemap_to_vram(0); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + gTasks[taskId].func = sub_81C0510; +} + +void sub_81C129C(u8 taskId) +{ + gUnknown_0203CF1C->unk40C7 = gUnknown_0203CF1C->unk40C6; + sub_81C4C84(1); + sub_81C4AF8(18); + gTasks[taskId].func = sub_81C12E4; +} + +void sub_81C12E4(u8 taskId) +{ + u8 a = taskId; + s16* data = gTasks[taskId].data; + if (sub_81221EC() != 1) + { + if (gMain.newKeys & DPAD_UP) + { + data[0] = 3; + sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C7); + } + else if (gMain.newKeys & DPAD_DOWN) + { + data[0] = 3; + sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C7); + } + else if (gMain.newKeys & A_BUTTON) + { + if (gUnknown_0203CF1C->unk40C6 == gUnknown_0203CF1C->unk40C7) + { + sub_81C13B0(taskId, 0); + } + else + sub_81C13B0(taskId, 1); + } + else if (gMain.newKeys & B_BUTTON) + sub_81C13B0(a, 0); + } +} + +void sub_81C13B0(u8 taskId, u8 b) +{ + u16 move; + PlaySE(SE_SELECT); + sub_81C4C84(0); + sub_81C4C60(18); + if (b == 1) + { + if (gUnknown_0203CF1C->unk40BD == 0) + { + struct Pokemon *why = gUnknown_0203CF1C->unk0->mon; + sub_81C14BC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); + } + else + { + struct BoxPokemon *why = gUnknown_0203CF1C->unk0->boxMon; + sub_81C15EC(&why[gUnknown_0203CF1C->unk40BE], gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); + } + sub_81C0098(&gUnknown_0203CF1C->currentMon); + sub_81C40A0(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); + sub_81C4568(gUnknown_0203CF1C->unk40C6, gUnknown_0203CF1C->unk40C7); + gUnknown_0203CF1C->unk40C6 = gUnknown_0203CF1C->unk40C7; + } + move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + sub_81C3E9C(move); + sub_81C240C(move); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + gTasks[taskId].func = sub_81C0F44; +} + + +#ifdef NONMATCHING +void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId) +{ + u16 localMoveTo; + u16 localMoveFrom; + u8 localPpTo; + u8 localPpFrom; + u8 localPpBonuses; + u16* moveFromPtr; + u16* moveToPtr; + u8* ppFromPtr; + u8* ppToPtr; + u8* ppBonusesPtr; + + moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId]; + localMoveFrom = *moveFromPtr; + + moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId]; + localMoveTo = *moveToPtr; + + ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId]; + localPpFrom = *ppFromPtr; + + ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId]; + localPpTo = *ppToPtr; + + ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses; + localPpBonuses = *ppBonusesPtr; + +{ + u8 bitsFrom, bitsTo; + + bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1); + bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1); + + + localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]); + localPpBonuses &= ~(gUnknown_08329D22[swappingToId]); + + localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1))); +} + + SetMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo); + SetMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom); + + SetMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo); + SetMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom); + + SetMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses); + + *moveFromPtr = localMoveTo; + *moveToPtr = localMoveFrom; + + *ppFromPtr = localPpTo; + *ppToPtr = localPpFrom; + + *ppBonusesPtr = localPpBonuses; +} +#else +__attribute__((naked)) +void sub_81C14BC(struct Pokemon *mon, u8 swappingFromId, u8 swappingToId) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x28\n\ + adds r7, r0, 0\n\ + adds r4, r1, 0\n\ + adds r6, r2, 0\n\ + lsls r4, 24\n\ + lsrs r4, 24\n\ + lsls r6, 24\n\ + lsrs r6, 24\n\ + ldr r0, =gUnknown_0203CF1C\n\ + ldr r2, [r0]\n\ + lsls r0, r4, 1\n\ + mov r10, r0\n\ + adds r1, r2, 0\n\ + adds r1, 0x84\n\ + adds r0, r1, r0\n\ + str r0, [sp, 0x8]\n\ + ldrh r0, [r0]\n\ + mov r3, sp\n\ + adds r3, 0x2\n\ + str r3, [sp, 0x1C]\n\ + strh r0, [r3]\n\ + lsls r0, r6, 1\n\ + mov r9, r0\n\ + add r1, r9\n\ + str r1, [sp, 0xC]\n\ + ldrh r1, [r1]\n\ + mov r0, sp\n\ + strh r1, [r0]\n\ + adds r1, r2, 0\n\ + adds r1, 0x8C\n\ + adds r3, r1, r4\n\ + str r3, [sp, 0x10]\n\ + ldrb r0, [r3]\n\ + mov r3, sp\n\ + adds r3, 0x5\n\ + str r3, [sp, 0x24]\n\ + strb r0, [r3]\n\ + adds r1, r6\n\ + str r1, [sp, 0x14]\n\ + ldrb r0, [r1]\n\ + mov r1, sp\n\ + adds r1, 0x4\n\ + str r1, [sp, 0x20]\n\ + strb r0, [r1]\n\ + adds r2, 0xA4\n\ + str r2, [sp, 0x18]\n\ + ldrb r0, [r2]\n\ + mov r5, sp\n\ + adds r5, 0x6\n\ + strb r0, [r5]\n\ + ldr r1, =gUnknown_08329D22\n\ + adds r0, r4, r1\n\ + ldrb r0, [r0]\n\ + mov r8, r0\n\ + ldrb r0, [r5]\n\ + adds r2, r0, 0\n\ + mov r3, r8\n\ + ands r2, r3\n\ + mov r3, r10\n\ + asrs r2, r3\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + adds r1, r6, r1\n\ + ldrb r1, [r1]\n\ + mov r12, r1\n\ + adds r1, r0, 0\n\ + mov r3, r12\n\ + ands r1, r3\n\ + mov r3, r9\n\ + asrs r1, r3\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + mov r3, r8\n\ + bics r0, r3\n\ + strb r0, [r5]\n\ + ldrb r0, [r5]\n\ + mov r3, r12\n\ + bics r0, r3\n\ + strb r0, [r5]\n\ + mov r0, r9\n\ + lsls r2, r0\n\ + mov r3, r10\n\ + lsls r1, r3\n\ + adds r2, r1\n\ + ldrb r0, [r5]\n\ + orrs r0, r2\n\ + strb r0, [r5]\n\ + adds r1, r4, 0\n\ + adds r1, 0xD\n\ + adds r0, r7, 0\n\ + mov r2, sp\n\ + bl SetMonData\n\ + adds r1, r6, 0\n\ + adds r1, 0xD\n\ + adds r0, r7, 0\n\ + ldr r2, [sp, 0x1C]\n\ + bl SetMonData\n\ + adds r4, 0x11\n\ + adds r0, r7, 0\n\ + adds r1, r4, 0\n\ + ldr r2, [sp, 0x20]\n\ + bl SetMonData\n\ + adds r6, 0x11\n\ + adds r0, r7, 0\n\ + adds r1, r6, 0\n\ + ldr r2, [sp, 0x24]\n\ + bl SetMonData\n\ + adds r0, r7, 0\n\ + movs r1, 0x15\n\ + adds r2, r5, 0\n\ + bl SetMonData\n\ + mov r0, sp\n\ + ldrh r0, [r0]\n\ + ldr r1, [sp, 0x8]\n\ + strh r0, [r1]\n\ + ldr r3, [sp, 0x1C]\n\ + ldrh r0, [r3]\n\ + ldr r1, [sp, 0xC]\n\ + strh r0, [r1]\n\ + ldr r3, [sp, 0x20]\n\ + ldrb r0, [r3]\n\ + ldr r1, [sp, 0x10]\n\ + strb r0, [r1]\n\ + ldr r3, [sp, 0x24]\n\ + ldrb r0, [r3]\n\ + ldr r1, [sp, 0x14]\n\ + strb r0, [r1]\n\ + ldrb r0, [r5]\n\ + ldr r3, [sp, 0x18]\n\ + strb r0, [r3]\n\ + add sp, 0x28\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +#ifdef NONMATCHING +void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId) +{ + u16 localMoveTo; + u16 localMoveFrom; + u8 localPpTo; + u8 localPpFrom; + u8 localPpBonuses; + u16* moveFromPtr; + u16* moveToPtr; + u8* ppFromPtr; + u8* ppToPtr; + u8* ppBonusesPtr; + + moveFromPtr = &gUnknown_0203CF1C->summary.moves[swappingFromId]; + localMoveFrom = *moveFromPtr; + + moveToPtr = &gUnknown_0203CF1C->summary.moves[swappingToId]; + localMoveTo = *moveToPtr; + + ppFromPtr = &gUnknown_0203CF1C->summary.pp[swappingFromId]; + localPpFrom = *ppFromPtr; + + ppToPtr = &gUnknown_0203CF1C->summary.pp[swappingToId]; + localPpTo = *ppToPtr; + + ppBonusesPtr = &gUnknown_0203CF1C->summary.ppBonuses; + localPpBonuses = *ppBonusesPtr; + +{ + u8 bitsFrom, bitsTo; + + bitsFrom = (localPpBonuses & gUnknown_08329D22[swappingFromId]) >> (swappingFromId << 1); + bitsTo = (localPpBonuses & gUnknown_08329D22[swappingToId]) >> (swappingToId << 1); + + + localPpBonuses &= ~(gUnknown_08329D22[swappingFromId]); + localPpBonuses &= ~(gUnknown_08329D22[swappingToId]); + + localPpBonuses |= ((bitsFrom << (swappingToId << 1)) + (bitsTo << (swappingToId << 1))); +} + + SetBoxMonData(mon, swappingFromId + MON_DATA_MOVE1, &localMoveTo); + SetBoxMonData(mon, swappingToId + MON_DATA_MOVE1, &localMoveFrom); + + SetBoxMonData(mon, swappingFromId + MON_DATA_PP1, &localPpTo); + SetBoxMonData(mon, swappingToId + MON_DATA_PP1, &localPpFrom); + + SetBoxMonData(mon, MON_DATA_PP_BONUSES, &localPpBonuses); + + *moveFromPtr = localMoveTo; + *moveToPtr = localMoveFrom; + + *ppFromPtr = localPpTo; + *ppToPtr = localPpFrom; + + *ppBonusesPtr = localPpBonuses; +} +#else +__attribute__((naked)) +void sub_81C15EC(struct BoxPokemon *mon, u8 swappingFromId, u8 swappingToId) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x28\n\ + adds r7, r0, 0\n\ + adds r4, r1, 0\n\ + adds r6, r2, 0\n\ + lsls r4, 24\n\ + lsrs r4, 24\n\ + lsls r6, 24\n\ + lsrs r6, 24\n\ + ldr r0, =gUnknown_0203CF1C\n\ + ldr r2, [r0]\n\ + lsls r0, r4, 1\n\ + mov r10, r0\n\ + adds r1, r2, 0\n\ + adds r1, 0x84\n\ + adds r0, r1, r0\n\ + str r0, [sp, 0x8]\n\ + ldrh r0, [r0]\n\ + mov r3, sp\n\ + adds r3, 0x2\n\ + str r3, [sp, 0x1C]\n\ + strh r0, [r3]\n\ + lsls r0, r6, 1\n\ + mov r9, r0\n\ + add r1, r9\n\ + str r1, [sp, 0xC]\n\ + ldrh r1, [r1]\n\ + mov r0, sp\n\ + strh r1, [r0]\n\ + adds r1, r2, 0\n\ + adds r1, 0x8C\n\ + adds r3, r1, r4\n\ + str r3, [sp, 0x10]\n\ + ldrb r0, [r3]\n\ + mov r3, sp\n\ + adds r3, 0x5\n\ + str r3, [sp, 0x24]\n\ + strb r0, [r3]\n\ + adds r1, r6\n\ + str r1, [sp, 0x14]\n\ + ldrb r0, [r1]\n\ + mov r1, sp\n\ + adds r1, 0x4\n\ + str r1, [sp, 0x20]\n\ + strb r0, [r1]\n\ + adds r2, 0xA4\n\ + str r2, [sp, 0x18]\n\ + ldrb r0, [r2]\n\ + mov r5, sp\n\ + adds r5, 0x6\n\ + strb r0, [r5]\n\ + ldr r1, =gUnknown_08329D22\n\ + adds r0, r4, r1\n\ + ldrb r0, [r0]\n\ + mov r8, r0\n\ + ldrb r0, [r5]\n\ + adds r2, r0, 0\n\ + mov r3, r8\n\ + ands r2, r3\n\ + mov r3, r10\n\ + asrs r2, r3\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + adds r1, r6, r1\n\ + ldrb r1, [r1]\n\ + mov r12, r1\n\ + adds r1, r0, 0\n\ + mov r3, r12\n\ + ands r1, r3\n\ + mov r3, r9\n\ + asrs r1, r3\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + mov r3, r8\n\ + bics r0, r3\n\ + strb r0, [r5]\n\ + ldrb r0, [r5]\n\ + mov r3, r12\n\ + bics r0, r3\n\ + strb r0, [r5]\n\ + mov r0, r9\n\ + lsls r2, r0\n\ + mov r3, r10\n\ + lsls r1, r3\n\ + adds r2, r1\n\ + ldrb r0, [r5]\n\ + orrs r0, r2\n\ + strb r0, [r5]\n\ + adds r1, r4, 0\n\ + adds r1, 0xD\n\ + adds r0, r7, 0\n\ + mov r2, sp\n\ + bl SetBoxMonData\n\ + adds r1, r6, 0\n\ + adds r1, 0xD\n\ + adds r0, r7, 0\n\ + ldr r2, [sp, 0x1C]\n\ + bl SetBoxMonData\n\ + adds r4, 0x11\n\ + adds r0, r7, 0\n\ + adds r1, r4, 0\n\ + ldr r2, [sp, 0x20]\n\ + bl SetBoxMonData\n\ + adds r6, 0x11\n\ + adds r0, r7, 0\n\ + adds r1, r6, 0\n\ + ldr r2, [sp, 0x24]\n\ + bl SetBoxMonData\n\ + adds r0, r7, 0\n\ + movs r1, 0x15\n\ + adds r2, r5, 0\n\ + bl SetBoxMonData\n\ + mov r0, sp\n\ + ldrh r0, [r0]\n\ + ldr r1, [sp, 0x8]\n\ + strh r0, [r1]\n\ + ldr r3, [sp, 0x1C]\n\ + ldrh r0, [r3]\n\ + ldr r1, [sp, 0xC]\n\ + strh r0, [r1]\n\ + ldr r3, [sp, 0x20]\n\ + ldrb r0, [r3]\n\ + ldr r1, [sp, 0x10]\n\ + strb r0, [r1]\n\ + ldr r3, [sp, 0x24]\n\ + ldrb r0, [r3]\n\ + ldr r1, [sp, 0x14]\n\ + strb r0, [r1]\n\ + ldrb r0, [r5]\n\ + ldr r3, [sp, 0x18]\n\ + strb r0, [r3]\n\ + add sp, 0x28\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +void sub_81C171C(u8 taskId) +{ + sub_81C44F0(); + sub_81C4AF8(8); + gTasks[taskId].func = sub_81C174C; +} + +void sub_81C174C(u8 taskId) +{ + s16* data = gTasks[taskId].data; + + if (sub_81221EC() != 1) + { + if (gPaletteFade.active != 1) + { + if (gMain.newKeys & DPAD_UP) + { + data[0] = 4; + sub_81C1070(data, -1, &gUnknown_0203CF1C->unk40C6); + } + else if (gMain.newKeys & DPAD_DOWN) + { + data[0] = 4; + sub_81C1070(data, 1, &gUnknown_0203CF1C->unk40C6); + } + else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1) + { + sub_81C0A8C(taskId, -1); + } + else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2) + { + sub_81C0A8C(taskId, 1); + } + else if (gMain.newKeys & A_BUTTON) + { + if (sub_81C18A8() == TRUE) + { + sub_81C48F0(); + PlaySE(SE_SELECT); + gUnknown_0203CF21 = gUnknown_0203CF1C->unk40C6; + gSpecialVar_0x8005 = gUnknown_0203CF21; + sub_81C044C(taskId); + } + else + { + PlaySE(0x20); + sub_81C18F4(taskId); + } + } + else if (gMain.newKeys & B_BUTTON) + { + u32 var1; + sub_81C48F0(); + PlaySE(SE_SELECT); + gUnknown_0203CF21 = 4; + gSpecialVar_0x8005 = 4; + sub_81C044C(taskId); + } + } + } +} + +bool8 sub_81C18A8() +{ + if (gUnknown_0203CF1C->unk40C6 == 4 || gUnknown_0203CF1C->unk40C4 == 0 || sub_81B6D14(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]) != 1) + return TRUE; + else + return FALSE; +} + +void sub_81C18F4(u8 taskId) +{ + ClearWindowTilemap(14); + ClearWindowTilemap(15); + schedule_bg_copy_tilemap_to_vram(0); + sub_81C1DA4(0, 3); + sub_81C1EFC(0, 3, 0); + sub_81C4154(); + gTasks[taskId].func = sub_81C1940; +} + +void sub_81C1940(u8 taskId) +{ + s16* data = gTasks[taskId].data; + u16 move; + if (FuncIsActiveTask(sub_81C1E20) != 1) + { + if (gMain.newKeys & DPAD_UP) + { + data[1] = 1; + data[0] = 4; + sub_81C1070(&data[0], -1, &gUnknown_0203CF1C->unk40C6); + data[1] = 0; + gTasks[taskId].func = sub_81C174C; + } + else if (gMain.newKeys & DPAD_DOWN) + { + data[1] = 1; + data[0] = 4; + sub_81C1070(&data[0], 1, &gUnknown_0203CF1C->unk40C6); + data[1] = 0; + gTasks[taskId].func = sub_81C174C; + } + else if (gMain.newKeys & DPAD_LEFT || GetLRKeysState() == 1) + { + if (gUnknown_0203CF1C->unk40C0 != 2) + { + + ClearWindowTilemap(19); + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + ClearWindowTilemap(13); + move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + gTasks[taskId].func = sub_81C174C; + sub_81C0A8C(taskId, -1); + sub_81C1DA4(9, -2); + sub_81C1EFC(9, -2, move); + } + } + else if (gMain.newKeys & DPAD_RIGHT || GetLRKeysState() == 2) + { + if (gUnknown_0203CF1C->unk40C0 != 3) + { + ClearWindowTilemap(19); + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + ClearWindowTilemap(13); + move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + gTasks[taskId].func = sub_81C174C; + sub_81C0A8C(taskId, 1); + sub_81C1DA4(9, -2); + sub_81C1EFC(9, -2, move); + } + } + else if (gMain.newKeys & (A_BUTTON | B_BUTTON)) + { + ClearWindowTilemap(19); + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + ClearWindowTilemap(13); + move = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + sub_81C3E9C(move); + schedule_bg_copy_tilemap_to_vram(0); + sub_81C1DA4(9, -3); + sub_81C1EFC(9, -3, move); + gTasks[taskId].func = sub_81C174C; + } + } +} + +u8 sub_81C1B94() +{ + return gUnknown_0203CF21; +} + +void sub_81C1BA0() +{ + u16 *alloced = Alloc(32); + u8 i; + for (i = 0; i < 4; i++) + { + u8 j = i << 1; + if (i < gUnknown_0203CF1C->unk40C1) + { + alloced[j+0] = 0x40; + alloced[j+1] = 0x40; + alloced[j+8] = 0x50; + alloced[j+9] = 0x50; + } + else if (i > gUnknown_0203CF1C->unk40C2) + { + alloced[j+0] = 0x4A; + alloced[j+1] = 0x4A; + alloced[j+8] = 0x5A; + alloced[j+9] = 0x5A; + } + else if (i < gUnknown_0203CF1C->unk40C0) + { + alloced[j+0] = 0x46; + alloced[j+1] = 0x47; + alloced[j+8] = 0x56; + alloced[j+9] = 0x57; + } + else if (i == gUnknown_0203CF1C->unk40C0) + { + if (i != gUnknown_0203CF1C->unk40C2) + { + alloced[j+0] = 0x41; + alloced[j+1] = 0x42; + alloced[j+8] = 0x51; + alloced[j+9] = 0x52; + } + else + { + alloced[j+0] = 0x4B; + alloced[j+1] = 0x4C; + alloced[j+8] = 0x5B; + alloced[j+9] = 0x5C; + } + } + else if (i != gUnknown_0203CF1C->unk40C2) + { + alloced[j+0] = 0x43; + alloced[j+1] = 0x44; + alloced[j+8] = 0x53; + alloced[j+9] = 0x54; + } + else + { + alloced[j+0] = 0x48; + alloced[j+1] = 0x49; + alloced[j+8] = 0x58; + alloced[j+9] = 0x59; + } + } + CopyToBgTilemapBufferRect_ChangePalette(3, alloced, 11, 0, 8, 2, 16); + schedule_bg_copy_tilemap_to_vram(3); + Free(alloced); +} + +struct UnkStruct_61CC04 +{ + u8 *ptr; + u8 field_4; + u8 field_5; + u8 field_6; + u8 field_7; + u8 field_8; + u8 field_9; +}; + +#ifdef NONMATCHING +void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d) +{ + u8 *alloced = Alloc(a->field_6 * (a->field_7 << 1)); + CpuFill16(a->field_4, alloced, a->field_7*a->field_6); + if (a->field_6 != c) + { + if (!d) + { + for (d;d < a->field_7; d++) + { + CpuCopy16(&a->ptr + ((c + a->field_6*d)), alloced + ((a->field_6*d) << 1), (a->field_6 - c) * 2); + } + } + else + { + for (d = 0;d < a->field_7; d++) + { + CpuCopy16(&a->ptr + (a->field_6*d), alloced + ((c + a->field_6*d) << 1), (a->field_6 - c) * 2); + } + } + } + d = 0; + while (d < a->field_7) + { + CpuCopy16(alloced + ((a->field_6*d) << 1), b + ((((a->field_9 + d) << 5) + a->field_8) << 1), a->field_6 * 2); + d++; + } + Free(alloced); +} +#else +__attribute__((naked)) +void sub_81C1CB0(struct UnkStruct_61CC04 *a, u16 *b, u8 c, u8 d) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r8\n\ + push {r7}\n\ + sub sp, 0x4\n\ + adds r4, r0, 0\n\ + mov r8, r1\n\ + lsls r2, 24\n\ + lsrs r6, r2, 24\n\ + lsls r3, 24\n\ + lsrs r5, r3, 24\n\ + ldrb r1, [r4, 0x6]\n\ + ldrb r0, [r4, 0x7]\n\ + lsls r0, 1\n\ + muls r0, r1\n\ + bl Alloc\n\ + adds r7, r0, 0\n\ + mov r1, sp\n\ + ldrh r0, [r4, 0x4]\n\ + strh r0, [r1]\n\ + ldrb r1, [r4, 0x7]\n\ + ldrb r0, [r4, 0x6]\n\ + adds r2, r1, 0\n\ + muls r2, r0\n\ + movs r0, 0x80\n\ + lsls r0, 17\n\ + orrs r2, r0\n\ + mov r0, sp\n\ + adds r1, r7, 0\n\ + bl CpuSet\n\ + ldrb r0, [r4, 0x6]\n\ + cmp r0, r6\n\ + beq _081C1D60\n\ + cmp r5, 0\n\ + bne _081C1D30\n\ + movs r5, 0\n\ + ldrb r0, [r4, 0x7]\n\ + cmp r5, r0\n\ + bcs _081C1D60\n\ +_081C1D00:\n\ + ldrb r2, [r4, 0x6]\n\ + adds r1, r2, 0\n\ + muls r1, r5\n\ + adds r3, r6, r1\n\ + lsls r3, 1\n\ + ldr r0, [r4]\n\ + adds r0, r3\n\ + lsls r1, 1\n\ + adds r1, r7, r1\n\ + subs r2, r6\n\ + ldr r3, =0x001fffff\n\ + ands r2, r3\n\ + bl CpuSet\n\ + adds r0, r5, 0x1\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ + ldrb r3, [r4, 0x7]\n\ + cmp r5, r3\n\ + bcc _081C1D00\n\ + b _081C1D60\n\ + .pool\n\ +_081C1D30:\n\ + movs r5, 0\n\ + ldrb r0, [r4, 0x7]\n\ + cmp r5, r0\n\ + bcs _081C1D60\n\ +_081C1D38:\n\ + ldrb r2, [r4, 0x6]\n\ + adds r1, r2, 0\n\ + muls r1, r5\n\ + lsls r3, r1, 1\n\ + ldr r0, [r4]\n\ + adds r0, r3\n\ + adds r1, r6, r1\n\ + lsls r1, 1\n\ + adds r1, r7, r1\n\ + subs r2, r6\n\ + ldr r3, =0x001fffff\n\ + ands r2, r3\n\ + bl CpuSet\n\ + adds r0, r5, 0x1\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ + ldrb r3, [r4, 0x7]\n\ + cmp r5, r3\n\ + bcc _081C1D38\n\ +_081C1D60:\n\ + movs r5, 0\n\ + b _081C1D8A\n\ + .pool\n\ +_081C1D68:\n\ + ldrb r2, [r4, 0x6]\n\ + adds r0, r2, 0\n\ + muls r0, r5\n\ + lsls r0, 1\n\ + adds r0, r7, r0\n\ + ldrb r1, [r4, 0x9]\n\ + adds r1, r5\n\ + lsls r1, 5\n\ + ldrb r3, [r4, 0x8]\n\ + adds r1, r3\n\ + lsls r1, 1\n\ + add r1, r8\n\ + bl CpuSet\n\ + adds r0, r5, 0x1\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ +_081C1D8A:\n\ + ldrb r0, [r4, 0x7]\n\ + cmp r5, r0\n\ + bcc _081C1D68\n\ + adds r0, r7, 0\n\ + bl Free\n\ + add sp, 0x4\n\ + pop {r3}\n\ + mov r8, r3\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .syntax divided\n"); +} +#endif + +void sub_81C1DA4(u16 a, s16 b) +{ + if (b > gUnknown_0861CC04.field_6) + b = gUnknown_0861CC04.field_6; + if (b == 0 || b == gUnknown_0861CC04.field_6) + { + sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], b, 1); + } + else + { + u8 taskId = FindTaskIdByFunc(sub_81C1E20); + if (taskId == 0xFF) + { + taskId = CreateTask(sub_81C1E20, 8); + } + gTasks[taskId].data[0] = b; + gTasks[taskId].data[1] = a; + } +} + +void sub_81C1E20(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + data[1] += data[0]; + if (data[1] < 0) + { + data[1] = 0; + } + else if (data[1] > gUnknown_0861CC04.field_6) + { + data[1] = gUnknown_0861CC04.field_6; + } + sub_81C1CB0(&gUnknown_0861CC04, &gUnknown_0203CF1C->unkTilemap2[0], data[1], 1); + if (data[1] <= 0 || data[1] >= gUnknown_0861CC04.field_6) + { + if (data[0] < 0) + { + if (gUnknown_0203CF1C->unk40C0 == 2) + PutWindowTilemap(14); + + } + else + { + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + PutWindowTilemap(13); + PutWindowTilemap(19); + } + schedule_bg_copy_tilemap_to_vram(0); + DestroyTask(taskId); + } + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); +} + +void sub_81C1EFC(u16 a, s16 b, u16 move) +{ + if (b > gUnknown_0861CC10.field_6) + b = gUnknown_0861CC10.field_6; + if (b == 0 || b == gUnknown_0861CC10.field_6) + sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], b, 1); + else + { + u8 taskId = FindTaskIdByFunc(sub_81C1F80); + if (taskId == 0xFF) + taskId = CreateTask(sub_81C1F80, 8); + gTasks[taskId].data[0] = b; + gTasks[taskId].data[1] = a; + gTasks[taskId].data[2] = move; + } +} + +void sub_81C1F80(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + data[1] += data[0]; + if (data[1] < 0) + { + data[1] = 0; + } + else if (data[1] > gUnknown_0861CC10.field_6) + { + data[1] = gUnknown_0861CC10.field_6; + } + sub_81C1CB0(&gUnknown_0861CC10, &gUnknown_0203CF1C->unkTilemap3[0], data[1], 1); + if (data[1] <= 0 || data[1] >= gUnknown_0861CC10.field_6) + { + if (data[0] < 0) + { + if (gUnknown_0203CF1C->unk40C0 == 3 && FuncIsActiveTask(sub_81C0B8C) == 0) + PutWindowTilemap(15); + sub_81C240C(data[2]); + } + else + { + if (!gSprites[gUnknown_0203CF1C->unk40D5].invisible) + { + PutWindowTilemap(13); + } + PutWindowTilemap(19); + } + schedule_bg_copy_tilemap_to_vram(0); + DestroyTask(taskId); + } + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); +} + +void sub_81C2074(u16 a, s16 b) +{ + if (b > gUnknown_0861CBEC.field_6) + b = gUnknown_0861CBEC.field_6; + if (b == 0 || b == gUnknown_0861CBEC.field_6) + { + sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], b, 0); + sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], b, 0); + } + else + { + u8 taskId = CreateTask(sub_81C20F0, 8); + gTasks[taskId].data[0] = b; + gTasks[taskId].data[1] = a; + } +} + +void sub_81C20F0(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + data[1] += data[0]; + if (data[1] < 0) + data[1] = 0; + else if (data[1] > gUnknown_0861CBEC.field_6) + data[1] = gUnknown_0861CBEC.field_6; + sub_81C1CB0(&gUnknown_0861CBEC, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0); + sub_81C1CB0(&gUnknown_0861CBF8, &gUnknown_0203CF1C->unkTilemap0[0], data[1], 0); + schedule_bg_copy_tilemap_to_vram(3); + if (data[1] <= 0 || data[1] >= gUnknown_0861CBEC.field_6) + { + if (data[0] < 0) + { + sub_81C4A88(); + PutWindowTilemap(13); + schedule_bg_copy_tilemap_to_vram(0); + } + DestroyTask(taskId); + } +} + +// somebody send help this is a complete fucking mess +#ifdef NONMATCHING +void sub_81C2194(u16 *a, u16 b, u8 c) +{ + u16 i; + int var; + b *= 0x1000; + var = 0x56A; + + if (c == 0) + { + for (i = 0; i < 20; i++) + { + a[(i + var) << 1] = gUnknown_08DC3CD4[i] + b; + a[((i + var) << 1) + 0x40] = gUnknown_08DC3CD4[i] + b; + a[((i + var) << 1) + 0x80] = gUnknown_08DC3CD4[i + 20] + b; + } + } + else + { + for (i = 0; i < 20; i++) + { + a[(i + var)] = gUnknown_08DC3CD4[i + 20] + b; + a[((i + var)) + 0x40] = gUnknown_08DC3CD4[i + 40] + b; + a[((i + var)) + 0x80] = gUnknown_08DC3CD4[i + 40] + b; + } + } +} +#else +__attribute__((naked)) +void sub_81C2194(u16 *a, u16 b, u8 c) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + adds r6, r0, 0\n\ + lsls r2, 24\n\ + lsls r1, 28\n\ + lsrs r4, r1, 16\n\ + ldr r7, =0x0000056a\n\ + cmp r2, 0\n\ + bne _081C21E4\n\ + movs r3, 0\n\ + ldr r5, =gUnknown_08DC3CD4\n\ +_081C21A8:\n\ + adds r2, r7, r3\n\ + lsls r2, 1\n\ + adds r2, r6\n\ + lsls r0, r3, 1\n\ + adds r0, r5\n\ + ldrh r1, [r0]\n\ + adds r1, r4, r1\n\ + strh r1, [r2]\n\ + adds r0, r2, 0\n\ + adds r0, 0x40\n\ + strh r1, [r0]\n\ + adds r2, 0x80\n\ + adds r0, r3, 0\n\ + adds r0, 0x14\n\ + lsls r0, 1\n\ + adds r0, r5\n\ + ldrh r0, [r0]\n\ + adds r0, r4, r0\n\ + strh r0, [r2]\n\ + adds r0, r3, 0x1\n\ + lsls r0, 16\n\ + lsrs r3, r0, 16\n\ + cmp r3, 0x13\n\ + bls _081C21A8\n\ + b _081C221C\n\ + .pool\n\ +_081C21E4:\n\ + movs r3, 0\n\ + ldr r5, =gUnknown_08DC3CD4\n\ +_081C21E8:\n\ + adds r1, r7, r3\n\ + lsls r1, 1\n\ + adds r1, r6\n\ + adds r0, r3, 0\n\ + adds r0, 0x14\n\ + lsls r0, 1\n\ + adds r0, r5\n\ + ldrh r0, [r0]\n\ + adds r0, r4, r0\n\ + strh r0, [r1]\n\ + adds r2, r1, 0\n\ + adds r2, 0x40\n\ + adds r0, r3, 0\n\ + adds r0, 0x28\n\ + lsls r0, 1\n\ + adds r0, r5\n\ + ldrh r0, [r0]\n\ + adds r0, r4, r0\n\ + strh r0, [r2]\n\ + adds r1, 0x80\n\ + strh r0, [r1]\n\ + adds r0, r3, 0x1\n\ + lsls r0, 16\n\ + lsrs r3, r0, 16\n\ + cmp r3, 0x13\n\ + bls _081C21E8\n\ +_081C221C:\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +void sub_81C2228(struct Pokemon *mon) +{ + if (!CheckPartyPokerus(mon, 0) && CheckPartyHasHadPokerus(mon, 0)) + { + gUnknown_0203CF1C->unkTilemap0[0x223] = 0x2C; + gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x2C; + } + else + { + gUnknown_0203CF1C->unkTilemap0[0x223] = 0x81A; + gUnknown_0203CF1C->unkTilemap0_1[0x223] = 0x81A; + } + schedule_bg_copy_tilemap_to_vram(3); +} + +void sub_81C228C(u8 a) +{ + if (a == 0) + sub_8199C30(3, 1, 4, 8, 8, 0); + else + sub_8199C30(3, 1, 4, 8, 8, 5); + schedule_bg_copy_tilemap_to_vram(3); +} + +void sub_81C22CC(struct Pokemon *unused) +{ + s64 r6r7; + struct PokeSummary *summary = &gUnknown_0203CF1C->summary; + u16 *r9; + u8 i; + + if (summary->level < MAX_MON_LEVEL) + { + u32 r1 = gExperienceTables[gBaseStats[summary->species].growthRate][summary->level + 1] - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level]; + u32 r4 = summary->exp - gExperienceTables[gBaseStats[summary->species].growthRate][summary->level]; + + r6r7 = r4 * 64 / r1; + if (r6r7 == 0 && r4 != 0) + r6r7 = 1; + } + else + { + r6r7 = 0; + } + + r9 = &gUnknown_0203CF1C->unkTilemap1_1[0x255]; + for (i = 0; i < 8; i++) + { + if (r6r7 > 7) + r9[i] = 0x206A; + else + r9[i] = 0x2062 + (r6r7 % 8); + r6r7 -= 8; + if (r6r7 < 0) + r6r7 = 0; + } + + if (GetBgTilemapBuffer(1) == gUnknown_0203CF1C->unkTilemap1) + schedule_bg_copy_tilemap_to_vram(1); + else + schedule_bg_copy_tilemap_to_vram(2); +} + +void sub_81C240C(u16 move) +{ + u16* r5 = &gUnknown_0203CF1C->unkTilemap3_1[0]; + u8 i; + u8 r4; + if (move != MOVE_NONE) + { + r4 = gContestEffects[gContestMoves[move].effect].appeal; + if (r4 != 0xFF) + r4 /= 10; + for (i = 0;i < 8; i++) + { + if (r4 != 0xFF && i < r4) + { + r5[((i>>2)*32)+(i&3)+0x1E6] = 0x103A; + } + else + r5[((i>>2)*32)+(i&3)+0x1E6] = 0x1039; + } + r4 = gContestEffects[gContestMoves[move].effect].jam; + if (r4 != 0xFF) + r4 /= 10; + for (i = 0;i < 8; i++) + { + if (r4 != 0xFF && i < r4) + { + r5[((i>>2)*32)+(i&3)+0x226] = 0x103C; + } + else + r5[((i>>2)*32)+(i&3)+0x226] = 0x103D; + } + } +} + +void sub_81C2524() +{ + if (gUnknown_0203CF1C->summary.isEgg != 0) + ChangeBgX(3, 0x10000, 0); + else + ChangeBgX(3, 0, 0); +} + +void sub_81C2554() +{ + u8 i; + InitWindows(&gUnknown_0861CC24); + DeactivateAllTextPrinters(); + for (i = 0; i < 20; i++) + FillWindowPixelBuffer(i, 0); + for (i = 0; i < 8; i++) + gUnknown_0203CF1C->unk40CB[i] |= 0xFF; +} + +void sub_81C25A4(u8 a, u8 *b, u8 c, u8 d, u8 e, u8 f) +{ + AddTextPrinterParametrized2(a, 1, c, d, 0, e, &gUnknown_0861CD2C[f], 0, b); +} + +void sub_81C25E8() +{ + FillWindowPixelBuffer(17, 0); + FillWindowPixelBuffer(18, 0); + FillWindowPixelBuffer(19, 0); + if (gUnknown_0203CF1C->summary.isEgg == 0) + sub_81C2628(); + else + sub_81C2794(); + schedule_bg_copy_tilemap_to_vram(0); +} + +void sub_81C2628() +{ + u8 strArray[16]; + struct Pokemon *mon = &gUnknown_0203CF1C->currentMon; + struct PokeSummary *summary = &gUnknown_0203CF1C->summary; + u16 r5 = SpeciesToPokedexNum(summary->species); + if (r5 != 0xFFFF) + { + StringCopy(gStringVar1, &gText_UnkCtrlF908Clear01[0]); + ConvertIntToDecimalStringN(gStringVar2, r5, 2, 3); + StringAppend(gStringVar1, gStringVar2); + if (IsMonShiny(mon) == 0) + { + sub_81C25A4(17, gStringVar1, 0, 1, 0, 1); + sub_81C228C(0); + } + else + { + sub_81C25A4(17, gStringVar1, 0, 1, 0, 7); + sub_81C228C(1); + } + PutWindowTilemap(17); + } + else + { + ClearWindowTilemap(17); + if (IsMonShiny(mon) == 0) + sub_81C228C(0); + else + sub_81C228C(1); + } + StringCopy(gStringVar1, &gText_LevelSymbol[0]); + ConvertIntToDecimalStringN(gStringVar2, summary->level, 0, 3); + StringAppend(gStringVar1, gStringVar2); + sub_81C25A4(19, gStringVar1, 0x18, 17, 0, 1); + GetMonNickname(mon, gStringVar1); + sub_81C25A4(18, gStringVar1, 0, 1, 0, 1); + strArray[0] = CHAR_SLASH; + StringCopy(&strArray[1], &gSpeciesNames[summary->species2][0]); + sub_81C25A4(19, &strArray[0], 0, 1, 0, 1); + sub_81C27DC(mon, summary->species2); + PutWindowTilemap(18); + PutWindowTilemap(19); +} + +void sub_81C2794() +{ + GetMonNickname(&gUnknown_0203CF1C->currentMon, gStringVar1); + sub_81C25A4(18, gStringVar1, 0, 1, 0, 1); + PutWindowTilemap(18); + ClearWindowTilemap(17); + ClearWindowTilemap(19); +} + +void sub_81C27DC(struct Pokemon *mon, u16 a) +{ + if (a != SPECIES_NIDORAN_M && a != SPECIES_NIDORAN_F) + { + u8 gender = GetMonGender(mon); + switch (gender) + { + case 0: + sub_81C25A4(0x13, &gText_MaleSymbol[0], 0x39, 17, 0, 3); + break; + case 0xFE: + sub_81C25A4(0x13, &gText_FemaleSymbol[0], 0x39, 17, 0, 4); + break; + } + } +} + +void sub_81C2838(u8 a, bool8 b, u32 c) +{ + BlitBitmapToWindow(a, (b) ? &gUnknown_0861CDD3[0] : &gUnknown_0861CDD3[0] - 0x80, c, 0, 16, 16); +} + +void sub_81C286C() +{ + int r4; + int r2; + int temp; + sub_81C25A4(0, gText_PkmnInfo, 2, 1, 0, 1); + sub_81C25A4(1, gText_PkmnSkills, 2, 1, 0, 1); + sub_81C25A4(2, gText_BattleMoves, 2, 1, 0, 1); + sub_81C25A4(3, gText_ContestMoves, 2, 1, 0, 1); + r4 = GetStringRightAlignXOffset(1, gText_Cancel2, 0x3E); + r2 = r4 - 16; + if (r2 < 0) + r2 = 0; + sub_81C2838(4, 0, r2); + sub_81C25A4(4, gText_Cancel2, r4, 1, 0, 0); + r4 = GetStringRightAlignXOffset(1, gText_Info, 0x3E); + r2 = r4 - 16; + if (r2 < 0) + r2 = 0; + sub_81C2838(5, 0, r2); + sub_81C25A4(5, gText_Info, r4, 1, 0, 0); + r4 = GetStringRightAlignXOffset(1, gText_Switch, 0x3E); + r2 = r4 - 16; + if (r2 < 0) + r2 = 0; + sub_81C2838(6, 0, r2); + sub_81C25A4(6, gText_Switch, r4, 1, 0, 0); + sub_81C25A4(8, gText_RentalPkmn, 0, 1, 0, 1); + sub_81C25A4(9, gText_TypeSlash, 0, 1, 0, 0); + temp = 6; + temp += GetStringCenterAlignXOffset(1, gText_HP4, 42); + sub_81C25A4(10, gText_HP4, temp, 1, 0, 1); + temp = 6; + temp += GetStringCenterAlignXOffset(1, gText_Attack3, 42); + sub_81C25A4(10, gText_Attack3, temp, 17, 0, 1); + temp = 6; + temp += GetStringCenterAlignXOffset(1, gText_Defense3, 42); + sub_81C25A4(10, gText_Defense3, temp, 33, 0, 1); + temp = 2; + temp += GetStringCenterAlignXOffset(1, gText_SpAtk4, 36); + sub_81C25A4(11, gText_SpAtk4, temp, 1, 0, 1); + temp = 2; + temp += GetStringCenterAlignXOffset(1, gText_SpDef4, 36); + sub_81C25A4(11, gText_SpDef4, temp, 17, 0, 1); + temp = 2; + temp += GetStringCenterAlignXOffset(1, gText_Speed2, 36); + sub_81C25A4(11, gText_Speed2, temp, 33, 0, 1); + sub_81C25A4(12, gText_ExpPoints, 6, 1, 0, 1); + sub_81C25A4(12, gText_NextLv, 6, 17, 0, 1); + sub_81C25A4(13, gText_Status, 2, 1, 0, 1); + sub_81C25A4(14, gText_Power, 0, 1, 0, 1); + sub_81C25A4(14, gText_Accuracy2, 0, 17, 0, 1); + sub_81C25A4(15, gText_Appeal, 0, 1, 0, 1); + sub_81C25A4(15, gText_Jam, 0, 17, 0, 1); +} + +void sub_81C2AFC(u8 a) +{ + u8 i; + ClearWindowTilemap(0); + ClearWindowTilemap(1); + ClearWindowTilemap(2); + ClearWindowTilemap(3); + switch (a) + { + case 0: + PutWindowTilemap(0); + PutWindowTilemap(4); + if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE) + PutWindowTilemap(8); + PutWindowTilemap(9); + break; + case 1: + PutWindowTilemap(1); + PutWindowTilemap(10); + PutWindowTilemap(11); + PutWindowTilemap(12); + break; + case 2: + PutWindowTilemap(2); + if (gUnknown_0203CF1C->unk40BC == 3) + { + if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + PutWindowTilemap(14); + } + else + PutWindowTilemap(5); + break; + case 3: + PutWindowTilemap(3); + if (gUnknown_0203CF1C->unk40BC == 3) + { + if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + PutWindowTilemap(15); + } + else + PutWindowTilemap(5); + break; + } + for (i = 0; i < 8; i++) + { + PutWindowTilemap(gUnknown_0203CF1C->unk40CB[i]); + } + schedule_bg_copy_tilemap_to_vram(0); +} + +void sub_81C2C38(u8 a) +{ + u8 i; + switch (a) + { + case 0: + ClearWindowTilemap(4); + if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE) + ClearWindowTilemap(8); + ClearWindowTilemap(9); + break; + case 1: + ClearWindowTilemap(10); + ClearWindowTilemap(11); + ClearWindowTilemap(12); + break; + case 2: + if (gUnknown_0203CF1C->unk40BC == 3) + { + if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + ClearWindowTilemap(14); + } + else + ClearWindowTilemap(5); + break; + case 3: + if (gUnknown_0203CF1C->unk40BC == 3) + { + if(!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + ClearWindowTilemap(15); + } + else + ClearWindowTilemap(5); + break; + } + for (i = 0; i < 8; i++) + sub_81C2D68(i); + schedule_bg_copy_tilemap_to_vram(0); +} + + + +#ifdef NONMATCHING +u8 sub_81C2D2C(struct WindowTemplate *template, u8 a) +{ + u8 *r4 = gUnknown_0203CF1C->unk40CB; + if (r4[a] == 0xFF) + { + r4[a] = AddWindow(&template[a]); + FillWindowPixelBuffer(r4[a], 0); + } + return r4[a]; +} +#else +__attribute__((naked)) +u8 sub_81C2D2C(struct WindowTemplate *template, u8 a) +{ + asm(".syntax unified\n\ + push {r4,lr}\n\ + adds r3, r0, 0\n\ + lsls r1, 24\n\ + lsrs r2, r1, 24\n\ + ldr r0, =gUnknown_0203CF1C\n\ + ldr r4, =0x000040cb\n\ + adds r1, r2, r4\n\ + ldr r0, [r0]\n\ + adds r4, r0, r1\n\ + ldrb r0, [r4]\n\ + cmp r0, 0xFF\n\ + bne _081C2D56\n\ + lsls r0, r2, 3\n\ + adds r0, r3, r0\n\ + bl AddWindow\n\ + strb r0, [r4]\n\ + ldrb r0, [r4]\n\ + movs r1, 0\n\ + bl FillWindowPixelBuffer\n\ +_081C2D56:\n\ + ldrb r0, [r4]\n\ + pop {r4}\n\ + pop {r1}\n\ + bx r1\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +#ifdef NONMATCHING +void sub_81C2D68(u8 a) +{ + u8 *r4 = gUnknown_0203CF1C->unk40CB; + if (r4[a] != 0xFF) + { + ClearWindowTilemap(r4[a]); + RemoveWindow(r4[a]); + r4[a] = 0xFF; + } +} +#else +__attribute__((naked)) +void sub_81C2D68(u8 a) +{ + asm(".syntax unified\n\ + push {r4,lr}\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + ldr r1, =gUnknown_0203CF1C\n\ + ldr r2, =0x000040cb\n\ + adds r0, r2\n\ + ldr r1, [r1]\n\ + adds r4, r1, r0\n\ + ldrb r0, [r4]\n\ + cmp r0, 0xFF\n\ + beq _081C2D8C\n\ + bl ClearWindowTilemap\n\ + ldrb r0, [r4]\n\ + bl RemoveWindow\n\ + movs r0, 0xFF\n\ + strb r0, [r4]\n\ +_081C2D8C:\n\ + pop {r4}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +void sub_81C2D9C(u8 a) +{ + u16 i; + for (i = 0; i < 8; i++) + { + if (gUnknown_0203CF1C->unk40CB[i] != 0xFF) + FillWindowPixelBuffer(gUnknown_0203CF1C->unk40CB[i], 0); + } + gUnknown_0861CE54[a](); +} + +void sub_81C2DE4(u8 a) +{ + CreateTask(gUnknown_0861CE64[a], 16); +} + +void sub_81C2E00() +{ + if (gUnknown_0203CF1C->summary.isEgg) + { + sub_81C335C(); + sub_81C33CC(); + sub_81C3428(); + sub_81C349C(); + } + else + { + sub_81C2EC4(); + sub_81C2F5C(); + sub_81C2FD8(); + sub_81C302C(); + sub_81C307C(); + sub_81C3194(); + } +} + +void sub_81C2E40(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + s16 dataa = data[0] - 1; + switch (dataa) + { + case 0: + sub_81C2EC4(); + break; + case 1: + sub_81C2F5C(); + break; + case 2: + sub_81C2FD8(); + break; + case 3: + sub_81C302C(); + break; + case 4: + sub_81C307C(); + break; + case 5: + sub_81C3194(); + break; + case 6: + DestroyTask(taskId); + return; + } + data[0]++; +} + +void sub_81C2EC4() +{ + u8 r5; + int r2; + if (sub_81A6BF4() != 1 && sub_81B9E94() != 1) + { + r5 = sub_81C2D2C(&gUnknown_0861CCCC, 0); + sub_81C25A4(r5, gText_OTSlash, 0, 1, 0, 1); + r2 = GetStringWidth(1, gText_OTSlash, 0); + if (gUnknown_0203CF1C->summary.OTGender == 0) + sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 5); + else + sub_81C25A4(r5, gUnknown_0203CF1C->summary.OTName, r2, 1, 0, 6); + } +} + +void sub_81C2F5C() +{ + int r4; + if (sub_81A6BF4() != TRUE && sub_81B9E94() != TRUE) + { + ConvertIntToDecimalStringN(StringCopy(gStringVar1, gText_UnkCtrlF907F908), (u16)gUnknown_0203CF1C->summary.OTID, 2, 5); + r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38); + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1); + } +} + +void sub_81C2FD8() +{ + u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility); + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityNames[ability], 0, 1, 0, 1); +} + +void sub_81C302C() +{ + u8 ability = GetAbilityBySpecies(gUnknown_0203CF1C->summary.species, gUnknown_0203CF1C->summary.altAbility); + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), gAbilityDescriptionPointers[ability], 0, 17, 0, 0); +} + +void sub_81C307C() +{ + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + u8 *text; + sub_81AFBF0(); + sub_81AFC0C(0, gUnknown_0861CE74); + sub_81AFC0C(1, gUnknown_0861CE7B); + sub_81C31C0(); + if (sub_81A6BF4() == TRUE || sub_81B9E94() == TRUE || sub_81C3304() == TRUE) + sub_81AFC28(gStringVar4, gText_XNature); + else + { + u8 *alloced1 = Alloc(32); + u8 *alloced2 = Alloc(32); + sub_81C31F0(alloced1); + if (sum->metLocation <= 0xD4) + { + sub_8124610(alloced2, sum->metLocation); + sub_81AFC0C(4, alloced2); + } + if (sub_81C3220() == 1) + { + if (sum->metLevel == 0) + text = (sum->metLocation > 0xD4) ? gText_XNatureHatchedSomewhereAt : gText_XNatureHatchedAtYZ; + else + text = (sum->metLocation > 0xD4) ? gText_XNatureMetSomewhereAt : gText_XNatureMetAtYZ; + } + else if (sum->metLocation == 0xFF) + text = gText_XNatureFatefulEncounter; + else if (sum->metLocation != 0xFE && sub_81C32BC()) + text = (sum->metLocation > 0xD4) ? gText_XNatureObtainedInTrade : gText_XNatureProbablyMetAt; + else + text = gText_XNatureObtainedInTrade; + sub_81AFC28(gStringVar4, text); + Free(alloced1); + Free(alloced2); + } +} + +void sub_81C3194() +{ + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), gStringVar4, 0, 1, 0, 0); +} + +void sub_81C31C0() +{ + struct UnkSummaryStruct *sumStruct = gUnknown_0203CF1C; + sub_81AFC0C(2, gNatureNamePointers[sumStruct->summary.nature]); + sub_81AFC0C(5, gText_EmptyString5); +} + +void sub_81C31F0(u8 *a) +{ + u8 level = gUnknown_0203CF1C->summary.metLevel; + if (level == 0) + level = 5; + ConvertIntToDecimalStringN(a, level, 0, 3); + sub_81AFC0C(3, a); +} + +u8 sub_81C3220() +{ + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + u32 r4; + u8 r5; + if (gUnknown_0203CF1C->unk0 == (union UnkUnion *)&gEnemyParty) + { + u8 multiID = GetMultiplayerId()^1; + r4 = (u16)gLinkPlayers[multiID].trainerId; + r5 = gLinkPlayers[multiID].gender; + StringCopy(gStringVar1, gLinkPlayers[multiID].name); + } + else + { + r4 = GetPlayerIDAsU32() & 0xFFFF; + r5 = gSaveBlock2Ptr->playerGender; + StringCopy(gStringVar1, gSaveBlock2Ptr->playerName); + } + if (r5 != sum->OTGender || r4 != (sum->OTID & 0xFFFF) || StringCompareWithoutExtCtrlCodes(gStringVar1, sum->OTName)) + { + return 0; + } + return 1; +} + +bool8 sub_81C32BC() +{ + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + u8 r0 = sum->metGame - 1; + if (r0 <= 4) + return TRUE; + return FALSE; +} + +bool8 sub_81C32E0() +{ + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + u8 r0 = sum->metGame - 1; + if (r0 <= 2) + return TRUE; + return FALSE; +} + +bool8 sub_81C3304() +{ + if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) && gMain.inBattle) + { + if (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5) + return TRUE; + } + return FALSE; +} + +#ifdef NONMATCHING +void sub_81C335C() +{ + u8 r4 = sub_81C2D2C(&gUnknown_0861CCCC, 0); + u32 r5 = GetStringWidth(1, gText_OTSlash, 0); + sub_81C25A4(r4, gText_OTSlash, 0, 1, 0, 1); + sub_81C25A4(r4, gText_FiveMarks, r5, 1, 0, 1); +} +#else +__attribute__((naked)) +void sub_81C335C() +{ + asm(".syntax unified\n\ + push {r4-r6,lr}\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5,r6}\n\ + sub sp, 0x8\n\ + ldr r0, =gUnknown_0861CCCC\n\ + movs r1, 0\n\ + bl sub_81C2D2C\n\ + adds r4, r0, 0\n\ + lsls r4, 24\n\ + lsrs r4, 24\n\ + ldr r0, =gText_OTSlash\n\ + mov r8, r0\n\ + movs r0, 0x1\n\ + mov r1, r8\n\ + movs r2, 0\n\ + bl GetStringWidth\n\ + adds r5, r0, 0\n\ + movs r0, 0\n\ + mov r9, r0\n\ + str r0, [sp]\n\ + movs r6, 0x1\n\ + str r6, [sp, 0x4]\n\ + adds r0, r4, 0\n\ + mov r1, r8\n\ + movs r2, 0\n\ + movs r3, 0x1\n\ + bl sub_81C25A4\n\ + ldr r1, =gText_FiveMarks\n\ + lsls r5, 24\n\ + lsrs r5, 24\n\ + mov r0, r9\n\ + str r0, [sp]\n\ + str r6, [sp, 0x4]\n\ + adds r0, r4, 0\n\ + adds r2, r5, 0\n\ + movs r3, 0x1\n\ + bl sub_81C25A4\n\ + add sp, 0x8\n\ + pop {r3,r4}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + pop {r4-r6}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +void sub_81C33CC() +{ + int r4; + StringCopy(gStringVar1, gText_UnkCtrlF907F908); + StringAppend(gStringVar1, gText_FiveMarks); + r4 = GetStringRightAlignXOffset(1, gStringVar1, 0x38); + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 1), gStringVar1, r4, 1, 0, 1); +} + +void sub_81C3428() +{ + u8 *text; + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + if (gUnknown_0203CF1C->summary.sanity == 1) + text = gText_EggWillTakeALongTime; + else if (sum->friendship <= 5) + text = gText_EggAboutToHatch; + else if (sum->friendship <= 10) + text = gText_EggWillHatchSoon; + else if (sum->friendship <= 40) + text = gText_EggWillTakeSomeTime; + else + text = gText_EggWillTakeALongTime; + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 2), text, 0, 1, 0, 0); +} + +void sub_81C349C() +{ + u8 *text; + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + if (gUnknown_0203CF1C->summary.sanity != 1) + { + if (sum->metLocation == 0xFF) + text = gText_PeculiarEggNicePlace; + else if (sub_81C32BC() == 0 || sub_81C3220() == 0) + text = gText_PeculiarEggTrade; + else if (sum->metLocation == 0xFD) + text = (sub_81C32E0() == TRUE) ? gText_EggFromHotSprings : gText_EggFromTraveler; + else + text = gText_OddEggFoundByCouple; + } + else + text = gText_OddEggFoundByCouple; + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCCC, 3), text, 0, 1, 0, 0); +} + +void sub_81C3530() +{ + sub_81C35E4(); + sub_81C3690(); + sub_81C3710(); + sub_81C37D8(); + sub_81C3808(); + sub_81C3890(); + sub_81C38C0(); +} + +void sub_81C3554(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + s16 dataa = data[0] - 1; + switch (dataa) + { + case 0: + sub_81C35E4(); + break; + case 1: + sub_81C3690(); + break; + case 2: + sub_81C3710(); + break; + case 3: + sub_81C37D8(); + break; + case 4: + sub_81C3808(); + break; + case 5: + sub_81C3890(); + break; + case 6: + sub_81C38C0(); + break; + case 7: + DestroyTask(taskId); + return; + } + data[0]++; +} + +void sub_81C35E4() +{ + u8 *text; + int offset; + if (gUnknown_0203CF1C->summary.item == ITEM_ENIGMA_BERRY && sub_81B1250() == 1 && (gUnknown_0203CF1C->unk40BE == 1 || gUnknown_0203CF1C->unk40BE == 4 || gUnknown_0203CF1C->unk40BE == 5)) + { + text = (u8*)ItemId_GetItem(ITEM_ENIGMA_BERRY); + } + else if (gUnknown_0203CF1C->summary.item == ITEM_NONE) + text = gText_None; + else + { + CopyItemName(gUnknown_0203CF1C->summary.item, gStringVar1); + text = gStringVar1; + } + offset = GetStringCenterAlignXOffset(1, text, 0x48) + 6; + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 0), text, offset, 1, 0, 0); +} + +void sub_81C3690() +{ + u8 *text; + int offset; + if (gUnknown_0203CF1C->summary.ribbons == 0) + text = gText_None; + else + { + ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.ribbons, 1, 2); + StringExpandPlaceholders(gStringVar4, gText_RibbonsVar1); + text = gStringVar4; + } + offset = GetStringCenterAlignXOffset(1, text, 0x46) + 6; + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 1), text, offset, 1, 0, 0); +} + +void sub_81C3710() +{ + u8 *alloced1 = Alloc(8); + u8 *alloced2 = Alloc(8); + u8 *alloced3 = Alloc(8); + u8 *alloced4 = Alloc(8); + ConvertIntToDecimalStringN(alloced1, gUnknown_0203CF1C->summary.currentHP, 1, 3); + ConvertIntToDecimalStringN(alloced2, gUnknown_0203CF1C->summary.maxHP, 1, 3); + ConvertIntToDecimalStringN(alloced3, gUnknown_0203CF1C->summary.atk, 1, 7); + ConvertIntToDecimalStringN(alloced4, gUnknown_0203CF1C->summary.def, 1, 7); + sub_81AFBF0(); + sub_81AFC0C(0, alloced1); + sub_81AFC0C(1, alloced2); + sub_81AFC0C(2, alloced3); + sub_81AFC0C(3, alloced4); + sub_81AFC28(gStringVar4, gUnknown_0861CE82); + Free(alloced1); + Free(alloced2); + Free(alloced3); + Free(alloced4); +} + +void sub_81C37D8() +{ + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 2), gStringVar4, 4, 1, 0, 0); +} + +void sub_81C3808() +{ + ConvertIntToDecimalStringN(gStringVar1, gUnknown_0203CF1C->summary.spatk, 1, 3); + ConvertIntToDecimalStringN(gStringVar2, gUnknown_0203CF1C->summary.spdef, 1, 3); + ConvertIntToDecimalStringN(gStringVar3, gUnknown_0203CF1C->summary.speed, 1, 3); + sub_81AFBF0(); + sub_81AFC0C(0, gStringVar1); + sub_81AFC0C(1, gStringVar2); + sub_81AFC0C(2, gStringVar3); + sub_81AFC28(gStringVar4, gUnknown_0861CE8E); +} + +void sub_81C3890() +{ + sub_81C25A4(sub_81C2D2C(&gUnknown_0861CCEC, 3), gStringVar4, 2, 1, 0, 0); +} + +void sub_81C38C0() +{ + struct PokeSummary *sum = &gUnknown_0203CF1C->summary; + u8 r6 = sub_81C2D2C(&gUnknown_0861CCEC, 4); + int offset; + u32 expToNextLevel; + ConvertIntToDecimalStringN(gStringVar1, sum->exp, 1, 7); + offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2; + sub_81C25A4(r6, gStringVar1, offset, 1, 0, 0); + if (sum->level < MAX_MON_LEVEL) + expToNextLevel = gExperienceTables[gBaseStats[sum->species].growthRate][sum->level + 1] - sum->exp; + else + expToNextLevel = 0; + ConvertIntToDecimalStringN(gStringVar1, expToNextLevel, 1, 6); + offset = GetStringRightAlignXOffset(1, gStringVar1, 0x2A) + 2; + sub_81C25A4(r6, gStringVar1, offset, 17, 0, 0); +} + +void sub_81C3984() +{ + sub_81C3B08(0); + sub_81C3B08(1); + sub_81C3B08(2); + sub_81C3B08(3); + if (gUnknown_0203CF1C->unk40BC == 3) + { + sub_81C3F44(); + if (gUnknown_0203CF1C->unk40C6 == 4) + { + if (gUnknown_0203CF1C->unk40C4 != 0) + sub_81C3E9C(gUnknown_0203CF1C->unk40C4); + } + else + sub_81C3E9C(gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]); + } +} + +void sub_81C39F0(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + s16 dataa = data[0] - 1; + + switch (dataa) + { + case 0: + sub_81C3B08(0); + break; + case 1: + sub_81C3B08(1); + break; + case 2: + sub_81C3B08(2); + break; + case 3: + sub_81C3B08(3); + break; + case 4: + if (gUnknown_0203CF1C->unk40BC == 3) + sub_81C3F44(); + break; + case 5: + if (gUnknown_0203CF1C->unk40BC == 3) + { + if (gUnknown_0203CF1C->unk40C6 == 4) + data[1] = gUnknown_0203CF1C->unk40C4; + else + data[1] = gUnknown_0203CF1C->summary.moves[gUnknown_0203CF1C->unk40C6]; + } + break; + case 6: + if (gUnknown_0203CF1C->unk40BC == 3) + { + if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + sub_81C3E9C(data[1]); + } + break; + case 7: + DestroyTask(taskId); + return; + } + data[0]++; +} + +#ifdef NONMATCHING +void sub_81C3B08(u8 a) +{ + struct UnkSummaryStruct *r10 = gUnknown_0203CF1C; + u8 r8 = sub_81C2D2C(&gUnknown_0861CD14, 0); + u8 sp = sub_81C2D2C(&gUnknown_0861CD14, 1); + u8 r6; + u8 r5; + u8 *text; + int offset; + u16 move; + if (r10->summary.moves[a] != 0) + { + move = r10->summary.moves[a]; + r6 = CalculatePPWithBonus(move, r10->summary.ppBonuses, a); + sub_81C25A4(r8, gMoveNames[move], 0, (a<<4) + 1, 0, 1); + ConvertIntToDecimalStringN(gStringVar1, r10->summary.pp[a], 1, 2); + ConvertIntToDecimalStringN(gStringVar2, r6, 1, 2); + sub_81AFBF0(); + sub_81AFC0C(0, gStringVar1); + sub_81AFC0C(1, gStringVar2); + sub_81AFC28(gStringVar4, gUnknown_0861CE97); + text = gStringVar4; + r5 = GetCurrentPpToMaxPpState(r10->summary.pp[a], r6) + 9; + offset = GetStringRightAlignXOffset(1, text, 0x2C); + } + else + { + sub_81C25A4(r8, gText_OneDash, 0, (a<<4) + 1, 0, 1); + text = gText_TwoDashes; + r5 = 12; + offset = GetStringCenterAlignXOffset(1, text, 0x2C); + } + sub_81C25A4(sp, text, offset, (a<<4), 0, r5); +} +#else +__attribute__((naked)) +void sub_81C3B08(u8 a) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0xC\n\ + lsls r0, 24\n\ + lsrs r7, r0, 24\n\ + ldr r0, =gUnknown_0203CF1C\n\ + ldr r0, [r0]\n\ + mov r10, r0\n\ + ldr r4, =gUnknown_0861CD14\n\ + adds r0, r4, 0\n\ + movs r1, 0\n\ + bl sub_81C2D2C\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r8, r0\n\ + adds r0, r4, 0\n\ + movs r1, 0x1\n\ + bl sub_81C2D2C\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + str r0, [sp, 0x8]\n\ + lsls r1, r7, 1\n\ + mov r0, r10\n\ + adds r0, 0x84\n\ + adds r0, r1\n\ + ldrh r5, [r0]\n\ + cmp r5, 0\n\ + beq _081C3C00\n\ + mov r0, r10\n\ + adds r0, 0xA4\n\ + ldrb r1, [r0]\n\ + adds r0, r5, 0\n\ + adds r2, r7, 0\n\ + bl CalculatePPWithBonus\n\ + adds r6, r0, 0\n\ + lsls r6, 24\n\ + lsrs r6, 24\n\ + movs r0, 0xD\n\ + adds r1, r5, 0\n\ + muls r1, r0\n\ + ldr r0, =gMoveNames\n\ + adds r1, r0\n\ + lsls r0, r7, 4\n\ + mov r9, r0\n\ + mov r3, r9\n\ + adds r3, 0x1\n\ + lsls r3, 24\n\ + lsrs r3, 24\n\ + movs r0, 0\n\ + str r0, [sp]\n\ + movs r0, 0x1\n\ + str r0, [sp, 0x4]\n\ + mov r0, r8\n\ + movs r2, 0\n\ + bl sub_81C25A4\n\ + ldr r0, =gStringVar1\n\ + mov r8, r0\n\ + mov r5, r10\n\ + adds r5, 0x8C\n\ + adds r5, r7\n\ + ldrb r1, [r5]\n\ + movs r2, 0x1\n\ + movs r3, 0x2\n\ + bl ConvertIntToDecimalStringN\n\ + ldr r4, =gStringVar2\n\ + adds r0, r4, 0\n\ + adds r1, r6, 0\n\ + movs r2, 0x1\n\ + movs r3, 0x2\n\ + bl ConvertIntToDecimalStringN\n\ + bl sub_81AFBF0\n\ + movs r0, 0\n\ + mov r1, r8\n\ + bl sub_81AFC0C\n\ + movs r0, 0x1\n\ + adds r1, r4, 0\n\ + bl sub_81AFC0C\n\ + ldr r4, =gStringVar4\n\ + ldr r1, =gUnknown_0861CE97\n\ + adds r0, r4, 0\n\ + bl sub_81AFC28\n\ + adds r7, r4, 0\n\ + ldrb r0, [r5]\n\ + adds r1, r6, 0\n\ + bl GetCurrentPpToMaxPpState\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + adds r5, r0, 0\n\ + adds r5, 0x9\n\ + movs r0, 0x1\n\ + adds r1, r7, 0\n\ + movs r2, 0x2C\n\ + bl GetStringRightAlignXOffset\n\ + mov r4, r9\n\ + b _081C3C26\n\ + .pool\n\ +_081C3C00:\n\ + ldr r1, =gText_OneDash\n\ + lsls r4, r7, 4\n\ + adds r3, r4, 0x1\n\ + lsls r3, 24\n\ + lsrs r3, 24\n\ + str r5, [sp]\n\ + movs r0, 0x1\n\ + str r0, [sp, 0x4]\n\ + mov r0, r8\n\ + movs r2, 0\n\ + bl sub_81C25A4\n\ + ldr r7, =gText_TwoDashes\n\ + movs r5, 0xC\n\ + movs r0, 0x1\n\ + adds r1, r7, 0\n\ + movs r2, 0x2C\n\ + bl GetStringCenterAlignXOffset\n\ +_081C3C26:\n\ + lsls r2, r0, 24\n\ + lsrs r2, 24\n\ + adds r3, r4, 0x1\n\ + lsls r3, 24\n\ + lsrs r3, 24\n\ + movs r0, 0\n\ + str r0, [sp]\n\ + lsls r0, r5, 24\n\ + lsrs r0, 24\n\ + str r0, [sp, 0x4]\n\ + ldr r0, [sp, 0x8]\n\ + adds r1, r7, 0\n\ + bl sub_81C25A4\n\ + add sp, 0xC\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool\n\ + .syntax divided\n"); +} +#endif + +void sub_81C3C5C(u16 move) +{ + u8 *text; + if (move != 0) + { + FillWindowPixelRect(14, 0, 0x35, 0, 0x13, 0x20); + if (gBattleMoves[move].power <= 1) + text = gText_ThreeDashes; + else + { + ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].power, 1, 3); + text = gStringVar1; + } + sub_81C25A4(14, text, 0x35, 1, 0, 0); + if (gBattleMoves[move].accuracy == 0) + text = gText_ThreeDashes; + else + { + ConvertIntToDecimalStringN(gStringVar1, gBattleMoves[move].accuracy, 1, 3); + text = gStringVar1; + } + sub_81C25A4(14, text, 0x35, 17, 0, 0); + } +} + +void sub_81C3D08() +{ + sub_81C3B08(0); + sub_81C3B08(1); + sub_81C3B08(2); + sub_81C3B08(3); + if (gUnknown_0203CF1C->unk40BC == 3) + { + sub_81C3F44(); + sub_81C3E2C(gUnknown_0203CF1C->unk40C6); + } +} + +void sub_81C3D54(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + s16 dataa = data[0] - 1; + + switch (dataa) + { + case 0: + sub_81C3B08(0); + break; + case 1: + sub_81C3B08(1); + break; + case 2: + sub_81C3B08(2); + break; + case 3: + sub_81C3B08(3); + break; + case 4: + if (gUnknown_0203CF1C->unk40BC == 3) + sub_81C3F44(); + break; + case 5: + if (gUnknown_0203CF1C->unk40BC == 3) + { + if (!(gUnknown_0203CF1C->unk40C4 == 0 && gUnknown_0203CF1C->unk40C6 == 4)) + sub_81C3E2C(gUnknown_0203CF1C->unk40C6); + } + break; + case 6: + DestroyTask(taskId); + return; + } + data[0]++; +} \ No newline at end of file diff --git a/src/start_menu.c b/src/start_menu.c index be30d0e53..37331a922 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -207,7 +207,7 @@ static bool32 PrintStartMenuItemsMultistep(s16 *index, u32 n) do { - if (sStartMenuItems[sCurrentStartMenuActions[_index]].func == StartMenu_PlayerName) + if (sStartMenuItems[sCurrentStartMenuActions[_index]].func.u8_void == StartMenu_PlayerName) { } diff --git a/src/tv.c b/src/tv.c index 7f64b46ac..3c822b394 100644 --- a/src/tv.c +++ b/src/tv.c @@ -2353,7 +2353,7 @@ void sub_80EDFB4(TVShow *show) show->secretBaseVisit.move = sTV_SecretBaseVisitMonsTemp[j].move; } -void sub_80EE104(void) +void TV_PutSecretBaseVisitOnTheAir(void) { TVShow *show; -- cgit v1.2.3 From 1f3a867a0b05c52344c5a145db3272e653deb697 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 23 Oct 2017 16:38:11 +0200 Subject: battle link partner controller is done --- src/battle_controller_link_partner.c | 1657 +++++++++++++++++++++++++++++-- src/battle_controller_recorded_player.c | 2 +- src/battle_controllers.c | 44 +- src/battle_message.c | 8 +- src/battle_script_commands.c | 6 +- src/battle_util.c | 4 +- src/pokemon_3.c | 4 +- 7 files changed, 1626 insertions(+), 99 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 62361ebef..07bab9d5f 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -5,6 +5,7 @@ #include "battle_interface.h" #include "battle_anim.h" #include "battle_ai_script_commands.h" +#include "battle_link_817C95C.h" #include "pokemon.h" #include "link.h" #include "util.h" @@ -55,73 +56,81 @@ extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; extern const struct BattleMove gBattleMoves[]; -extern void sub_81358F4(void); extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); +extern void sub_81851A8(u8 *); // this file's functions -void LinkPartnerHandleGetMonData(void); -void LinkPartnerHandleGetRawMonData(void); -void LinkPartnerHandleSetMonData(void); -void LinkPartnerHandleSetRawMonData(void); -void LinkPartnerHandleLoadMonSprite(void); -void LinkPartnerHandleSwitchInAnim(void); -void LinkPartnerHandleReturnMonToBall(void); -void LinkPartnerHandleDrawTrainerPic(void); -void LinkPartnerHandleTrainerSlide(void); -void LinkPartnerHandleTrainerSlideBack(void); -void LinkPartnerHandleFaintAnimation(void); -void LinkPartnerHandlePaletteFade(void); -void LinkPartnerHandleSuccessBallThrowAnim(void); -void LinkPartnerHandleBallThrowAnim(void); -void LinkPartnerHandlePause(void); -void LinkPartnerHandleMoveAnimation(void); -void LinkPartnerHandlePrintString(void); -void LinkPartnerHandlePrintStringPlayerOnly(void); -void LinkPartnerHandleChooseAction(void); -void LinkPartnerHandleUnknownYesNoBox(void); -void LinkPartnerHandleChooseMove(void); -void LinkPartnerHandleChooseItem(void); -void LinkPartnerHandleChoosePokemon(void); -void LinkPartnerHandleCmd23(void); -void LinkPartnerHandleHealthBarUpdate(void); -void LinkPartnerHandleExpUpdate(void); -void LinkPartnerHandleStatusIconUpdate(void); -void LinkPartnerHandleStatusAnimation(void); -void LinkPartnerHandleStatusXor(void); -void LinkPartnerHandleDataTransfer(void); -void LinkPartnerHandleDMA3Transfer(void); -void LinkPartnerHandlePlayBGM(void); -void LinkPartnerHandleCmd32(void); -void LinkPartnerHandleTwoReturnValues(void); -void LinkPartnerHandleChosenMonReturnValue(void); -void LinkPartnerHandleOneReturnValue(void); -void LinkPartnerHandleOneReturnValue_Duplicate(void); -void LinkPartnerHandleCmd37(void); -void LinkPartnerHandleCmd38(void); -void LinkPartnerHandleCmd39(void); -void LinkPartnerHandleCmd40(void); -void LinkPartnerHandleHitAnimation(void); -void LinkPartnerHandleCmd42(void); -void LinkPartnerHandleEffectivenessSound(void); -void LinkPartnerHandlePlayFanfareOrBGM(void); -void LinkPartnerHandleFaintingCry(void); -void LinkPartnerHandleIntroSlide(void); -void LinkPartnerHandleIntroTrainerBallThrow(void); -void LinkPartnerHandleDrawPartyStatusSummary(void); -void LinkPartnerHandleCmd49(void); -void LinkPartnerHandleCmd50(void); -void LinkPartnerHandleSpriteInvisibility(void); -void LinkPartnerHandleBattleAnimation(void); -void LinkPartnerHandleLinkStandbyMsg(void); -void LinkPartnerHandleResetActionMoveSelection(void); -void LinkPartnerHandleCmd55(void); -void nullsub_113(void); - -void LinkPartnerBufferRunCommand(void); -void LinkPartnerBufferExecCompleted(void); - -void (*const gLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void LinkPartnerHandleGetMonData(void); +static void LinkPartnerHandleGetRawMonData(void); +static void LinkPartnerHandleSetMonData(void); +static void LinkPartnerHandleSetRawMonData(void); +static void LinkPartnerHandleLoadMonSprite(void); +static void LinkPartnerHandleSwitchInAnim(void); +static void LinkPartnerHandleReturnMonToBall(void); +static void LinkPartnerHandleDrawTrainerPic(void); +static void LinkPartnerHandleTrainerSlide(void); +static void LinkPartnerHandleTrainerSlideBack(void); +static void LinkPartnerHandleFaintAnimation(void); +static void LinkPartnerHandlePaletteFade(void); +static void LinkPartnerHandleSuccessBallThrowAnim(void); +static void LinkPartnerHandleBallThrowAnim(void); +static void LinkPartnerHandlePause(void); +static void LinkPartnerHandleMoveAnimation(void); +static void LinkPartnerHandlePrintString(void); +static void LinkPartnerHandlePrintStringPlayerOnly(void); +static void LinkPartnerHandleChooseAction(void); +static void LinkPartnerHandleUnknownYesNoBox(void); +static void LinkPartnerHandleChooseMove(void); +static void LinkPartnerHandleChooseItem(void); +static void LinkPartnerHandleChoosePokemon(void); +static void LinkPartnerHandleCmd23(void); +static void LinkPartnerHandleHealthBarUpdate(void); +static void LinkPartnerHandleExpUpdate(void); +static void LinkPartnerHandleStatusIconUpdate(void); +static void LinkPartnerHandleStatusAnimation(void); +static void LinkPartnerHandleStatusXor(void); +static void LinkPartnerHandleDataTransfer(void); +static void LinkPartnerHandleDMA3Transfer(void); +static void LinkPartnerHandlePlayBGM(void); +static void LinkPartnerHandleCmd32(void); +static void LinkPartnerHandleTwoReturnValues(void); +static void LinkPartnerHandleChosenMonReturnValue(void); +static void LinkPartnerHandleOneReturnValue(void); +static void LinkPartnerHandleOneReturnValue_Duplicate(void); +static void LinkPartnerHandleCmd37(void); +static void LinkPartnerHandleCmd38(void); +static void LinkPartnerHandleCmd39(void); +static void LinkPartnerHandleCmd40(void); +static void LinkPartnerHandleHitAnimation(void); +static void LinkPartnerHandleCmd42(void); +static void LinkPartnerHandleEffectivenessSound(void); +static void LinkPartnerHandlePlayFanfareOrBGM(void); +static void LinkPartnerHandleFaintingCry(void); +static void LinkPartnerHandleIntroSlide(void); +static void LinkPartnerHandleIntroTrainerBallThrow(void); +static void LinkPartnerHandleDrawPartyStatusSummary(void); +static void LinkPartnerHandleCmd49(void); +static void LinkPartnerHandleCmd50(void); +static void LinkPartnerHandleSpriteInvisibility(void); +static void LinkPartnerHandleBattleAnimation(void); +static void LinkPartnerHandleLinkStandbyMsg(void); +static void LinkPartnerHandleResetActionMoveSelection(void); +static void LinkPartnerHandleCmd55(void); +static void nullsub_113(void); + +static void LinkPartnerBufferRunCommand(void); +static void LinkPartnerBufferExecCompleted(void); +static void sub_814B554(void); +static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst); +static void SetLinkPartnerMonData(u8 monId); +static void sub_814CC98(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void LinkPartnerDoMoveAnimation(void); +static void sub_814DCCC(u8 taskId); +static void sub_814DE9C(void); + +static void (*const gLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { LinkPartnerHandleGetMonData, LinkPartnerHandleGetRawMonData, @@ -182,7 +191,7 @@ void (*const gLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = nullsub_113 }; -void nullsub_112(void) +static void nullsub_112(void) { } @@ -191,7 +200,7 @@ void SetBankFuncToLinkPartnerBufferRunCommand(void) gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; } -void LinkPartnerBufferRunCommand(void) +static void LinkPartnerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { @@ -201,3 +210,1521 @@ void LinkPartnerBufferRunCommand(void) LinkPartnerBufferExecCompleted(); } } + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + LinkPartnerBufferExecCompleted(); +} + +static void sub_814AF54(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_25(0); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + LinkPartnerBufferExecCompleted(); + } +} + +static void sub_814AFBC(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + LinkPartnerBufferExecCompleted(); + } +} + +static void sub_814B004(void) +{ + bool32 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r6 = TRUE; + } + } + + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_814AFBC; + } +} + +static void sub_814B0E8(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8 + && gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && ++gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 != 1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + + gBattleBankFunc[gActiveBank] = sub_814B004; + } +} + +static void sub_814B290(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].animEnded && gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + LinkPartnerBufferExecCompleted(); +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + LinkPartnerBufferExecCompleted(); + } +} + +static void sub_814B340(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_24(species); + FreeOamMatrix(gSprites[gBankSpriteIds[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +static void sub_814B3DC(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + LinkPartnerBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + LinkPartnerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_814B4E0(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + + gBattleBankFunc[gActiveBank] = sub_814B554; + } +} + +static void sub_814B554(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + LinkPartnerBufferExecCompleted(); + } +} + +static void sub_814B5A8(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + CreateTask(c3_0802FDF4, 10); + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleBankFunc[gActiveBank] = sub_814B4E0; + } +} + +static void sub_814B69C(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + gBattleBankFunc[gActiveBank] = sub_814B5A8; + } +} + +static void LinkPartnerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + LinkPartnerBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyLinkPartnerMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyLinkPartnerMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + LinkPartnerBufferExecCompleted(); +} + +static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gPlayerParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gPlayerParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void LinkPartnerHandleGetRawMonData(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetLinkPartnerMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetLinkPartnerMonData(i); + monsToCheck >>= 1; + } + } + LinkPartnerBufferExecCompleted(); +} + +static void SetLinkPartnerMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +static void LinkPartnerHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleLoadMonSprite(void) +{ + u16 species; + + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + gBattleBankFunc[gActiveBank] = sub_814B290; +} + +static void LinkPartnerHandleSwitchInAnim(void) +{ + ClearTemporarySpeciesSpriteData(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_814CC98(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_814B69C; +} + +static void sub_814CC98(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite( + &gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); +} + +static void LinkPartnerHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + gBattleBankFunc[gActiveBank] = sub_814B3DC; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +static void LinkPartnerHandleDrawTrainerPic(void) +{ + s16 xPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 90; + else // first mon + xPos = 32; + } + else + { + xPos = 80; + } + + if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_LEAF_GREEN) + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender + BACK_PIC_RED; + } + else if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_SAPPHIRE) + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender + BACK_PIC_RS_BRENDAN; + } + else + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender; + } + + DecompressTrainerBackPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, xPos, (8 - gTrainerBackPicCoords[trainerPicId].coords) * 4 + 80, sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void LinkPartnerHandleTrainerSlide(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_814AF54; +} + +static void LinkPartnerHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; + gBattleBankFunc[gActiveBank] = sub_814B340; + } + } +} + +static void LinkPartnerHandlePaletteFade(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleSuccessBallThrowAnim(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleBallThrowAnim(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandlePause(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + LinkPartnerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = LinkPartnerDoMoveAnimation; + sub_817E0FC(move, gWeatherMoveAnim, gAnimDisableStructPtr); + } + } +} + +static void LinkPartnerDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + LinkPartnerBufferExecCompleted(); + } + break; + } +} + +static void LinkPartnerHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; + sub_817C95C(*stringId); +} + +static void LinkPartnerHandlePrintStringPlayerOnly(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleChooseAction(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleUnknownYesNoBox(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleChooseMove(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleChooseItem(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleChoosePokemon(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd23(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void LinkPartnerHandleExpUpdate(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void LinkPartnerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void LinkPartnerHandleStatusXor(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleDataTransfer(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleDMA3Transfer(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandlePlayBGM(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd32(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleTwoReturnValues(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleChosenMonReturnValue(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleOneReturnValue(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleOneReturnValue_Duplicate(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + LinkPartnerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void LinkPartnerHandleCmd42(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, -25, 5); + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + u32 trainerPicId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + gSprites[gBankSpriteIds[gActiveBank]].data5 = gActiveBank; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_805CC00); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + + paletteNum = AllocSpritePalette(0xD6F9); + + if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_LEAF_GREEN) + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender + BACK_PIC_RED; + } + else if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_SAPPHIRE) + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender + BACK_PIC_RS_BRENDAN; + } + else + { + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender; + } + + LoadCompressedPalette(gTrainerBackPicPaletteTable[trainerPicId].data, 0x100 + paletteNum * 16, 32); + + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = paletteNum; + + taskId = CreateTask(sub_814DCCC, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_112; +} + +static void sub_814DCCC(u8 taskId) +{ + if (gTasks[taskId].data[1] < 24) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_814CC98(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_814CC98(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_814CC98(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_814B0E8; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +static void LinkPartnerHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + LinkPartnerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_814DE9C; + } +} + +static void sub_814DE9C(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + LinkPartnerBufferExecCompleted(); + } +} + +static void LinkPartnerHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd50(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + LinkPartnerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + + sub_817E32C(animationId); + } +} + +static void LinkPartnerHandleLinkStandbyMsg(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][2]); + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleResetActionMoveSelection(void) +{ + LinkPartnerBufferExecCompleted(); +} + +static void LinkPartnerHandleCmd55(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][4]); + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + gSaveBlock2Ptr->field_CA9_b = gBattleBufferA[gActiveBank][2]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + LinkPartnerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_113(void) +{ +} diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index efedf52b6..0b0f1e626 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -1716,7 +1716,7 @@ static void RecordedPlayerHandleIntroTrainerBallThrow(void) paletteNum = AllocSpritePalette(0xD6F9); if (gBattleTypeFlags & BATTLE_TYPE_x2000000) - trainerPicId = gLinkPlayers[sub_806D864(gActiveBank)].gender; + trainerPicId = gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender; else trainerPicId = gSaveBlock2Ptr->playerGender; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index bf6962b1b..ee835586b 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -1226,9 +1226,9 @@ void EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8* arg4) void EmitCmd23(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_23; - gBattleBuffersTransferData[1] = 23; - gBattleBuffersTransferData[2] = 23; - gBattleBuffersTransferData[3] = 23; + gBattleBuffersTransferData[1] = CONTROLLER_23; + gBattleBuffersTransferData[2] = CONTROLLER_23; + gBattleBuffersTransferData[3] = CONTROLLER_23; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1289,7 +1289,7 @@ void EmitDataTransfer(u8 bufferId, u16 size, void *data) s32 i; gBattleBuffersTransferData[0] = CONTROLLER_DATATRANSFER; - gBattleBuffersTransferData[1] = 29; + gBattleBuffersTransferData[1] = CONTROLLER_DATATRANSFER; gBattleBuffersTransferData[2] = size; gBattleBuffersTransferData[3] = (size & 0xFF00) >> 8; for (i = 0; i < size; i++) @@ -1421,9 +1421,9 @@ void EmitHitAnimation(u8 bufferId) void EmitCmd42(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_42; - gBattleBuffersTransferData[1] = 42; - gBattleBuffersTransferData[2] = 42; - gBattleBuffersTransferData[3] = 42; + gBattleBuffersTransferData[1] = CONTROLLER_42; + gBattleBuffersTransferData[2] = CONTROLLER_42; + gBattleBuffersTransferData[3] = CONTROLLER_42; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1448,9 +1448,9 @@ void EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM) void EmitFaintingCry(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY; - gBattleBuffersTransferData[1] = 45; - gBattleBuffersTransferData[2] = 45; - gBattleBuffersTransferData[3] = 45; + gBattleBuffersTransferData[1] = CONTROLLER_FAINTINGCRY; + gBattleBuffersTransferData[2] = CONTROLLER_FAINTINGCRY; + gBattleBuffersTransferData[3] = CONTROLLER_FAINTINGCRY; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1464,9 +1464,9 @@ void EmitIntroSlide(u8 bufferId, u8 terrainId) void EmitIntroTrainerBallThrow(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW; - gBattleBuffersTransferData[1] = 47; - gBattleBuffersTransferData[2] = 47; - gBattleBuffersTransferData[3] = 47; + gBattleBuffersTransferData[1] = CONTROLLER_INTROTRAINERBALLTHROW; + gBattleBuffersTransferData[2] = CONTROLLER_INTROTRAINERBALLTHROW; + gBattleBuffersTransferData[3] = CONTROLLER_INTROTRAINERBALLTHROW; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1477,7 +1477,7 @@ void EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 gBattleBuffersTransferData[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; gBattleBuffersTransferData[1] = arg2 & 0x7F; gBattleBuffersTransferData[2] = (arg2 & 0x80) >> 7; - gBattleBuffersTransferData[3] = 48; + gBattleBuffersTransferData[3] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; for (i = 0; i < (s32)(sizeof(struct HpAndStatus) * 6); i++) gBattleBuffersTransferData[4 + i] = *(i + (u8*)(hpAndStatus)); PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct HpAndStatus) * 6 + 4); @@ -1486,18 +1486,18 @@ void EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 void EmitCmd49(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_49; - gBattleBuffersTransferData[1] = 49; - gBattleBuffersTransferData[2] = 49; - gBattleBuffersTransferData[3] = 49; + gBattleBuffersTransferData[1] = CONTROLLER_49; + gBattleBuffersTransferData[2] = CONTROLLER_49; + gBattleBuffersTransferData[3] = CONTROLLER_49; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } void EmitCmd50(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_50; - gBattleBuffersTransferData[1] = 50; - gBattleBuffersTransferData[2] = 50; - gBattleBuffersTransferData[3] = 50; + gBattleBuffersTransferData[1] = CONTROLLER_50; + gBattleBuffersTransferData[2] = CONTROLLER_50; + gBattleBuffersTransferData[3] = CONTROLLER_50; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1505,8 +1505,8 @@ void EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible) { gBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY; gBattleBuffersTransferData[1] = isInvisible; - gBattleBuffersTransferData[2] = 51; - gBattleBuffersTransferData[3] = 51; + gBattleBuffersTransferData[2] = CONTROLLER_SPRITEINVISIBILITY; + gBattleBuffersTransferData[3] = CONTROLLER_SPRITEINVISIBILITY; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } diff --git a/src/battle_message.c b/src/battle_message.c index d0c7b118d..52c0c7af5 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -1858,16 +1858,16 @@ u32 BattleStringExpandPlaceholders(const u8* src, u8* dst) toCpy = gLinkPlayers[multiplayerID].name; break; case B_TXT_1F: // link partner name? - toCpy = gLinkPlayers[sub_806D864(2 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + toCpy = gLinkPlayers[GetBankMultiplayerId(2 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; break; case B_TXT_20: // link opponent 1 name? - toCpy = gLinkPlayers[sub_806D864(1 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + toCpy = gLinkPlayers[GetBankMultiplayerId(1 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; break; case B_TXT_21: // link opponent 2 name? - toCpy = gLinkPlayers[sub_806D864(3 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + toCpy = gLinkPlayers[GetBankMultiplayerId(3 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; break; case B_TXT_22: // link scripting active name - toCpy = gLinkPlayers[sub_806D864(gBattleScripting.bank)].name; + toCpy = gLinkPlayers[GetBankMultiplayerId(gBattleScripting.bank)].name; break; case B_TXT_PLAYER_NAME: // player name if (gBattleTypeFlags & BATTLE_TYPE_RECORDED) diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index b2afd9837..6dfc848d7 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -5463,7 +5463,7 @@ static void atk4F_jump_if_cannot_switch(void) party = gPlayerParty; val = 0; - if (sub_806D82C(sub_806D864(gActiveBank)) == TRUE) + if (sub_806D82C(GetBankMultiplayerId(gActiveBank)) == TRUE) val = 3; } else @@ -5485,7 +5485,7 @@ static void atk4F_jump_if_cannot_switch(void) val = 0; - if (sub_806D82C(sub_806D864(gActiveBank)) == TRUE) + if (sub_806D82C(GetBankMultiplayerId(gActiveBank)) == TRUE) val = 3; } @@ -7933,7 +7933,7 @@ static void atk8F_forcerandomswitch(void) else if ((gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) || (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_x2000000)) { - if (sub_806D82C(sub_806D864(gBankTarget)) == 1) + if (sub_806D82C(GetBankMultiplayerId(gBankTarget)) == 1) { firstMonId = 3; lastMonId = 6; diff --git a/src/battle_util.c b/src/battle_util.c index 0a0badb33..468b2c46d 100644 --- a/src/battle_util.c +++ b/src/battle_util.c @@ -1729,7 +1729,7 @@ bool8 sub_80423F4(u8 bank, u8 r1, u8 r2) if (GetBankSide(bank) == SIDE_PLAYER) { party = gPlayerParty; - r7 = sub_806D864(bank); + r7 = GetBankMultiplayerId(bank); r6 = sub_806D82C(r7); } else @@ -1748,7 +1748,7 @@ bool8 sub_80423F4(u8 bank, u8 r1, u8 r2) } else { - r7 = sub_806D864(bank); + r7 = GetBankMultiplayerId(bank); if (GetBankSide(bank) == SIDE_PLAYER) party = gPlayerParty; else diff --git a/src/pokemon_3.c b/src/pokemon_3.c index aa45c3d24..73d23fe6f 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -618,7 +618,7 @@ bool16 sub_806D82C(u8 id) return retVal; } -s32 sub_806D864(u16 a1) +s32 GetBankMultiplayerId(u16 a1) { s32 id; for (id = 0; id < MAX_LINK_PLAYERS; id++) @@ -1477,7 +1477,7 @@ const u8* GetTrainerPartnerName(void) else { u8 id = GetMultiplayerId(); - return gLinkPlayers[sub_806D864(gLinkPlayers[id].lp_field_18 ^ 2)].name; + return gLinkPlayers[GetBankMultiplayerId(gLinkPlayers[id].lp_field_18 ^ 2)].name; } } -- cgit v1.2.3 From bffcd426cf1414287443c67d955fb36b861dbd91 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 24 Oct 2017 15:25:20 +0200 Subject: link opponent controller is done --- src/battle_controller_link_opponent.c | 1903 +++++++++++++++++++++++++++++++ src/battle_controller_link_partner.c | 5 +- src/battle_controller_linkopponent.c | 143 --- src/battle_controller_player.c | 6 +- src/battle_controller_player_partner.c | 4 +- src/battle_controller_recorded_player.c | 2 +- 6 files changed, 1911 insertions(+), 152 deletions(-) create mode 100644 src/battle_controller_link_opponent.c delete mode 100644 src/battle_controller_linkopponent.c (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c new file mode 100644 index 000000000..084a84d0b --- /dev/null +++ b/src/battle_controller_link_opponent.c @@ -0,0 +1,1903 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "battle_ai_script_commands.h" +#include "battle_link_817C95C.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u16 gUnknown_020243FC; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gPartnerTrainerId; +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_020244B4[]; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern struct UnusedControllerStruct gUnknown_02022D0C; +extern u16 gTrainerBattleOpponent_A; +extern u16 gTrainerBattleOpponent_B; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; +extern const u8 gUnknown_0831F578[]; + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); +extern void sub_81851A8(u8 *); +extern u16 sub_8068B48(void); + +// this file's functions +static void LinkOpponentHandleGetMonData(void); +static void LinkOpponentHandleGetRawMonData(void); +static void LinkOpponentHandleSetMonData(void); +static void LinkOpponentHandleSetRawMonData(void); +static void LinkOpponentHandleLoadMonSprite(void); +static void LinkOpponentHandleSwitchInAnim(void); +static void LinkOpponentHandleReturnMonToBall(void); +static void LinkOpponentHandleDrawTrainerPic(void); +static void LinkOpponentHandleTrainerSlide(void); +static void LinkOpponentHandleTrainerSlideBack(void); +static void LinkOpponentHandleFaintAnimation(void); +static void LinkOpponentHandlePaletteFade(void); +static void LinkOpponentHandleSuccessBallThrowAnim(void); +static void LinkOpponentHandleBallThrowAnim(void); +static void LinkOpponentHandlePause(void); +static void LinkOpponentHandleMoveAnimation(void); +static void LinkOpponentHandlePrintString(void); +static void LinkOpponentHandlePrintStringPlayerOnly(void); +static void LinkOpponentHandleChooseAction(void); +static void LinkOpponentHandleUnknownYesNoBox(void); +static void LinkOpponentHandleChooseMove(void); +static void LinkOpponentHandleChooseItem(void); +static void LinkOpponentHandleChoosePokemon(void); +static void LinkOpponentHandleCmd23(void); +static void LinkOpponentHandleHealthBarUpdate(void); +static void LinkOpponentHandleExpUpdate(void); +static void LinkOpponentHandleStatusIconUpdate(void); +static void LinkOpponentHandleStatusAnimation(void); +static void LinkOpponentHandleStatusXor(void); +static void LinkOpponentHandleDataTransfer(void); +static void LinkOpponentHandleDMA3Transfer(void); +static void LinkOpponentHandlePlayBGM(void); +static void LinkOpponentHandleCmd32(void); +static void LinkOpponentHandleTwoReturnValues(void); +static void LinkOpponentHandleChosenMonReturnValue(void); +static void LinkOpponentHandleOneReturnValue(void); +static void LinkOpponentHandleOneReturnValue_Duplicate(void); +static void LinkOpponentHandleCmd37(void); +static void LinkOpponentHandleCmd38(void); +static void LinkOpponentHandleCmd39(void); +static void LinkOpponentHandleCmd40(void); +static void LinkOpponentHandleHitAnimation(void); +static void LinkOpponentHandleCmd42(void); +static void LinkOpponentHandleEffectivenessSound(void); +static void LinkOpponentHandlePlayFanfareOrBGM(void); +static void LinkOpponentHandleFaintingCry(void); +static void LinkOpponentHandleIntroSlide(void); +static void LinkOpponentHandleIntroTrainerBallThrow(void); +static void LinkOpponentHandleDrawPartyStatusSummary(void); +static void LinkOpponentHandleCmd49(void); +static void LinkOpponentHandleCmd50(void); +static void LinkOpponentHandleSpriteInvisibility(void); +static void LinkOpponentHandleBattleAnimation(void); +static void LinkOpponentHandleLinkStandbyMsg(void); +static void LinkOpponentHandleResetActionMoveSelection(void); +static void LinkOpponentHandleCmd55(void); +static void nullsub_92(void); + +static void LinkOpponentBufferRunCommand(void); +static void LinkOpponentBufferExecCompleted(void); +static void sub_8064DD0(void); +static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst); +static void SetLinkOpponentMonData(u8 monId); +static void sub_8066494(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void LinkOpponentDoMoveAnimation(void); +static void sub_8067618(u8 taskId); +static void sub_80676FC(struct Sprite *sprite); +static void sub_806782C(void); + +static void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + LinkOpponentHandleGetMonData, + LinkOpponentHandleGetRawMonData, + LinkOpponentHandleSetMonData, + LinkOpponentHandleSetRawMonData, + LinkOpponentHandleLoadMonSprite, + LinkOpponentHandleSwitchInAnim, + LinkOpponentHandleReturnMonToBall, + LinkOpponentHandleDrawTrainerPic, + LinkOpponentHandleTrainerSlide, + LinkOpponentHandleTrainerSlideBack, + LinkOpponentHandleFaintAnimation, + LinkOpponentHandlePaletteFade, + LinkOpponentHandleSuccessBallThrowAnim, + LinkOpponentHandleBallThrowAnim, + LinkOpponentHandlePause, + LinkOpponentHandleMoveAnimation, + LinkOpponentHandlePrintString, + LinkOpponentHandlePrintStringPlayerOnly, + LinkOpponentHandleChooseAction, + LinkOpponentHandleUnknownYesNoBox, + LinkOpponentHandleChooseMove, + LinkOpponentHandleChooseItem, + LinkOpponentHandleChoosePokemon, + LinkOpponentHandleCmd23, + LinkOpponentHandleHealthBarUpdate, + LinkOpponentHandleExpUpdate, + LinkOpponentHandleStatusIconUpdate, + LinkOpponentHandleStatusAnimation, + LinkOpponentHandleStatusXor, + LinkOpponentHandleDataTransfer, + LinkOpponentHandleDMA3Transfer, + LinkOpponentHandlePlayBGM, + LinkOpponentHandleCmd32, + LinkOpponentHandleTwoReturnValues, + LinkOpponentHandleChosenMonReturnValue, + LinkOpponentHandleOneReturnValue, + LinkOpponentHandleOneReturnValue_Duplicate, + LinkOpponentHandleCmd37, + LinkOpponentHandleCmd38, + LinkOpponentHandleCmd39, + LinkOpponentHandleCmd40, + LinkOpponentHandleHitAnimation, + LinkOpponentHandleCmd42, + LinkOpponentHandleEffectivenessSound, + LinkOpponentHandlePlayFanfareOrBGM, + LinkOpponentHandleFaintingCry, + LinkOpponentHandleIntroSlide, + LinkOpponentHandleIntroTrainerBallThrow, + LinkOpponentHandleDrawPartyStatusSummary, + LinkOpponentHandleCmd49, + LinkOpponentHandleCmd50, + LinkOpponentHandleSpriteInvisibility, + LinkOpponentHandleBattleAnimation, + LinkOpponentHandleLinkStandbyMsg, + LinkOpponentHandleResetActionMoveSelection, + LinkOpponentHandleCmd55, + nullsub_92 +}; + +static void nullsub_28(void) +{ +} + +void SetBankFuncToLinkOpponentBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand; +} + +static void LinkOpponentBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gLinkOpponentBufferCommands)) + gLinkOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + LinkOpponentBufferExecCompleted(); + } +} + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + LinkOpponentBufferExecCompleted(); +} + +static void CompleteOnBankSpriteCallbackDummy2(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + LinkOpponentBufferExecCompleted(); +} + +static void sub_8064470(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + FreeTrainerFrontPicPalette(gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + LinkOpponentBufferExecCompleted(); + } +} + +static void sub_80644D8(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + LinkOpponentBufferExecCompleted(); + } +} + +static void sub_8064520(void) +{ + bool32 r8 = FALSE; + bool32 r4 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r8 = TRUE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r8 = TRUE; + } + r4 = TRUE; + } + + if (r8) + { + if (r4 || !IsAnimBankSpriteVisible(gActiveBank ^ BIT_MON)) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + return; + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + return; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + return; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + if (GetBankIdentity(gActiveBank) == IDENTITY_OPPONENT_MON2) + { + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + } + } + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_80644D8; + } +} + +static void sub_8064734(void) +{ + bool32 r10 = FALSE; + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + } + if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + { + sub_8172EF0(gActiveBank ^ BIT_MON, &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + } + + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1; + } + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40 + && !IsCryPlayingOrClearCrySongs()) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (GetBankIdentity(gActiveBank) == IDENTITY_OPPONENT_MON1) + m4aMPlayContinue(&gMPlay_BGM); + } + else + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + } + } + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1; + r10 = TRUE; + } + + if (r10) + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && GetBankIdentity(gActiveBank) == IDENTITY_OPPONENT_MON2) + { + if (++gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 1) + return; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + } + + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + SetBankEnemyShadowSpriteCallback(gActiveBank ^ BIT_MON, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], MON_DATA_SPECIES)); + } + + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0; + + gBattleBankFunc[gActiveBank] = sub_8064520; + } + } +} + +static void sub_8064B04(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80) + { + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + } + else + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + LinkOpponentBufferExecCompleted(); + } + } + } +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + LinkOpponentBufferExecCompleted(); + } +} + +static void sub_8064C14(void) +{ + if (!gSprites[gBankSpriteIds[gActiveBank]].inUse) + { + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkOpponentBufferExecCompleted(); + } +} + +static void sub_8064C58(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkOpponentBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + LinkOpponentBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + LinkOpponentBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_8064D60(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + + gBattleBankFunc[gActiveBank] = sub_8064DD0; + } +} + +static void sub_8064DD0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive && !IsCryPlayingOrClearCrySongs()) + { + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + || gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy_2) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + LinkOpponentBufferExecCompleted(); + } + } +} + +static void sub_8064E50(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_8064D60; + } +} + +static void sub_8064F40(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80) + { + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_8064E50; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + LinkOpponentBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void LinkOpponentHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyLinkOpponentMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyLinkOpponentMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + LinkOpponentBufferExecCompleted(); +} + +static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + battleMon.spAttackIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gEnemyParty[monId], MON_DATA_SPD); + battleMon.spAttack = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gEnemyParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gEnemyParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + GetMonData(&gEnemyParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gEnemyParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + dst[4] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPD); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void LinkOpponentHandleGetRawMonData(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetLinkOpponentMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetLinkOpponentMonData(i); + monsToCheck >>= 1; + } + } + LinkOpponentBufferExecCompleted(); +} + +static void SetLinkOpponentMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gEnemyParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } +} + +static void LinkOpponentHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleLoadMonSprite(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + + + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + gBattleBankFunc[gActiveBank] = sub_8064B04; +} + +static void LinkOpponentHandleSwitchInAnim(void) +{ + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_8066494(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_8064F40; +} + +static void sub_8066494(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite( + &gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFE); +} + +static void LinkOpponentHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + LinkOpponentBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_OPPONENT_MON); + gBattleBankFunc[gActiveBank] = sub_8064C58; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +static void LinkOpponentHandleDrawTrainerPic(void) +{ + s16 xPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 152; + else // first mon + xPos = 200; + + if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + { + if (gActiveBank == 1) + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + else + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); + } + else + { + if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_LEAF_GREEN) + { + if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) + trainerPicId = gUnknown_0831F578[0x4F]; + else + trainerPicId = gUnknown_0831F578[0x4E]; + } + else if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_SAPPHIRE) + { + if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) + trainerPicId = gUnknown_0831F578[0x51]; + else + trainerPicId = gUnknown_0831F578[0x50]; + } + else + { + trainerPicId = PlayerGenderToFrontTrainerPicId(gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender); + } + } + } + else + { + xPos = 176; + if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + { + trainerPicId = sub_8068B48(); + } + else if ((gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_LEAF_GREEN) + { + if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) + trainerPicId = gUnknown_0831F578[0x4F]; + else + trainerPicId = gUnknown_0831F578[0x4E]; + } + else if ((gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_SAPPHIRE) + { + if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) + trainerPicId = gUnknown_0831F578[0x51]; + else + trainerPicId = gUnknown_0831F578[0x50]; + } + else + { + trainerPicId = PlayerGenderToFrontTrainerPicId(gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender); + } + } + + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + xPos, + (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 40, + sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = 2; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam = trainerPicId; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void LinkOpponentHandleTrainerSlide(void) +{ + u32 trainerPicId; + + if (gActiveBank == 1) + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + else + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); + + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, 176, (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 40, 0x1E); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 96; + gSprites[gBankSpriteIds[gActiveBank]].pos1.x += 32; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam = trainerPicId; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; // this line is redundant, because LinkOpponentBufferExecCompleted changes the battle bank function + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_8064470; +} + +static void LinkOpponentHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT); + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039934; + gBattleBankFunc[gActiveBank] = sub_8064C14; + } + } +} + +static void LinkOpponentHandlePaletteFade(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleSuccessBallThrowAnim(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleBallThrowAnim(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandlePause(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + LinkOpponentBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = LinkOpponentDoMoveAnimation; + sub_817E0FC(move, gWeatherMoveAnim, gAnimDisableStructPtr); + } + } +} + +static void LinkOpponentDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + LinkOpponentBufferExecCompleted(); + } + break; + } +} + +static void LinkOpponentHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; + sub_817C95C(*stringId); +} + +static void LinkOpponentHandlePrintStringPlayerOnly(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleChooseAction(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleUnknownYesNoBox(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleChooseMove(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleChooseItem(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleChoosePokemon(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd23(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void LinkOpponentHandleExpUpdate(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void LinkOpponentHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void LinkOpponentHandleStatusXor(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleDataTransfer(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleDMA3Transfer(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandlePlayBGM(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd32(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleTwoReturnValues(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleChosenMonReturnValue(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleOneReturnValue(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleOneReturnValue_Duplicate(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + LinkOpponentBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void LinkOpponentHandleCmd42(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleFaintingCry(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, 25, 5); + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_80676FC); + + taskId = CreateTask(sub_8067618, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_28; +} + +static void sub_8067618(u8 taskId) +{ + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8066494(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8066494(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8066494(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_8064734; + gActiveBank = savedActiveBank; + DestroyTask(taskId); +} + +static void sub_80676FC(struct Sprite *sprite) +{ + FreeTrainerFrontPicPalette(sprite->oam.affineParam); + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); +} + +static void LinkOpponentHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + LinkOpponentBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + + if (gBattleBufferA[gActiveBank][2] != 0) + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E < 2) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E++; + return; + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E = 0; + } + } + + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_806782C; + } +} + +static void sub_806782C(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + LinkOpponentBufferExecCompleted(); + } +} + +static void LinkOpponentHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd50(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + LinkOpponentBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + + sub_817E32C(animationId); + } +} + +static void LinkOpponentHandleLinkStandbyMsg(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][2]); + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleResetActionMoveSelection(void) +{ + LinkOpponentBufferExecCompleted(); +} + +static void LinkOpponentHandleCmd55(void) +{ + sub_81851A8(&gBattleBufferA[gActiveBank][4]); + + if (gBattleBufferA[gActiveBank][1] == BATTLE_DREW) + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + else + gBattleOutcome = gBattleBufferA[gActiveBank][1] ^ BATTLE_DREW; + + gSaveBlock2Ptr->field_CA9_b = gBattleBufferA[gActiveBank][2]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + LinkOpponentBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_92(void) +{ +} diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 07bab9d5f..2c5cdd6d9 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -40,7 +40,6 @@ extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; extern u8 gBattleOutcome; extern u16 gBattle_BG0_X; extern u16 gBattle_BG0_Y; -extern u8 gBankInMenu; extern u16 gUnknown_020243FC; extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; @@ -1129,7 +1128,7 @@ static void DoSwitchOutAnimation(void) if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; - DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_PLAYER_MON); gBattleBankFunc[gActiveBank] = sub_814B3DC; } break; @@ -1221,7 +1220,7 @@ static void LinkPartnerHandleFaintAnimation(void) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlaySE12WithPanning(SE_POKE_DEAD, -64); + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER); gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; diff --git a/src/battle_controller_linkopponent.c b/src/battle_controller_linkopponent.c deleted file mode 100644 index fb21865ca..000000000 --- a/src/battle_controller_linkopponent.c +++ /dev/null @@ -1,143 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_controllers.h" -#include "battle_message.h" -#include "battle_interface.h" -#include "battle_anim.h" -#include "link.h" - -extern u8 gActiveBank; -extern bool8 gDoingBattleAnim; -extern u8 gUnknown_020244CC; -extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); - -// this file's functions -void LinkOpponentHandleGetMonData(void); -void LinkOpponentHandleGetRawMonData(void); -void LinkOpponentHandleSetMonData(void); -void LinkOpponentHandleSetRawMonData(void); -void LinkOpponentHandleLoadMonSprite(void); -void LinkOpponentHandleSwitchInAnim(void); -void LinkOpponentHandleReturnMonToBall(void); -void LinkOpponentHandleDrawTrainerPic(void); -void LinkOpponentHandleTrainerSlide(void); -void LinkOpponentHandleTrainerSlideBack(void); -void LinkOpponentHandleFaintAnimation(void); -void LinkOpponentHandleCmd11(void); -void LinkOpponentHandleCmd12(void); -void LinkOpponentHandleBallThrow(void); -void LinkOpponentHandlePause(void); -void LinkOpponentHandleMoveAnimation(void); -void LinkOpponentHandlePrintString(void); -void LinkOpponentHandlePrintStringPlayerOnly(void); -void LinkOpponentHandleChooseAction(void); -void LinkOpponentHandleCmd19(void); -void LinkOpponentHandleChooseMove(void); -void LinkOpponentHandleOpenBag(void); -void LinkOpponentHandleChoosePokemon(void); -void LinkOpponentHandleCmd23(void); -void LinkOpponentHandleHealthBarUpdate(void); -void LinkOpponentHandleExpUpdate(void); -void LinkOpponentHandleStatusIconUpdate(void); -void LinkOpponentHandleStatusAnimation(void); -void LinkOpponentHandleStatusXor(void); -void LinkOpponentHandleDataTransfer(void); -void LinkOpponentHandleDMA3Transfer(void); -void LinkOpponentHandlePlayBGM(void); -void LinkOpponentHandleCmd32(void); -void LinkOpponentHandleCmd33(void); -void LinkOpponentHandleCmd34(void); -void LinkOpponentHandleCmd35(void); -void LinkOpponentHandleCmd36(void); -void LinkOpponentHandleCmd37(void); -void LinkOpponentHandleCmd38(void); -void LinkOpponentHandleCmd39(void); -void LinkOpponentHandleCmd40(void); -void LinkOpponentHandleHitAnimation(void); -void LinkOpponentHandleCmd42(void); -void LinkOpponentHandleEffectivenessSound(void); -void LinkOpponentHandlePlayFanfareOrBGM(void); -void LinkOpponentHandleFaintingCry(void); -void LinkOpponentHandleIntroSlide(void); -void LinkOpponentHandleIntroTrainerBallThrow(void); -void LinkOpponentHandleDrawPartyStatusSummary(void); -void LinkOpponentHandleCmd49(void); -void LinkOpponentHandleCmd50(void); -void LinkOpponentHandleSpriteInvisibility(void); -void LinkOpponentHandleBattleAnimation(void); -void LinkOpponentHandleLinkStandbyMsg(void); -void LinkOpponentHandleResetActionMoveSelection(void); -void LinkOpponentHandleCmd55(void); -void nullsub_92(void); - -void LinkOpponentBufferRunCommand(void); - -void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = -{ - LinkOpponentHandleGetMonData, - LinkOpponentHandleGetRawMonData, - LinkOpponentHandleSetMonData, - LinkOpponentHandleSetRawMonData, - LinkOpponentHandleLoadMonSprite, - LinkOpponentHandleSwitchInAnim, - LinkOpponentHandleReturnMonToBall, - LinkOpponentHandleDrawTrainerPic, - LinkOpponentHandleTrainerSlide, - LinkOpponentHandleTrainerSlideBack, - LinkOpponentHandleFaintAnimation, - LinkOpponentHandleCmd11, - LinkOpponentHandleCmd12, - LinkOpponentHandleBallThrow, - LinkOpponentHandlePause, - LinkOpponentHandleMoveAnimation, - LinkOpponentHandlePrintString, - LinkOpponentHandlePrintStringPlayerOnly, - LinkOpponentHandleChooseAction, - LinkOpponentHandleCmd19, - LinkOpponentHandleChooseMove, - LinkOpponentHandleOpenBag, - LinkOpponentHandleChoosePokemon, - LinkOpponentHandleCmd23, - LinkOpponentHandleHealthBarUpdate, - LinkOpponentHandleExpUpdate, - LinkOpponentHandleStatusIconUpdate, - LinkOpponentHandleStatusAnimation, - LinkOpponentHandleStatusXor, - LinkOpponentHandleDataTransfer, - LinkOpponentHandleDMA3Transfer, - LinkOpponentHandlePlayBGM, - LinkOpponentHandleCmd32, - LinkOpponentHandleCmd33, - LinkOpponentHandleCmd34, - LinkOpponentHandleCmd35, - LinkOpponentHandleCmd36, - LinkOpponentHandleCmd37, - LinkOpponentHandleCmd38, - LinkOpponentHandleCmd39, - LinkOpponentHandleCmd40, - LinkOpponentHandleHitAnimation, - LinkOpponentHandleCmd42, - LinkOpponentHandleEffectivenessSound, - LinkOpponentHandlePlayFanfareOrBGM, - LinkOpponentHandleFaintingCry, - LinkOpponentHandleIntroSlide, - LinkOpponentHandleIntroTrainerBallThrow, - LinkOpponentHandleDrawPartyStatusSummary, - LinkOpponentHandleCmd49, - LinkOpponentHandleCmd50, - LinkOpponentHandleSpriteInvisibility, - LinkOpponentHandleBattleAnimation, - LinkOpponentHandleLinkStandbyMsg, - LinkOpponentHandleResetActionMoveSelection, - LinkOpponentHandleCmd55, - nullsub_92 -}; - -void nullsub_28(void) -{ -} - -void SetBankFuncToLinkOpponentBufferRunCommand(void) -{ - gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand; -} diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b022d3f87..cbf924235 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -2285,7 +2285,7 @@ static void DoSwitchOutAnimation(void) if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; - DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_PLAYER_MON); gBattleBankFunc[gActiveBank] = sub_8059744; } break; @@ -2453,7 +2453,7 @@ static void PlayerHandleFaintAnimation(void) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlaySE12WithPanning(SE_POKE_DEAD, -64); + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER); gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; @@ -2911,7 +2911,7 @@ static void PlayerHandleHitAnimation(void) } else { - gDoingBattleAnim = 1; + gDoingBattleAnim = TRUE; gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; DoHitAnimHealthboxEffect(gActiveBank); gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 25eaf773f..82f358921 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -1315,7 +1315,7 @@ static void DoSwitchOutAnimation(void) if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; - DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_PLAYER_MON); gBattleBankFunc[gActiveBank] = sub_81BB828; } break; @@ -1414,7 +1414,7 @@ static void PlayerPartnerHandleFaintAnimation(void) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlaySE12WithPanning(SE_POKE_DEAD, -64); + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_PLAYER); gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; gSprites[gBankSpriteIds[gActiveBank]].data2 = 5; gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039C00; diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 0b0f1e626..429edf9f7 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -1213,7 +1213,7 @@ static void DoSwitchOutAnimation(void) if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; - DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_MON); + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_PLAYER_MON); gBattleBankFunc[gActiveBank] = sub_818A1B0; } break; -- cgit v1.2.3 From 94b3a8dd69699f7a127cf27282c06ca8a27d0a63 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 24 Oct 2017 15:35:36 +0200 Subject: spd to speed --- src/battle_controller_link_opponent.c | 24 ++++++++++++------------ src/battle_controller_link_partner.c | 24 ++++++++++++------------ src/battle_controller_player.c | 24 ++++++++++++------------ src/battle_controller_player_partner.c | 24 ++++++++++++------------ src/battle_controller_recorded_player.c | 24 ++++++++++++------------ src/pokemon_1.c | 4 ++-- src/pokemon_2.c | 4 ++-- 7 files changed, 64 insertions(+), 64 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 084a84d0b..c7613001b 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -621,7 +621,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) battleMon.hpIV = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); battleMon.attackIV = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); battleMon.defenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); - battleMon.speedIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + battleMon.speedIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); battleMon.spAttackIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); battleMon.spDefenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); battleMon.personality = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); @@ -631,7 +631,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) battleMon.maxHP = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); battleMon.attack = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); battleMon.defense = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); - battleMon.speed = GetMonData(&gEnemyParty[monId], MON_DATA_SPD); + battleMon.speed = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); battleMon.spAttack = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); battleMon.spDefense = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); battleMon.isEgg = GetMonData(&gEnemyParty[monId], MON_DATA_IS_EGG); @@ -716,7 +716,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_EV_BATTLE: - dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_EV); + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV); size = 1; break; case REQUEST_SPATK_EV_BATTLE: @@ -755,7 +755,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); dst[1] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); dst[2] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); - dst[3] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + dst[3] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); dst[4] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); dst[5] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); size = 6; @@ -773,7 +773,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_IV_BATTLE: - dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV); + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); size = 1; break; case REQUEST_SPATK_IV_BATTLE: @@ -835,7 +835,7 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst) size = 2; break; case REQUEST_SPEED_BATTLE: - data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPD); + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); dst[0] = data16; dst[1] = data16 >> 8; size = 2; @@ -957,7 +957,7 @@ static void SetLinkOpponentMonData(u8 monId) iv = battlePokemon->defenseIV; SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &iv); iv = battlePokemon->speedIV; - SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &iv); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &iv); iv = battlePokemon->spAttackIV; SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &iv); iv = battlePokemon->spDefenseIV; @@ -969,7 +969,7 @@ static void SetLinkOpponentMonData(u8 monId) SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &battlePokemon->attack); SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &battlePokemon->defense); - SetMonData(&gEnemyParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &battlePokemon->speed); SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); } @@ -1023,7 +1023,7 @@ static void SetLinkOpponentMonData(u8 monId) SetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_EV_BATTLE: - SetMonData(&gEnemyParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_EV_BATTLE: SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); @@ -1053,7 +1053,7 @@ static void SetLinkOpponentMonData(u8 monId) SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); break; @@ -1067,7 +1067,7 @@ static void SetLinkOpponentMonData(u8 monId) SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_IV_BATTLE: - SetMonData(&gEnemyParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_IV_BATTLE: SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); @@ -1100,7 +1100,7 @@ static void SetLinkOpponentMonData(u8 monId) SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_BATTLE: - SetMonData(&gEnemyParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_BATTLE: SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 2c5cdd6d9..d5ce7ef70 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -503,7 +503,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); @@ -513,7 +513,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); - battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); @@ -598,7 +598,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_EV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV); size = 1; break; case REQUEST_SPATK_EV_BATTLE: @@ -637,7 +637,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); size = 6; @@ -655,7 +655,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_IV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); size = 1; break; case REQUEST_SPATK_IV_BATTLE: @@ -717,7 +717,7 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst) size = 2; break; case REQUEST_SPEED_BATTLE: - data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); dst[0] = data16; dst[1] = data16 >> 8; size = 2; @@ -839,7 +839,7 @@ static void SetLinkPartnerMonData(u8 monId) iv = battlePokemon->defenseIV; SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &iv); iv = battlePokemon->spAttackIV; SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); iv = battlePokemon->spDefenseIV; @@ -851,7 +851,7 @@ static void SetLinkPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &battlePokemon->speed); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); } @@ -905,7 +905,7 @@ static void SetLinkPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_EV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_EV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); @@ -935,7 +935,7 @@ static void SetLinkPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); break; @@ -949,7 +949,7 @@ static void SetLinkPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_IV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_IV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); @@ -982,7 +982,7 @@ static void SetLinkPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index cbf924235..e6c32adb5 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -1661,7 +1661,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); @@ -1671,7 +1671,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); - battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); @@ -1756,7 +1756,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_EV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV); size = 1; break; case REQUEST_SPATK_EV_BATTLE: @@ -1795,7 +1795,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); size = 6; @@ -1813,7 +1813,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_IV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); size = 1; break; case REQUEST_SPATK_IV_BATTLE: @@ -1875,7 +1875,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst) size = 2; break; case REQUEST_SPEED_BATTLE: - data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); dst[0] = data16; dst[1] = data16 >> 8; size = 2; @@ -2006,7 +2006,7 @@ static void SetPlayerMonData(u8 monId) iv = battlePokemon->defenseIV; SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &iv); iv = battlePokemon->spAttackIV; SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); iv = battlePokemon->spDefenseIV; @@ -2018,7 +2018,7 @@ static void SetPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &battlePokemon->speed); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); } @@ -2072,7 +2072,7 @@ static void SetPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_EV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_EV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); @@ -2102,7 +2102,7 @@ static void SetPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); break; @@ -2116,7 +2116,7 @@ static void SetPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_IV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_IV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); @@ -2149,7 +2149,7 @@ static void SetPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 82f358921..34ac92e74 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -690,7 +690,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); @@ -700,7 +700,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); - battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); @@ -785,7 +785,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_EV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV); size = 1; break; case REQUEST_SPATK_EV_BATTLE: @@ -824,7 +824,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); size = 6; @@ -842,7 +842,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_IV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); size = 1; break; case REQUEST_SPATK_IV_BATTLE: @@ -904,7 +904,7 @@ static u32 CopyPlayerPartnerMonData(u8 monId, u8 *dst) size = 2; break; case REQUEST_SPEED_BATTLE: - data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); dst[0] = data16; dst[1] = data16 >> 8; size = 2; @@ -1026,7 +1026,7 @@ static void SetPlayerPartnerMonData(u8 monId) iv = battlePokemon->defenseIV; SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &iv); iv = battlePokemon->spAttackIV; SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); iv = battlePokemon->spDefenseIV; @@ -1038,7 +1038,7 @@ static void SetPlayerPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &battlePokemon->speed); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); } @@ -1092,7 +1092,7 @@ static void SetPlayerPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_EV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_EV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); @@ -1122,7 +1122,7 @@ static void SetPlayerPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); break; @@ -1136,7 +1136,7 @@ static void SetPlayerPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_IV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_IV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); @@ -1169,7 +1169,7 @@ static void SetPlayerPartnerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 429edf9f7..605268f13 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -588,7 +588,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); @@ -598,7 +598,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); - battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); @@ -683,7 +683,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_EV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV); size = 1; break; case REQUEST_SPATK_EV_BATTLE: @@ -722,7 +722,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); - dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); size = 6; @@ -740,7 +740,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) size = 1; break; case REQUEST_SPEED_IV_BATTLE: - dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV); + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); size = 1; break; case REQUEST_SPATK_IV_BATTLE: @@ -802,7 +802,7 @@ static u32 CopyRecordedPlayerMonData(u8 monId, u8 *dst) size = 2; break; case REQUEST_SPEED_BATTLE: - data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPD); + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); dst[0] = data16; dst[1] = data16 >> 8; size = 2; @@ -924,7 +924,7 @@ static void SetRecordedPlayerMonData(u8 monId) iv = battlePokemon->defenseIV; SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &iv); iv = battlePokemon->spAttackIV; SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); iv = battlePokemon->spDefenseIV; @@ -936,7 +936,7 @@ static void SetRecordedPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &battlePokemon->speed); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); } @@ -990,7 +990,7 @@ static void SetRecordedPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_EV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_EV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); @@ -1020,7 +1020,7 @@ static void SetRecordedPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); break; @@ -1034,7 +1034,7 @@ static void SetRecordedPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_IV_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_IV_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); @@ -1067,7 +1067,7 @@ static void SetRecordedPlayerMonData(u8 monId) SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPEED_BATTLE: - SetMonData(&gPlayerParty[monId], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); break; case REQUEST_SPATK_BATTLE: SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); diff --git a/src/pokemon_1.c b/src/pokemon_1.c index 79fa15343..f56ade967 100644 --- a/src/pokemon_1.c +++ b/src/pokemon_1.c @@ -305,7 +305,7 @@ void sub_806819C(struct Pokemon *mon, struct UnknownPokemonStruct *src) SetMonData(mon, MON_DATA_HP_EV, &src->hpEV); SetMonData(mon, MON_DATA_ATK_EV, &src->attackEV); SetMonData(mon, MON_DATA_DEF_EV, &src->defenseEV); - SetMonData(mon, MON_DATA_SPD_EV, &src->speedEV); + SetMonData(mon, MON_DATA_SPEED_EV, &src->speedEV); SetMonData(mon, MON_DATA_SPATK_EV, &src->spAttackEV); SetMonData(mon, MON_DATA_SPDEF_EV, &src->spDefenseEV); value = src->altAbility; @@ -369,7 +369,7 @@ void sub_8068338(struct Pokemon *mon, struct UnknownPokemonStruct *src, bool8 lv SetMonData(mon, MON_DATA_HP_EV, &src->hpEV); SetMonData(mon, MON_DATA_ATK_EV, &src->attackEV); SetMonData(mon, MON_DATA_DEF_EV, &src->defenseEV); - SetMonData(mon, MON_DATA_SPD_EV, &src->speedEV); + SetMonData(mon, MON_DATA_SPEED_EV, &src->speedEV); SetMonData(mon, MON_DATA_SPATK_EV, &src->spAttackEV); SetMonData(mon, MON_DATA_SPDEF_EV, &src->spDefenseEV); value = src->altAbility; diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 7a1f51b1c..b0ec7460d 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -513,7 +513,7 @@ u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data) case MON_DATA_DEF_EV: retVal = substruct2->defenseEV; break; - case MON_DATA_SPD_EV: + case MON_DATA_SPEED_EV: retVal = substruct2->speedEV; break; case MON_DATA_SPATK_EV: @@ -881,7 +881,7 @@ void SetBoxMonData(struct BoxPokemon *boxMon, s32 field, const void *dataArg) case MON_DATA_DEF_EV: SET8(substruct2->defenseEV); break; - case MON_DATA_SPD_EV: + case MON_DATA_SPEED_EV: SET8(substruct2->speedEV); break; case MON_DATA_SPATK_EV: -- cgit v1.2.3 From 3ece244246cbd8aa689f3e471bb0e1cb1cf0d8f7 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 24 Oct 2017 21:45:41 +0200 Subject: wally controller is done --- src/battle_controller_wally.c | 1610 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 1535 insertions(+), 75 deletions(-) (limited to 'src') diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index ce38ca882..5e454deb5 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -4,75 +4,139 @@ #include "battle_message.h" #include "battle_interface.h" #include "battle_anim.h" +#include "battle_link_817C95C.h" +#include "pokemon.h" #include "link.h" +#include "util.h" +#include "main.h" +#include "item.h" +#include "items.h" +#include "songs.h" +#include "sound.h" +#include "moves.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "rng.h" +#include "pokeball.h" +#include "party_menu.h" +extern u32 gBattleExecBuffer; extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gAbsentBankFlags; +extern u8 gNoOfAllBanks; extern bool8 gDoingBattleAnim; extern u8 gUnknown_020244CC; extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern u8 gMultiUsePlayerCursor; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u16 gPartnerTrainerId; +extern struct SpriteTemplate gUnknown_0202499C; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gScriptItemId; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u8 gNumberOfMovesToChoose; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern s32 gUnknown_0203CD70; +extern u8 gBankInMenu; +extern u32 gBattlePalaceMoveSelectionRngValue; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern u8 gUnknown_020244B4[]; +extern u16 gUnknown_020243FC; +extern struct UnusedControllerStruct gUnknown_02022D0C; + +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; + +extern const u8 gText_WhatWillWallyDo[]; +extern const u8 gText_BattleMenu[]; + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); // this file's functions -void WallyHandleGetMonData(void); -void WallyHandleGetRawMonData(void); -void WallyHandleSetMonData(void); -void WallyHandleSetRawMonData(void); -void WallyHandleLoadMonSprite(void); -void WallyHandleSwitchInAnim(void); -void WallyHandleReturnMonToBall(void); -void WallyHandleDrawTrainerPic(void); -void WallyHandleTrainerSlide(void); -void WallyHandleTrainerSlideBack(void); -void WallyHandleFaintAnimation(void); -void WallyHandleCmd11(void); -void WallyHandleCmd12(void); -void WallyHandleBallThrow(void); -void WallyHandlePause(void); -void WallyHandleMoveAnimation(void); -void WallyHandlePrintString(void); -void WallyHandlePrintStringPlayerOnly(void); -void WallyHandleChooseAction(void); -void WallyHandleCmd19(void); -void WallyHandleChooseMove(void); -void WallyHandleOpenBag(void); -void WallyHandleChoosePokemon(void); -void WallyHandleCmd23(void); -void WallyHandleHealthBarUpdate(void); -void WallyHandleExpUpdate(void); -void WallyHandleStatusIconUpdate(void); -void WallyHandleStatusAnimation(void); -void WallyHandleStatusXor(void); -void WallyHandleDataTransfer(void); -void WallyHandleDMA3Transfer(void); -void WallyHandlePlayBGM(void); -void WallyHandleCmd32(void); -void WallyHandleCmd33(void); -void WallyHandleCmd34(void); -void WallyHandleCmd35(void); -void WallyHandleCmd36(void); -void WallyHandleCmd37(void); -void WallyHandleCmd38(void); -void WallyHandleCmd39(void); -void WallyHandleCmd40(void); -void WallyHandleHitAnimation(void); -void WallyHandleCmd42(void); -void WallyHandleEffectivenessSound(void); -void WallyHandlePlayFanfareOrBGM(void); -void WallyHandleFaintingCry(void); -void WallyHandleIntroSlide(void); -void WallyHandleIntroTrainerBallThrow(void); -void WallyHandleDrawPartyStatusSummary(void); -void WallyHandleCmd49(void); -void WallyHandleCmd50(void); -void WallyHandleSpriteInvisibility(void); -void WallyHandleBattleAnimation(void); -void WallyHandleLinkStandbyMsg(void); -void WallyHandleResetActionMoveSelection(void); -void WallyHandleCmd55(void); -void nullsub_118(void); - -void WallyBufferRunCommand(void); - -void (*const gWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void WallyHandleGetMonData(void); +static void WallyHandleGetRawMonData(void); +static void WallyHandleSetMonData(void); +static void WallyHandleSetRawMonData(void); +static void WallyHandleLoadMonSprite(void); +static void WallyHandleSwitchInAnim(void); +static void WallyHandleReturnMonToBall(void); +static void WallyHandleDrawTrainerPic(void); +static void WallyHandleTrainerSlide(void); +static void WallyHandleTrainerSlideBack(void); +static void WallyHandleFaintAnimation(void); +static void WallyHandlePaletteFade(void); +static void WallyHandleSuccessBallThrowAnim(void); +static void WallyHandleBallThrowAnim(void); +static void WallyHandlePause(void); +static void WallyHandleMoveAnimation(void); +static void WallyHandlePrintString(void); +static void WallyHandlePrintStringPlayerOnly(void); +static void WallyHandleChooseAction(void); +static void WallyHandleUnknownYesNoBox(void); +static void WallyHandleChooseMove(void); +static void WallyHandleChooseItem(void); +static void WallyHandleChoosePokemon(void); +static void WallyHandleCmd23(void); +static void WallyHandleHealthBarUpdate(void); +static void WallyHandleExpUpdate(void); +static void WallyHandleStatusIconUpdate(void); +static void WallyHandleStatusAnimation(void); +static void WallyHandleStatusXor(void); +static void WallyHandleDataTransfer(void); +static void WallyHandleDMA3Transfer(void); +static void WallyHandlePlayBGM(void); +static void WallyHandleCmd32(void); +static void WallyHandleTwoReturnValues(void); +static void WallyHandleChosenMonReturnValue(void); +static void WallyHandleOneReturnValue(void); +static void WallyHandleOneReturnValue_Duplicate(void); +static void WallyHandleCmd37(void); +static void WallyHandleCmd38(void); +static void WallyHandleCmd39(void); +static void WallyHandleCmd40(void); +static void WallyHandleHitAnimation(void); +static void WallyHandleCmd42(void); +static void WallyHandleEffectivenessSound(void); +static void WallyHandlePlayFanfareOrBGM(void); +static void WallyHandleFaintingCry(void); +static void WallyHandleIntroSlide(void); +static void WallyHandleIntroTrainerBallThrow(void); +static void WallyHandleDrawPartyStatusSummary(void); +static void WallyHandleCmd49(void); +static void WallyHandleCmd50(void); +static void WallyHandleSpriteInvisibility(void); +static void WallyHandleBattleAnimation(void); +static void WallyHandleLinkStandbyMsg(void); +static void WallyHandleResetActionMoveSelection(void); +static void WallyHandleCmd55(void); +static void nullsub_118(void); + +static void WallyBufferRunCommand(void); +static void WallyBufferExecCompleted(void); +static void CompleteOnChosenItem(void); +static void sub_8168818(void); +static u32 CopyWallyMonData(u8 monId, u8 *dst); +static void SetWallyMonData(u8 monId); +static void WallyDoMoveAnimation(void); +static void sub_816AC04(u8 taskId); + +static void (*const sWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { WallyHandleGetMonData, WallyHandleGetRawMonData, @@ -85,17 +149,17 @@ void (*const gWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = WallyHandleTrainerSlide, WallyHandleTrainerSlideBack, WallyHandleFaintAnimation, - WallyHandleCmd11, - WallyHandleCmd12, - WallyHandleBallThrow, + WallyHandlePaletteFade, + WallyHandleSuccessBallThrowAnim, + WallyHandleBallThrowAnim, WallyHandlePause, WallyHandleMoveAnimation, WallyHandlePrintString, WallyHandlePrintStringPlayerOnly, WallyHandleChooseAction, - WallyHandleCmd19, + WallyHandleUnknownYesNoBox, WallyHandleChooseMove, - WallyHandleOpenBag, + WallyHandleChooseItem, WallyHandleChoosePokemon, WallyHandleCmd23, WallyHandleHealthBarUpdate, @@ -107,10 +171,10 @@ void (*const gWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = WallyHandleDMA3Transfer, WallyHandlePlayBGM, WallyHandleCmd32, - WallyHandleCmd33, - WallyHandleCmd34, - WallyHandleCmd35, - WallyHandleCmd36, + WallyHandleTwoReturnValues, + WallyHandleChosenMonReturnValue, + WallyHandleOneReturnValue, + WallyHandleOneReturnValue_Duplicate, WallyHandleCmd37, WallyHandleCmd38, WallyHandleCmd39, @@ -133,15 +197,1411 @@ void (*const gWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = nullsub_118 }; -void nullsub_117(void) +static void nullsub_117(void) { } void SetBankFuncToWallyBufferRunCommand(void) { gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; - gBattleStruct->field_94 = 0; - gBattleStruct->field_95 = 0; - gBattleStruct->field_96 = 0; - gBattleStruct->field_97 = 0; + gBattleStruct->wallyBattleState = 0; + gBattleStruct->wallyMovesState = 0; + gBattleStruct->wallyWaitFrames = 0; + gBattleStruct->wallyMoveFrames = 0; +} + +static void WallyBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sWallyBufferCommands)) + sWallyBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + WallyBufferExecCompleted(); + } +} + +static void WallyHandleActions(void) +{ + switch (gBattleStruct->wallyBattleState) + { + case 0: + gBattleStruct->wallyWaitFrames = 64; + gBattleStruct->wallyBattleState++; + case 1: + if (--gBattleStruct->wallyWaitFrames == 0) + { + PlaySE(SE_SELECT); + EmitTwoReturnValues(1, ACTION_USE_MOVE, 0); + WallyBufferExecCompleted(); + gBattleStruct->wallyBattleState++; + gBattleStruct->wallyMovesState = 0; + gBattleStruct->wallyWaitFrames = 64; + } + break; + case 2: + if (--gBattleStruct->wallyWaitFrames == 0) + { + PlaySE(SE_SELECT); + EmitTwoReturnValues(1, ACTION_USE_MOVE, 0); + WallyBufferExecCompleted(); + gBattleStruct->wallyBattleState++; + gBattleStruct->wallyMovesState = 0; + gBattleStruct->wallyWaitFrames = 64; + } + break; + case 3: + if (--gBattleStruct->wallyWaitFrames == 0) + { + EmitTwoReturnValues(1, 9, 0); + WallyBufferExecCompleted(); + gBattleStruct->wallyBattleState++; + gBattleStruct->wallyMovesState = 0; + gBattleStruct->wallyWaitFrames = 64; + } + break; + case 4: + if (--gBattleStruct->wallyWaitFrames == 0) + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(0); + ActionSelectionCreateCursorAt(1, 0); + gBattleStruct->wallyWaitFrames = 64; + gBattleStruct->wallyBattleState++; + } + break; + case 5: + if (--gBattleStruct->wallyWaitFrames == 0) + { + PlaySE(SE_SELECT); + EmitTwoReturnValues(1, ACTION_USE_ITEM, 0); + WallyBufferExecCompleted(); + } + break; + } +} + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + WallyBufferExecCompleted(); +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + WallyBufferExecCompleted(); +} + +static void CompleteOnFinishedAnimation(void) +{ + if (!gDoingBattleAnim) + WallyBufferExecCompleted(); +} + +static void OpenBagAfterPaletteFade(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = CompleteOnChosenItem; + nullsub_35(); + FreeAllWindowBuffers(); + DoWallyTutorialBagMenu(); + } +} + +static void CompleteOnChosenItem(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + EmitOneReturnValue(1, gScriptItemId); + WallyBufferExecCompleted(); + } +} + +static void sub_816864C(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + sub_8172EF0(gActiveBank ^ BIT_MON, &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8 + && gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleBankFunc[gActiveBank] = sub_8168818; + } + +} + +static void sub_8168818(void) +{ + bool32 r4 = FALSE; + + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + r4 = TRUE; + + if (r4 && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + CreateTask(c3_0802FDF4, 10); + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + + WallyBufferExecCompleted(); + } +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + WallyBufferExecCompleted(); + } +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + WallyBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_8168A20(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + WallyBufferExecCompleted(); + } +} + +static void CompleteOnBankSpriteCallbackDummy2(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + WallyBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + WallyBufferExecCompleted(); +} + +static void WallyBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + WallyBufferExecCompleted(); +} + +static void WallyHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyWallyMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyWallyMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + WallyBufferExecCompleted(); +} + +static u32 CopyWallyMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); + battleMon.spAttackIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); + battleMon.spAttack = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gPlayerParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gPlayerParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gPlayerParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); + dst[4] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gPlayerParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPEED); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gPlayerParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void WallyHandleGetRawMonData(void) +{ + PlayerHandleGetRawMonData(); +} + +static void WallyHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetWallyMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetWallyMonData(i); + monsToCheck >>= 1; + } + } + WallyBufferExecCompleted(); +} + +static void SetWallyMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &battlePokemon->speed); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + + sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +static void WallyHandleSetRawMonData(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleLoadMonSprite(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleSwitchInAnim(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_PLAYER_MON); + gBattleBankFunc[gActiveBank] = sub_8168A20; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + WallyBufferExecCompleted(); + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerBackPicCoords[]; + +static void WallyHandleDrawTrainerPic(void) +{ + DecompressTrainerBackPic(BACK_PIC_WALLY, gActiveBank); + sub_806A12C(BACK_PIC_WALLY, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + 80, + 80 + 4 * (8 - gTrainerBackPicCoords[BACK_PIC_WALLY].coords), + 30); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void WallyHandleTrainerSlide(void) +{ + DecompressTrainerBackPic(BACK_PIC_WALLY, gActiveBank); + sub_806A12C(BACK_PIC_WALLY, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + 80, + 80 + 4 * (8 - gTrainerBackPicCoords[BACK_PIC_WALLY].coords), + 30); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -96; + gSprites[gBankSpriteIds[gActiveBank]].data0 = 2; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; +} + +static void WallyHandleTrainerSlideBack(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleFaintAnimation(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandlePaletteFade(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleSuccessBallThrowAnim(void) +{ + gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS; + gDoingBattleAnim = TRUE; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedAnimation; +} + +static void WallyHandleBallThrowAnim(void) +{ + u8 ballThrowCaseId = gBattleBufferA[gActiveBank][1]; + + gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId; + gDoingBattleAnim = TRUE; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, GetBankByIdentity(IDENTITY_OPPONENT_MON1), B_ANIM_SAFARI_BALL_THROW); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedAnimation; +} + +static void WallyHandlePause(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + WallyBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = WallyDoMoveAnimation; + } + +} + +static void WallyDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + WallyBufferExecCompleted(); + } + break; + } +} + +static void WallyHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; +} + +static void WallyHandlePrintStringPlayerOnly(void) +{ + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + WallyHandlePrintString(); + else + WallyBufferExecCompleted(); +} + +static void HandleChooseActionAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 160; + gBattleBankFunc[gActiveBank] = WallyHandleActions; + } +} + +static void WallyHandleChooseAction(void) +{ + s32 i; + + gBattleBankFunc[gActiveBank] = HandleChooseActionAfterDma3; + BattleHandleAddTextPrinter(gText_BattleMenu, 2); + + for (i = 0; i < 4; i++) + ActionSelectionDestroyCursorAt(i); + + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); + BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillWallyDo); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 1); +} + +static void WallyHandleUnknownYesNoBox(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleChooseMove(void) +{ + switch (gBattleStruct->wallyMovesState) + { + case 0: + InitMoveSelectionsVarsAndStrings(); + gBattleStruct->wallyMovesState++; + gBattleStruct->wallyMoveFrames = 80; + break; + case 1: + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0x140; + gBattleStruct->wallyMovesState++; + } + break; + case 2: + if (--gBattleStruct->wallyMoveFrames == 0) + { + PlaySE(SE_SELECT); + EmitTwoReturnValues(1, 10, 0x100); + WallyBufferExecCompleted(); + } + break; + } +} + +static void WallyHandleChooseItem(void) +{ + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gBattleBankFunc[gActiveBank] = OpenBagAfterPaletteFade; + gBankInMenu = gActiveBank; +} + +static void WallyHandleChoosePokemon(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd23(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], 0, HP_CURRENT); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void WallyHandleExpUpdate(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleStatusIconUpdate(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleStatusAnimation(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleStatusXor(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleDataTransfer(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleDMA3Transfer(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandlePlayBGM(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd32(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleTwoReturnValues(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleChosenMonReturnValue(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleOneReturnValue(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleOneReturnValue_Duplicate(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd37(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd38(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd39(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd40(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + WallyBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void WallyHandleCmd42(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleEffectivenessSound(void) +{ + PlaySE(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + WallyBufferExecCompleted(); +} + +static void WallyHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + WallyBufferExecCompleted(); +} + +static void WallyHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry1(species, 25); + WallyBufferExecCompleted(); +} + +static void WallyHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + WallyBufferExecCompleted(); +} + +static void WallyHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 50; + gSprites[gBankSpriteIds[gActiveBank]].data2 = -40; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + gSprites[gBankSpriteIds[gActiveBank]].data5 = gActiveBank; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_805CC00); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 1); + + paletteNum = AllocSpritePalette(0xD6F8); + LoadCompressedPalette(gTrainerBackPicPaletteTable[BACK_PIC_WALLY].data, 0x100 + paletteNum * 16, 32); + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = paletteNum; + + taskId = CreateTask(sub_816AC04, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_21; +} + +static void sub_816AA80(u8 bank) +{ + u16 species; + + gBattleSpritesDataPtr->bankData[bank].transformSpecies = 0; + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + sub_806A068(species, GetBankIdentity(bank)); + gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFF); +} + +static void sub_816AC04(u8 taskId) +{ + if (gTasks[taskId].data[1] < 31) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_816AA80(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_816864C; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +static void WallyHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + WallyBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + WallyBufferExecCompleted(); + } +} + +static void WallyHandleCmd49(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd50(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleSpriteInvisibility(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleBattleAnimation(void) +{ + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + WallyBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; +} + +static void WallyHandleLinkStandbyMsg(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleResetActionMoveSelection(void) +{ + WallyBufferExecCompleted(); +} + +static void WallyHandleCmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + WallyBufferExecCompleted(); + + if (!(gBattleTypeFlags & BATTLE_TYPE_WILD) && gBattleTypeFlags & BATTLE_TYPE_LINK) + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_118(void) +{ } -- cgit v1.2.3 From 91b010299f13125b0424d13f8e8119c40266df2c Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 25 Oct 2017 16:24:17 +0200 Subject: start recorded opponent controller --- src/battle_controller_recorded_opponent.c | 208 ++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 src/battle_controller_recorded_opponent.c (limited to 'src') diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c new file mode 100644 index 000000000..9cfd821f5 --- /dev/null +++ b/src/battle_controller_recorded_opponent.c @@ -0,0 +1,208 @@ +#include "global.h" +#include "battle.h" +#include "battle_controllers.h" +#include "battle_message.h" +#include "battle_interface.h" +#include "battle_anim.h" +#include "battle_ai_script_commands.h" +#include "battle_link_817C95C.h" +#include "pokemon.h" +#include "link.h" +#include "util.h" +#include "main.h" +#include "songs.h" +#include "sound.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "pokeball.h" + +extern u32 gBattleExecBuffer; +extern u8 gActiveBank; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT]; +extern u8 gNoOfAllBanks; +extern bool8 gDoingBattleAnim; +extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void (*gPreBattleCallback1)(void); +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern u16 gScriptItemId; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleOutcome; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; +extern u16 gUnknown_020243FC; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern u16 gPartnerTrainerId; +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_020244B4[]; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern struct UnusedControllerStruct gUnknown_02022D0C; +extern u16 gTrainerBattleOpponent_A; +extern u16 gTrainerBattleOpponent_B; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; +extern const u8 gUnknown_0831F578[]; + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); +extern void sub_81851A8(u8 *); +extern u16 sub_8068B48(void); + +// this file's functions +void RecordedOpponentHandleGetMonData(void); +void RecordedOpponentHandleGetRawMonData(void); +void RecordedOpponentHandleSetMonData(void); +void RecordedOpponentHandleSetRawMonData(void); +void RecordedOpponentHandleLoadMonSprite(void); +void RecordedOpponentHandleSwitchInAnim(void); +void RecordedOpponentHandleReturnMonToBall(void); +void RecordedOpponentHandleDrawTrainerPic(void); +void RecordedOpponentHandleTrainerSlide(void); +void RecordedOpponentHandleTrainerSlideBack(void); +void RecordedOpponentHandleFaintAnimation(void); +void RecordedOpponentHandlePaletteFade(void); +void RecordedOpponentHandleSuccessBallThrowAnim(void); +void RecordedOpponentHandleBallThrowAnim(void); +void RecordedOpponentHandlePause(void); +void RecordedOpponentHandleMoveAnimation(void); +void RecordedOpponentHandlePrintString(void); +void RecordedOpponentHandlePrintStringPlayerOnly(void); +void RecordedOpponentHandleChooseAction(void); +void RecordedOpponentHandleUnknownYesNoBox(void); +void RecordedOpponentHandleChooseMove(void); +void RecordedOpponentHandleChooseItem(void); +void RecordedOpponentHandleChoosePokemon(void); +void RecordedOpponentHandleCmd23(void); +void RecordedOpponentHandleHealthBarUpdate(void); +void RecordedOpponentHandleExpUpdate(void); +void RecordedOpponentHandleStatusIconUpdate(void); +void RecordedOpponentHandleStatusAnimation(void); +void RecordedOpponentHandleStatusXor(void); +void RecordedOpponentHandleDataTransfer(void); +void RecordedOpponentHandleDMA3Transfer(void); +void RecordedOpponentHandlePlayBGM(void); +void RecordedOpponentHandleCmd32(void); +void RecordedOpponentHandleTwoReturnValues(void); +void RecordedOpponentHandleChosenMonReturnValue(void); +void RecordedOpponentHandleOneReturnValue(void); +void RecordedOpponentHandleOneReturnValue_Duplicate(void); +void RecordedOpponentHandleCmd37(void); +void RecordedOpponentHandleCmd38(void); +void RecordedOpponentHandleCmd39(void); +void RecordedOpponentHandleCmd40(void); +void RecordedOpponentHandleHitAnimation(void); +void RecordedOpponentHandleCmd42(void); +void RecordedOpponentHandleEffectivenessSound(void); +void RecordedOpponentHandlePlayFanfareOrBGM(void); +void RecordedOpponentHandleFaintingCry(void); +void RecordedOpponentHandleIntroSlide(void); +void RecordedOpponentHandleIntroTrainerBallThrow(void); +void RecordedOpponentHandleDrawPartyStatusSummary(void); +void RecordedOpponentHandleCmd49(void); +void RecordedOpponentHandleCmd50(void); +void RecordedOpponentHandleSpriteInvisibility(void); +void RecordedOpponentHandleBattleAnimation(void); +void RecordedOpponentHandleLinkStandbyMsg(void); +void RecordedOpponentHandleResetActionMoveSelection(void); +void RecordedOpponentHandleCmd55(void); +void nullsub_119(void); + +void RecordedOpponentBufferRunCommand(void); +void RecordedOpponentBufferExecCompleted(void); + +void (*const gRecordedOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +{ + RecordedOpponentHandleGetMonData, + RecordedOpponentHandleGetRawMonData, + RecordedOpponentHandleSetMonData, + RecordedOpponentHandleSetRawMonData, + RecordedOpponentHandleLoadMonSprite, + RecordedOpponentHandleSwitchInAnim, + RecordedOpponentHandleReturnMonToBall, + RecordedOpponentHandleDrawTrainerPic, + RecordedOpponentHandleTrainerSlide, + RecordedOpponentHandleTrainerSlideBack, + RecordedOpponentHandleFaintAnimation, + RecordedOpponentHandlePaletteFade, + RecordedOpponentHandleSuccessBallThrowAnim, + RecordedOpponentHandleBallThrowAnim, + RecordedOpponentHandlePause, + RecordedOpponentHandleMoveAnimation, + RecordedOpponentHandlePrintString, + RecordedOpponentHandlePrintStringPlayerOnly, + RecordedOpponentHandleChooseAction, + RecordedOpponentHandleUnknownYesNoBox, + RecordedOpponentHandleChooseMove, + RecordedOpponentHandleChooseItem, + RecordedOpponentHandleChoosePokemon, + RecordedOpponentHandleCmd23, + RecordedOpponentHandleHealthBarUpdate, + RecordedOpponentHandleExpUpdate, + RecordedOpponentHandleStatusIconUpdate, + RecordedOpponentHandleStatusAnimation, + RecordedOpponentHandleStatusXor, + RecordedOpponentHandleDataTransfer, + RecordedOpponentHandleDMA3Transfer, + RecordedOpponentHandlePlayBGM, + RecordedOpponentHandleCmd32, + RecordedOpponentHandleTwoReturnValues, + RecordedOpponentHandleChosenMonReturnValue, + RecordedOpponentHandleOneReturnValue, + RecordedOpponentHandleOneReturnValue_Duplicate, + RecordedOpponentHandleCmd37, + RecordedOpponentHandleCmd38, + RecordedOpponentHandleCmd39, + RecordedOpponentHandleCmd40, + RecordedOpponentHandleHitAnimation, + RecordedOpponentHandleCmd42, + RecordedOpponentHandleEffectivenessSound, + RecordedOpponentHandlePlayFanfareOrBGM, + RecordedOpponentHandleFaintingCry, + RecordedOpponentHandleIntroSlide, + RecordedOpponentHandleIntroTrainerBallThrow, + RecordedOpponentHandleDrawPartyStatusSummary, + RecordedOpponentHandleCmd49, + RecordedOpponentHandleCmd50, + RecordedOpponentHandleSpriteInvisibility, + RecordedOpponentHandleBattleAnimation, + RecordedOpponentHandleLinkStandbyMsg, + RecordedOpponentHandleResetActionMoveSelection, + RecordedOpponentHandleCmd55, + nullsub_119 +}; + +void nullsub_70(void) +{ +} + +void SetBankFuncToRecordedOpponentBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = RecordedOpponentBufferRunCommand; +} + +void RecordedOpponentBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gRecordedOpponentBufferCommands)) + gRecordedOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + RecordedOpponentBufferExecCompleted(); + } +} -- cgit v1.2.3 From a9bc67dbb090277c8c6c4df1cf16a43ad36e413b Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 25 Oct 2017 18:59:07 +0200 Subject: recorded opponent controller is done --- src/battle_controller_link_opponent.c | 6 +- src/battle_controller_link_partner.c | 6 +- src/battle_controller_player.c | 6 +- src/battle_controller_player_partner.c | 6 +- src/battle_controller_recorded_opponent.c | 1770 +++++++++++++++++++++++++++-- src/battle_controller_recorded_player.c | 6 +- src/battle_controller_safari.c | 6 +- 7 files changed, 1718 insertions(+), 88 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index c7613001b..b8e82fe60 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -135,7 +135,7 @@ static void sub_8067618(u8 taskId); static void sub_80676FC(struct Sprite *sprite); static void sub_806782C(void); -static void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { LinkOpponentHandleGetMonData, LinkOpponentHandleGetRawMonData, @@ -209,8 +209,8 @@ static void LinkOpponentBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gLinkOpponentBufferCommands)) - gLinkOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sLinkOpponentBufferCommands)) + sLinkOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); else LinkOpponentBufferExecCompleted(); } diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index d5ce7ef70..8ad497807 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -129,7 +129,7 @@ static void LinkPartnerDoMoveAnimation(void); static void sub_814DCCC(u8 taskId); static void sub_814DE9C(void); -static void (*const gLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { LinkPartnerHandleGetMonData, LinkPartnerHandleGetRawMonData, @@ -203,8 +203,8 @@ static void LinkPartnerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gLinkPartnerBufferCommands)) - gLinkPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sLinkPartnerBufferCommands)) + sLinkPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); else LinkPartnerBufferExecCompleted(); } diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index e6c32adb5..68e328acc 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -169,7 +169,7 @@ static void PlayerDoMoveAnimation(void); static void task05_08033660(u8 taskId); static void sub_805CE38(void); -static void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { PlayerHandleGetMonData, PlayerHandleGetRawMonData, @@ -266,8 +266,8 @@ static void PlayerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gPlayerBufferCommands)) - gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sPlayerBufferCommands)) + sPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); else PlayerBufferExecCompleted(); } diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 34ac92e74..283c79e66 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -135,7 +135,7 @@ static void PlayerPartnerDoMoveAnimation(void); static void sub_81BE2C8(u8 taskId); static void sub_81BE498(void); -static void (*const gPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { PlayerPartnerHandleGetMonData, PlayerPartnerHandleGetRawMonData, @@ -218,8 +218,8 @@ static void PlayerPartnerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gPlayerPartnerBufferCommands)) - gPlayerPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sPlayerPartnerBufferCommands)) + sPlayerPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); else PlayerPartnerBufferExecCompleted(); } diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 9cfd821f5..8f30febe2 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -6,6 +6,7 @@ #include "battle_anim.h" #include "battle_ai_script_commands.h" #include "battle_link_817C95C.h" +#include "recorded_battle.h" #include "pokemon.h" #include "link.h" #include "util.h" @@ -53,80 +54,86 @@ extern struct MusicPlayerInfo gMPlay_BGM; extern struct UnusedControllerStruct gUnknown_02022D0C; extern u16 gTrainerBattleOpponent_A; extern u16 gTrainerBattleOpponent_B; +extern u8 gUnknown_0203C7B4; extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; -extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; -extern const struct BattleMove gBattleMoves[]; -extern const u8 gUnknown_0831F578[]; extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); -extern void sub_81851A8(u8 *); extern u16 sub_8068B48(void); // this file's functions -void RecordedOpponentHandleGetMonData(void); -void RecordedOpponentHandleGetRawMonData(void); -void RecordedOpponentHandleSetMonData(void); -void RecordedOpponentHandleSetRawMonData(void); -void RecordedOpponentHandleLoadMonSprite(void); -void RecordedOpponentHandleSwitchInAnim(void); -void RecordedOpponentHandleReturnMonToBall(void); -void RecordedOpponentHandleDrawTrainerPic(void); -void RecordedOpponentHandleTrainerSlide(void); -void RecordedOpponentHandleTrainerSlideBack(void); -void RecordedOpponentHandleFaintAnimation(void); -void RecordedOpponentHandlePaletteFade(void); -void RecordedOpponentHandleSuccessBallThrowAnim(void); -void RecordedOpponentHandleBallThrowAnim(void); -void RecordedOpponentHandlePause(void); -void RecordedOpponentHandleMoveAnimation(void); -void RecordedOpponentHandlePrintString(void); -void RecordedOpponentHandlePrintStringPlayerOnly(void); -void RecordedOpponentHandleChooseAction(void); -void RecordedOpponentHandleUnknownYesNoBox(void); -void RecordedOpponentHandleChooseMove(void); -void RecordedOpponentHandleChooseItem(void); -void RecordedOpponentHandleChoosePokemon(void); -void RecordedOpponentHandleCmd23(void); -void RecordedOpponentHandleHealthBarUpdate(void); -void RecordedOpponentHandleExpUpdate(void); -void RecordedOpponentHandleStatusIconUpdate(void); -void RecordedOpponentHandleStatusAnimation(void); -void RecordedOpponentHandleStatusXor(void); -void RecordedOpponentHandleDataTransfer(void); -void RecordedOpponentHandleDMA3Transfer(void); -void RecordedOpponentHandlePlayBGM(void); -void RecordedOpponentHandleCmd32(void); -void RecordedOpponentHandleTwoReturnValues(void); -void RecordedOpponentHandleChosenMonReturnValue(void); -void RecordedOpponentHandleOneReturnValue(void); -void RecordedOpponentHandleOneReturnValue_Duplicate(void); -void RecordedOpponentHandleCmd37(void); -void RecordedOpponentHandleCmd38(void); -void RecordedOpponentHandleCmd39(void); -void RecordedOpponentHandleCmd40(void); -void RecordedOpponentHandleHitAnimation(void); -void RecordedOpponentHandleCmd42(void); -void RecordedOpponentHandleEffectivenessSound(void); -void RecordedOpponentHandlePlayFanfareOrBGM(void); -void RecordedOpponentHandleFaintingCry(void); -void RecordedOpponentHandleIntroSlide(void); -void RecordedOpponentHandleIntroTrainerBallThrow(void); -void RecordedOpponentHandleDrawPartyStatusSummary(void); -void RecordedOpponentHandleCmd49(void); -void RecordedOpponentHandleCmd50(void); -void RecordedOpponentHandleSpriteInvisibility(void); -void RecordedOpponentHandleBattleAnimation(void); -void RecordedOpponentHandleLinkStandbyMsg(void); -void RecordedOpponentHandleResetActionMoveSelection(void); -void RecordedOpponentHandleCmd55(void); -void nullsub_119(void); - -void RecordedOpponentBufferRunCommand(void); -void RecordedOpponentBufferExecCompleted(void); - -void (*const gRecordedOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void RecordedOpponentHandleGetMonData(void); +static void RecordedOpponentHandleGetRawMonData(void); +static void RecordedOpponentHandleSetMonData(void); +static void RecordedOpponentHandleSetRawMonData(void); +static void RecordedOpponentHandleLoadMonSprite(void); +static void RecordedOpponentHandleSwitchInAnim(void); +static void RecordedOpponentHandleReturnMonToBall(void); +static void RecordedOpponentHandleDrawTrainerPic(void); +static void RecordedOpponentHandleTrainerSlide(void); +static void RecordedOpponentHandleTrainerSlideBack(void); +static void RecordedOpponentHandleFaintAnimation(void); +static void RecordedOpponentHandlePaletteFade(void); +static void RecordedOpponentHandleSuccessBallThrowAnim(void); +static void RecordedOpponentHandleBallThrowAnim(void); +static void RecordedOpponentHandlePause(void); +static void RecordedOpponentHandleMoveAnimation(void); +static void RecordedOpponentHandlePrintString(void); +static void RecordedOpponentHandlePrintStringPlayerOnly(void); +static void RecordedOpponentHandleChooseAction(void); +static void RecordedOpponentHandleUnknownYesNoBox(void); +static void RecordedOpponentHandleChooseMove(void); +static void RecordedOpponentHandleChooseItem(void); +static void RecordedOpponentHandleChoosePokemon(void); +static void RecordedOpponentHandleCmd23(void); +static void RecordedOpponentHandleHealthBarUpdate(void); +static void RecordedOpponentHandleExpUpdate(void); +static void RecordedOpponentHandleStatusIconUpdate(void); +static void RecordedOpponentHandleStatusAnimation(void); +static void RecordedOpponentHandleStatusXor(void); +static void RecordedOpponentHandleDataTransfer(void); +static void RecordedOpponentHandleDMA3Transfer(void); +static void RecordedOpponentHandlePlayBGM(void); +static void RecordedOpponentHandleCmd32(void); +static void RecordedOpponentHandleTwoReturnValues(void); +static void RecordedOpponentHandleChosenMonReturnValue(void); +static void RecordedOpponentHandleOneReturnValue(void); +static void RecordedOpponentHandleOneReturnValue_Duplicate(void); +static void RecordedOpponentHandleCmd37(void); +static void RecordedOpponentHandleCmd38(void); +static void RecordedOpponentHandleCmd39(void); +static void RecordedOpponentHandleCmd40(void); +static void RecordedOpponentHandleHitAnimation(void); +static void RecordedOpponentHandleCmd42(void); +static void RecordedOpponentHandleEffectivenessSound(void); +static void RecordedOpponentHandlePlayFanfareOrBGM(void); +static void RecordedOpponentHandleFaintingCry(void); +static void RecordedOpponentHandleIntroSlide(void); +static void RecordedOpponentHandleIntroTrainerBallThrow(void); +static void RecordedOpponentHandleDrawPartyStatusSummary(void); +static void RecordedOpponentHandleCmd49(void); +static void RecordedOpponentHandleCmd50(void); +static void RecordedOpponentHandleSpriteInvisibility(void); +static void RecordedOpponentHandleBattleAnimation(void); +static void RecordedOpponentHandleLinkStandbyMsg(void); +static void RecordedOpponentHandleResetActionMoveSelection(void); +static void RecordedOpponentHandleCmd55(void); +static void nullsub_119(void); + +static void RecordedOpponentBufferRunCommand(void); +static void RecordedOpponentBufferExecCompleted(void); +static void sub_8186F14(void); +static u32 CopyRecordedOpponentMonData(u8 monId, u8 *dst); +static void SetRecordedOpponentMonData(u8 monId); +static void sub_81885D8(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void RecordedOpponentDoMoveAnimation(void); +static void sub_8189548(u8 taskId); +static void sub_818962C(struct Sprite *sprite); +static void sub_818975C(void); + +static void (*const sRecordedOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { RecordedOpponentHandleGetMonData, RecordedOpponentHandleGetRawMonData, @@ -187,7 +194,7 @@ void (*const gRecordedOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = nullsub_119 }; -void nullsub_70(void) +static void nullsub_70(void) { } @@ -196,13 +203,1636 @@ void SetBankFuncToRecordedOpponentBufferRunCommand(void) gBattleBankFunc[gActiveBank] = RecordedOpponentBufferRunCommand; } -void RecordedOpponentBufferRunCommand(void) +static void RecordedOpponentBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gRecordedOpponentBufferCommands)) - gRecordedOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sRecordedOpponentBufferCommands)) + sRecordedOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + RecordedOpponentBufferExecCompleted(); + } +} + +static void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + RecordedOpponentBufferExecCompleted(); +} + +static void CompleteOnBankSpriteCallbackDummy2(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + RecordedOpponentBufferExecCompleted(); +} + +static void sub_81865C8(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + FreeTrainerFrontPicPalette(gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + RecordedOpponentBufferExecCompleted(); + } +} + +static void sub_8186630(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + RecordedOpponentBufferExecCompleted(); + } +} + +static void sub_8186678(void) +{ + bool8 var = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].animEnded) + { + var = TRUE; + } + + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].animEnded + && gSprites[gBankSpriteIds[gActiveBank ^ BIT_MON]].animEnded) + { + var = TRUE; + } + } + + if (var) + { + if (GetBankIdentity(gActiveBank) == IDENTITY_OPPONENT_MON1) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + return; + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + return; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + } + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_8186630; + } +} + +static void sub_818686C(void) +{ + bool32 r9 = FALSE; + bool32 r8 = FALSE; + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + sub_8172EF0(gActiveBank ^ BIT_MON, &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1; + } + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40 + && !IsCryPlayingOrClearCrySongs()) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (GetBankIdentity(gActiveBank) == IDENTITY_OPPONENT_MON1) + m4aMPlayContinue(&gMPlay_BGM); + } + else + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + } + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1; + r9 = TRUE; + } + + if (!IsDoubleBattle()) + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + r8 = TRUE; + } + } + else + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r8 = TRUE; + } + } + + if (r9 && r8) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + SetBankEnemyShadowSpriteCallback(gActiveBank ^ BIT_MON, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], MON_DATA_SPECIES)); + } + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0; + + gBattleBankFunc[gActiveBank] = sub_8186678; + } +} + +static void sub_8186C48(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80) + { + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + } + else + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + RecordedOpponentBufferExecCompleted(); + } + } + } +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + { + RecordedOpponentBufferExecCompleted(); + } +} + +static void sub_8186D58(void) +{ + if (!gSprites[gBankSpriteIds[gActiveBank]].inUse) + { + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedOpponentBufferExecCompleted(); + } +} + +static void sub_8186D9C(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedOpponentBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + RecordedOpponentBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + RecordedOpponentBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +static void sub_8186EA4(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + + gBattleBankFunc[gActiveBank] = sub_8186F14; + } +} + +static void sub_8186F14(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive + && !IsCryPlayingOrClearCrySongs()) + { + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + || gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy_2) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + RecordedOpponentBufferExecCompleted(); + } + } +} + +static void sub_8186F94(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_8186EA4; + } +} + +static void sub_8187084(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80) + { + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + } + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_8186F94; + } +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + RecordedOpponentBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = RecordedOpponentBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +static void RecordedOpponentHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += CopyRecordedOpponentMonData(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += CopyRecordedOpponentMonData(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + RecordedOpponentBufferExecCompleted(); +} + +static u32 CopyRecordedOpponentMonData(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + battleMon.spAttackIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); + battleMon.spAttack = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gEnemyParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gEnemyParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + GetMonData(&gEnemyParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gEnemyParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + dst[4] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +static void RecordedOpponentHandleGetRawMonData(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + SetRecordedOpponentMonData(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + SetRecordedOpponentMonData(i); + monsToCheck >>= 1; + } + } + RecordedOpponentBufferExecCompleted(); +} + +static void SetRecordedOpponentMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &battlePokemon->speed); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } +} + +static void RecordedOpponentHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleLoadMonSprite(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + + + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + gBattleBankFunc[gActiveBank] = sub_8186C48; +} + +static void RecordedOpponentHandleSwitchInAnim(void) +{ + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_81885D8(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_8187084; +} + +static void sub_81885D8(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFE); +} + +static void RecordedOpponentHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + RecordedOpponentBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_OPPONENT_MON); + gBattleBankFunc[gActiveBank] = sub_8186D9C; + } + break; + } +} + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +static void RecordedOpponentHandleDrawTrainerPic(void) +{ + s16 xPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 152; + else // first mon + xPos = 200; + + if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + { + if (gActiveBank == 1) + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + else + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); + } + else + { + trainerPicId = PlayerGenderToFrontTrainerPicId(sub_8185F40()); + } + } + else + { + xPos = 176; + if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_C00) + { + trainerPicId = sub_8068B48(); + } + else + { + trainerPicId = PlayerGenderToFrontTrainerPicId(gLinkPlayers[gUnknown_0203C7B4 ^ BIT_SIDE].gender); + } + } + + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + xPos, + (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 40, + sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = 2; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam = trainerPicId; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +static void RecordedOpponentHandleTrainerSlide(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_81865C8; +} + +static void RecordedOpponentHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT); + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039934; + gBattleBankFunc[gActiveBank] = sub_8186D58; + } + } +} + +static void RecordedOpponentHandlePaletteFade(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleSuccessBallThrowAnim(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleBallThrowAnim(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandlePause(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + RecordedOpponentBufferExecCompleted(); + } else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = RecordedOpponentDoMoveAnimation; + } + } +} + +static void RecordedOpponentDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + RecordedOpponentBufferExecCompleted(); + } + break; + } +} + +static void RecordedOpponentHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; +} + +static void RecordedOpponentHandlePrintStringPlayerOnly(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleChooseAction(void) +{ + EmitTwoReturnValues(1, RecordedBattle_ReadBankAction(gActiveBank), 0); + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleUnknownYesNoBox(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleChooseMove(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_PALACE) + { + EmitTwoReturnValues(1, 10, ChooseMoveAndTargetInBattlePalace()); + } + else + { + u8 moveId = RecordedBattle_ReadBankAction(gActiveBank); + u8 target = RecordedBattle_ReadBankAction(gActiveBank); + EmitTwoReturnValues(1, 10, moveId | (target << 8)); + } + + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleChooseItem(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleChoosePokemon(void) +{ + *(gBattleStruct->field_5C + gActiveBank) = RecordedBattle_ReadBankAction(gActiveBank); + EmitChosenMonReturnValue(1, *(gBattleStruct->field_5C + gActiveBank), NULL); + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd23(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void RecordedOpponentHandleExpUpdate(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void RecordedOpponentHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void RecordedOpponentHandleStatusXor(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleDataTransfer(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleDMA3Transfer(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandlePlayBGM(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd32(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleTwoReturnValues(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleChosenMonReturnValue(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleOneReturnValue(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleOneReturnValue_Duplicate(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + RecordedOpponentBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void RecordedOpponentHandleCmd42(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleFaintingCry(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, 25, 5); + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_818962C); + + taskId = CreateTask(sub_8189548, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_70; +} + +static void sub_8189548(u8 taskId) +{ + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81885D8(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81885D8(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81885D8(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_818686C; + gActiveBank = savedActiveBank; + DestroyTask(taskId); +} + +static void sub_818962C(struct Sprite *sprite) +{ + FreeTrainerFrontPicPalette(sprite->oam.affineParam); + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); +} + +static void RecordedOpponentHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + RecordedOpponentBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + + if (gBattleBufferA[gActiveBank][2] != 0) + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E < 2) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E++; + return; + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E = 0; + } + } + + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_818975C; + } +} + +static void sub_818975C(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + RecordedOpponentBufferExecCompleted(); + } +} + +static void RecordedOpponentHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd50(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleSpriteInvisibility(void) +{ + if (AnimBankSpriteExists(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) RecordedOpponentBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; } } + +static void RecordedOpponentHandleLinkStandbyMsg(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleResetActionMoveSelection(void) +{ + RecordedOpponentBufferExecCompleted(); +} + +static void RecordedOpponentHandleCmd55(void) +{ + if (gBattleBufferA[gActiveBank][1] == BATTLE_DREW) + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + else + gBattleOutcome = gBattleBufferA[gActiveBank][1] ^ BATTLE_DREW; + + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + RecordedOpponentBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_80587B0; +} + +static void nullsub_119(void) +{ +} diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 605268f13..4e71537b0 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -132,7 +132,7 @@ static void RecordedPlayerDoMoveAnimation(void); static void sub_818CC24(u8 taskId); static void sub_818CDF4(void); -static void (*const gRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { RecordedPlayerHandleGetMonData, RecordedPlayerHandleGetRawMonData, @@ -206,8 +206,8 @@ static void RecordedPlayerBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gRecordedPlayerBufferCommands)) - gRecordedPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sRecordedPlayerBufferCommands)) + sRecordedPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); else RecordedPlayerBufferExecCompleted(); } diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 74210e629..6eb19df84 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -110,7 +110,7 @@ static void SafariBufferRunCommand(void); static void SafariBufferExecCompleted(void); static void CompleteWhenChosePokeblock(void); -static void (*const gSafariBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sSafariBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { SafariHandleGetMonData, SafariHandleGetRawMonData, @@ -184,8 +184,8 @@ static void SafariBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gSafariBufferCommands)) - gSafariBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sSafariBufferCommands)) + sSafariBufferCommands[gBattleBufferA[gActiveBank][0]](); else SafariBufferExecCompleted(); } -- cgit v1.2.3 From fa36e23683a27876156d74829c543f69fcd1f297 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 25 Oct 2017 21:57:28 +0200 Subject: start opponent controller, thx bird --- src/battle_controller_link_opponent.c | 19 +- src/battle_controller_opponent.c | 1491 ++++++++++++++++++++++++++++++++- src/battle_dome_cards.c | 6 +- src/pokemon_2.c | 4 +- src/pokemon_3.c | 4 +- 5 files changed, 1500 insertions(+), 24 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index b8e82fe60..95cb80146 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -55,9 +55,8 @@ extern u16 gTrainerBattleOpponent_A; extern u16 gTrainerBattleOpponent_B; extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; -extern const struct CompressedSpritePalette gTrainerBackPicPaletteTable[]; extern const struct BattleMove gBattleMoves[]; -extern const u8 gUnknown_0831F578[]; +extern const u8 gTrainerClassToFrontPicId[]; extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); @@ -1291,17 +1290,17 @@ static void LinkOpponentHandleDrawTrainerPic(void) || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_LEAF_GREEN) { if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) - trainerPicId = gUnknown_0831F578[0x4F]; + trainerPicId = gTrainerClassToFrontPicId[0x4F]; else - trainerPicId = gUnknown_0831F578[0x4E]; + trainerPicId = gTrainerClassToFrontPicId[0x4E]; } else if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_RUBY || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_SAPPHIRE) { if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) - trainerPicId = gUnknown_0831F578[0x51]; + trainerPicId = gTrainerClassToFrontPicId[0x51]; else - trainerPicId = gUnknown_0831F578[0x50]; + trainerPicId = gTrainerClassToFrontPicId[0x50]; } else { @@ -1320,17 +1319,17 @@ static void LinkOpponentHandleDrawTrainerPic(void) || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_LEAF_GREEN) { if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) - trainerPicId = gUnknown_0831F578[0x4F]; + trainerPicId = gTrainerClassToFrontPicId[0x4F]; else - trainerPicId = gUnknown_0831F578[0x4E]; + trainerPicId = gTrainerClassToFrontPicId[0x4E]; } else if ((gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_RUBY || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_SAPPHIRE) { if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) - trainerPicId = gUnknown_0831F578[0x51]; + trainerPicId = gTrainerClassToFrontPicId[0x51]; else - trainerPicId = gUnknown_0831F578[0x50]; + trainerPicId = gTrainerClassToFrontPicId[0x50]; } else { diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index e55d78912..664d12142 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -4,12 +4,59 @@ #include "battle_message.h" #include "battle_interface.h" #include "battle_anim.h" +#include "battle_link_817C95C.h" +#include "battle_ai_script_commands.h" +#include "pokemon.h" #include "link.h" +#include "util.h" +#include "main.h" +#include "item.h" +#include "items.h" +#include "songs.h" +#include "sound.h" +#include "moves.h" +#include "window.h" +#include "m4a.h" +#include "palette.h" +#include "task.h" +#include "text.h" +#include "string_util.h" +#include "bg.h" +#include "reshow_battle_screen.h" +#include "rng.h" +#include "pokeball.h" +extern u32 gBattleExecBuffer; extern u8 gActiveBank; +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; extern bool8 gDoingBattleAnim; extern u8 gUnknown_020244CC; +extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; +extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; +extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; +extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200]; +extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u8 gUnknown_03005D7C[BATTLE_BANKS_COUNT]; extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); +extern void *gUnknown_020244D8; +extern void *gUnknown_020244DC; +extern u8 gBattleMonForms[BATTLE_BANKS_COUNT]; +extern struct SpriteTemplate gUnknown_0202499C; +extern struct UnusedControllerStruct gUnknown_02022D0C; +extern u16 gTrainerBattleOpponent_A; +extern u16 gTrainerBattleOpponent_B; +extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; +extern u16 gBattle_BG0_X; +extern u16 gBattle_BG0_Y; + +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const struct BattleMove gBattleMoves[]; + +extern void sub_8172EF0(u8 bank, struct Pokemon *mon); +extern void sub_806A068(u16, u8); +extern void sub_81A57E4(u8 bank, u16 stringId); // this file's functions void OpponentHandleGetMonData(void); @@ -23,15 +70,15 @@ void OpponentHandleDrawTrainerPic(void); void OpponentHandleTrainerSlide(void); void OpponentHandleTrainerSlideBack(void); void OpponentHandleFaintAnimation(void); -void OpponentHandleCmd11(void); -void OpponentHandleCmd12(void); +void OpponentHandlePaletteFade(void); +void OpponentHandleSuccessBallThrowAnim(void); void OpponentHandleBallThrow(void); void OpponentHandlePause(void); void OpponentHandleMoveAnimation(void); void OpponentHandlePrintString(void); void OpponentHandlePrintStringPlayerOnly(void); void OpponentHandleChooseAction(void); -void OpponentHandleCmd19(void); +void OpponentHandleUnknownYesNoBox(void); void OpponentHandleChooseMove(void); void OpponentHandleOpenBag(void); void OpponentHandleChoosePokemon(void); @@ -71,6 +118,13 @@ void OpponentHandleCmd55(void); void nullsub_91(void); void OpponentBufferRunCommand(void); +void OpponentBufferExecCompleted(void); +void bx_803AEDC(void); +u32 sub_8060004(u8 monId, u8 *dst); +void sub_8060890(u8 monId); +void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit); +void DoSwitchOutAnimation(void); +void OpponentDoMoveAnimation(void); void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { @@ -85,15 +139,15 @@ void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = OpponentHandleTrainerSlide, OpponentHandleTrainerSlideBack, OpponentHandleFaintAnimation, - OpponentHandleCmd11, - OpponentHandleCmd12, + OpponentHandlePaletteFade, + OpponentHandleSuccessBallThrowAnim, OpponentHandleBallThrow, OpponentHandlePause, OpponentHandleMoveAnimation, OpponentHandlePrintString, OpponentHandlePrintStringPlayerOnly, OpponentHandleChooseAction, - OpponentHandleCmd19, + OpponentHandleUnknownYesNoBox, OpponentHandleChooseMove, OpponentHandleOpenBag, OpponentHandleChoosePokemon, @@ -134,7 +188,7 @@ void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = }; // unknown unused data -static const u8 gUnknown_0831C7AC[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; +static const u8 sUnknown_0831C7AC[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; void nullsub_26(void) { @@ -144,3 +198,1426 @@ void SetBankFuncToOpponentBufferRunCommand(void) { gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; } + +void OpponentBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gOpponentBufferCommands)) + gOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + OpponentBufferExecCompleted(); + } +} + +void CompleteOnBankSpriteCallbackDummy(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + OpponentBufferExecCompleted(); +} + +void CompleteOnBankSpriteCallbackDummy2(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + OpponentBufferExecCompleted(); +} + +void sub_805F240(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + FreeTrainerFrontPicPalette(gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam); + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + OpponentBufferExecCompleted(); + } +} + +void sub_805F2A8(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0; + OpponentBufferExecCompleted(); + } +} + +void sub_805F2F0(void) +{ + bool8 var = FALSE; + bool8 var2; + + if (!IsDoubleBattle() || ((IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI)) || (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS))) + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + var = TRUE; + var2 = FALSE; + } + else + { + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + var = TRUE; + var2 = TRUE; + } + + gUnknown_020244D8 = &gBattleSpritesDataPtr->healthBoxesData[gActiveBank]; + gUnknown_020244DC = &gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON]; + + if (var) + { + if (var2 == TRUE) + { + if (var2 && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + } + else + return; + } + else if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + if (GetBankIdentity(gActiveBank) == 3) + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 == 0 && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 == 0) + { + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + } + else + return; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + } + else + return; + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3; + gBattleBankFunc[gActiveBank] = sub_805F2A8; + } +} + +void sub_805F560(void) +{ + bool32 sp = FALSE; + bool32 r10 = FALSE; + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI) && IsDoubleBattle() && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1) + sub_8172EF0(gActiveBank ^ BIT_MON, &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]]); + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL); + sub_8076918(gActiveBank ^ BIT_MON); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]); + } + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1; + } + + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40 + && !IsCryPlayingOrClearCrySongs()) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (GetBankIdentity(gActiveBank) == 1) + m4aMPlayContinue(&gMPlay_BGM); + } + else + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1; + sp = TRUE; + } + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + r10 = TRUE; + } + } + else + { + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy + && gSprites[gBankSpriteIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy) + { + r10 = TRUE; + } + } + + if (sp && r10) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]); + SetBankEnemyShadowSpriteCallback(gActiveBank ^ BIT_MON, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank ^ BIT_MON]], MON_DATA_SPECIES)); + } + + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0; + + gBattleBankFunc[gActiveBank] = sub_805F2F0; + } +} + +void sub_805F994(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + OpponentBufferExecCompleted(); + } +} + +void sub_805FA70(void) +{ + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT); + } + else + OpponentBufferExecCompleted(); +} + +void sub_805FAC4(void) +{ + if (!gSprites[gBankSpriteIds[gActiveBank]].inUse) + { + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void sub_805FB08(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + OpponentBufferExecCompleted(); +} + +void bx_blink_t7(void) +{ + u8 spriteId = gBankSpriteIds[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = 0; + gDoingBattleAnim = FALSE; + OpponentBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_805FC10(void) +{ + if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleBankFunc[gActiveBank] = bx_803AEDC; + } +} + +void bx_803AEDC(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive && !IsCryPlayingOrClearCrySongs()) + { + if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy || gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy_2) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + OpponentBufferExecCompleted(); + } + } +} + +void sub_805FD00(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], 0); + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); + sub_8076918(gActiveBank); + SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_805FC10; + } +} + +void sub_805FDF0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + + if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) + { + DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]); + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_805FD00; + } +} + +void sub_805FEB8(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) + OpponentBufferExecCompleted(); +} + +void bx_803B0F4(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) + OpponentBufferExecCompleted(); +} + +void OpponentBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void OpponentHandleGetMonData(void) +{ + u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data + u32 size = 0; + u8 monsToCheck; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + size += sub_8060004(gBattlePartyID[gActiveBank], monData); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + size += sub_8060004(i, monData + size); + monsToCheck >>= 1; + } + } + EmitDataTransfer(1, size, monData); + OpponentBufferExecCompleted(); +} + +u32 sub_8060004(u8 monId, u8 *dst) +{ + struct BattlePokemon battleMon; + struct MovePpInfo moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + battleMon.species = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + battleMon.item = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battleMon.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + battleMon.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + battleMon.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + battleMon.friendship = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + battleMon.experience = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + battleMon.hpIV = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + battleMon.attackIV = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + battleMon.defenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + battleMon.speedIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + battleMon.spAttackIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + battleMon.spDefenseIV = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + battleMon.personality = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + battleMon.status1 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + battleMon.level = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + battleMon.hp = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + battleMon.maxHP = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + battleMon.attack = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + battleMon.defense = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + battleMon.speed = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); + battleMon.spAttack = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + battleMon.spDefense = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + battleMon.isEgg = GetMonData(&gEnemyParty[monId], MON_DATA_IS_EGG); + battleMon.altAbility = GetMonData(&gEnemyParty[monId], MON_DATA_ALT_ABILITY); + battleMon.otId = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + GetMonData(&gEnemyParty[monId], MON_DATA_NICKNAME, nickname); + StringCopy10(battleMon.nickname, nickname); + GetMonData(&gEnemyParty[monId], MON_DATA_OT_NAME, battleMon.otName); + src = (u8 *)&battleMon; + for (size = 0; size < sizeof(battleMon); size++) + dst[size] = src[size]; + break; + case REQUEST_SPECIES_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPECIES); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_HELDITEM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MOVES_PP_BATTLE: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + src = (u8*)(&moveData); + for (size = 0; size < sizeof(moveData); size++) + dst[size] = src[size]; + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < 4; size++) + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + size); + dst[size] = GetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES); + size++; + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE); + size = 1; + break; + case REQUEST_OTID_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_OT_ID); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_EXP_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_EXP); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case REQUEST_HP_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_EV); + size = 1; + break; + case REQUEST_ATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV); + size = 1; + break; + case REQUEST_DEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV); + size = 1; + break; + case REQUEST_SPEED_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV); + size = 1; + break; + case REQUEST_SPATK_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV); + size = 1; + break; + case REQUEST_SPDEF_EV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV); + size = 1; + break; + case REQUEST_FRIENDSHIP_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP); + size = 1; + break; + case REQUEST_POKERUS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKERUS); + size = 1; + break; + case REQUEST_MET_LOCATION_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION); + size = 1; + break; + case REQUEST_MET_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL); + size = 1; + break; + case REQUEST_MET_GAME_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME); + size = 1; + break; + case REQUEST_POKEBALL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL); + size = 1; + break; + case REQUEST_ALL_IVS_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + dst[1] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + dst[2] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + dst[3] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + dst[4] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + dst[5] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 6; + break; + case REQUEST_HP_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_HP_IV); + size = 1; + break; + case REQUEST_ATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV); + size = 1; + break; + case REQUEST_DEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV); + size = 1; + break; + case REQUEST_SPEED_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV); + size = 1; + break; + case REQUEST_SPATK_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV); + size = 1; + break; + case REQUEST_SPDEF_IV_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV); + size = 1; + break; + case REQUEST_PERSONALITY_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_CHECKSUM_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_STATUS_BATTLE: + data32 = GetMonData(&gEnemyParty[monId], MON_DATA_STATUS); + dst[0] = (data32 & 0x000000FF); + dst[1] = (data32 & 0x0000FF00) >> 8; + dst[2] = (data32 & 0x00FF0000) >> 16; + dst[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case REQUEST_LEVEL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_LEVEL); + size = 1; + break; + case REQUEST_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_MAX_HP_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_ATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_ATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_DEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_DEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPEED_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPEED); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPATK_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPATK); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_SPDEF_BATTLE: + data16 = GetMonData(&gEnemyParty[monId], MON_DATA_SPDEF); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_COOL_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL); + size = 1; + break; + case REQUEST_BEAUTY_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY); + size = 1; + break; + case REQUEST_CUTE_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE); + size = 1; + break; + case REQUEST_SMART_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART); + size = 1; + break; + case REQUEST_TOUGH_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH); + size = 1; + break; + case REQUEST_SHEEN_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SHEEN); + size = 1; + break; + case REQUEST_COOL_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON); + size = 1; + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case REQUEST_CUTE_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case REQUEST_SMART_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON); + size = 1; + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + dst[0] = GetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + + return size; +} + +void OpponentHandleGetRawMonData(void) +{ + struct BattlePokemon battleMon; + u8 *src = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = src[i]; + + EmitDataTransfer(1, gBattleBufferA[gActiveBank][2], dst); + OpponentBufferExecCompleted(); +} + +void OpponentHandleSetMonData(void) +{ + u8 monsToCheck; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + sub_8060890(gBattlePartyID[gActiveBank]); + } + else + { + monsToCheck = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (monsToCheck & 1) + sub_8060890(i); + monsToCheck >>= 1; + } + } + OpponentBufferExecCompleted(); +} + +void sub_8060890(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case REQUEST_ALL_BATTLE: + { + u8 iv; + + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &battlePokemon->species); + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &battlePokemon->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &battlePokemon->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &battlePokemon->ppBonuses); + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &battlePokemon->friendship); + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &iv); + iv = battlePokemon->attackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &iv); + iv = battlePokemon->defenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &iv); + iv = battlePokemon->speedIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &iv); + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &battlePokemon->personality); + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &battlePokemon->status1); + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &battlePokemon->level); + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &battlePokemon->hp); + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &battlePokemon->maxHP); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &battlePokemon->attack); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &battlePokemon->defense); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &battlePokemon->speed); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &battlePokemon->spAttack); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &battlePokemon->spDefense); + } + break; + case REQUEST_SPECIES_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + i, &moveData->moves[i]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + i, &moveData->pp[i]); + } + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case REQUEST_MOVE1_BATTLE: + case REQUEST_MOVE2_BATTLE: + case REQUEST_MOVE3_BATTLE: + case REQUEST_MOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case REQUEST_PPMOVE1_BATTLE: + case REQUEST_PPMOVE2_BATTLE: + case REQUEST_PPMOVE3_BATTLE: + case REQUEST_PPMOVE4_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gEnemyParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } +} + +void OpponentHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + + OpponentBufferExecCompleted(); +} + +void OpponentHandleLoadMonSprite(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_806A068(species, GetBankIdentity(gActiveBank)); + + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(gActiveBank, 2), + sub_80A6138(gActiveBank), + sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; + gSprites[gBankSpriteIds[gActiveBank]].data2 = species; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gBankSpriteIds[gActiveBank]], gBattleMonForms[gActiveBank]); + + SetBankEnemyShadowSpriteCallback(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + gBattleBankFunc[gActiveBank] = sub_805F994; +} + +void OpponentHandleSwitchInAnim(void) +{ + *(gBattleStruct->field_5C + gActiveBank) = 6; + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_80613DC(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_805FDF0; +} + +void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(bank, dontClearSubstituteBit); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_03005D7C[bank] = CreateInvisibleSpriteWithCallback(sub_805D714); + BattleLoadOpponentMonSpriteGfx(&gEnemyParty[gBattlePartyID[bank]], bank); + sub_806A068(species, GetBankIdentity(bank)); + + gBankSpriteIds[bank] = CreateSprite(&gUnknown_0202499C, + sub_80A5C6C(bank, 2), + sub_80A6138(bank), + sub_80A82E4(bank)); + + gSprites[gBankSpriteIds[bank]].data0 = bank; + gSprites[gBankSpriteIds[bank]].data2 = species; + + gSprites[gUnknown_03005D7C[bank]].data1 = gBankSpriteIds[bank]; + gSprites[gUnknown_03005D7C[bank]].data2 = bank; + + gSprites[gBankSpriteIds[bank]].oam.paletteNum = bank; + + StartSpriteAnim(&gSprites[gBankSpriteIds[bank]], gBattleMonForms[bank]); + + gSprites[gBankSpriteIds[bank]].invisible = TRUE; + gSprites[gBankSpriteIds[bank]].callback = SpriteCallbackDummy; + + gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFE); +} + +void OpponentHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]); + DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]); + sub_805EEE0(gActiveBank); + SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SWITCH_OUT_OPPONENT_MON); + gBattleBankFunc[gActiveBank] = sub_805FB08; + } + break; + } +} + +u8 sub_81A4CB0(void); +u8 sub_81D5588(u16 trainerId); +u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +u8 GetEreaderTrainerFrontSpriteId(void); + +// todo: get rid of it once the struct is declared in a header +struct MonCoords +{ + // This would use a bitfield, but sub_8079F44 + // uses it as a u8 and casting won't match. + u8 coords; // u8 x:4, y:4; + u8 y_offset; +}; +extern const struct MonCoords gTrainerFrontPicCoords[]; + +void OpponentHandleDrawTrainerPic(void) +{ + u32 trainerPicId; + s16 xPos; + + if (gBattleTypeFlags & BATTLE_TYPE_SECRET_BASE) + { + trainerPicId = GetSecretBaseTrainerPicIndex(); + } + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_3FE) + { + trainerPicId = sub_81A4CB0(); + } + else if (gBattleTypeFlags & BATTLE_TYPE_x4000000) + { + if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (gActiveBank == 1) + trainerPicId = sub_81D5588(gTrainerBattleOpponent_A); + else + trainerPicId = sub_81D5588(gTrainerBattleOpponent_B); + } + else + { + trainerPicId = sub_81D5588(gTrainerBattleOpponent_A); + } + } + else if (gBattleTypeFlags & BATTLE_TYPE_FRONTIER) + { + if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000)) + { + if (gActiveBank == 1) + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + else + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); + } + else + { + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + } + } + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + { + trainerPicId = GetEreaderTrainerFrontSpriteId(); + } + else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (gActiveBank != 1) + trainerPicId = gTrainers[gTrainerBattleOpponent_B].trainerPic; + else + trainerPicId = gTrainers[gTrainerBattleOpponent_A].trainerPic; + } + else + { + trainerPicId = gTrainers[gTrainerBattleOpponent_A].trainerPic; + } + + if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS)) + { + if ((GetBankIdentity(gActiveBank) & BIT_MON) != 0) // second mon + xPos = 152; + else // first mon + xPos = 200; + } + else + { + xPos = 176; + } + + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, + xPos, + (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 40, + sub_80A82E4(gActiveBank)); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; + gSprites[gBankSpriteIds[gActiveBank]].data0 = 2; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam = trainerPicId; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; +} + +void OpponentHandleTrainerSlide(void) +{ + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_SECRET_BASE) + { + trainerPicId = GetSecretBaseTrainerPicIndex(); + } + else if (gTrainerBattleOpponent_A == TRAINER_OPPONENT_3FE) + { + trainerPicId = sub_81A4CB0(); + } + else if (gBattleTypeFlags & BATTLE_TYPE_x4000000) + { + if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (gActiveBank == 1) + trainerPicId = sub_81D5588(gTrainerBattleOpponent_A); + else + trainerPicId = sub_81D5588(gTrainerBattleOpponent_B); + } + else + { + trainerPicId = sub_81D5588(gTrainerBattleOpponent_A); + } + } + else if (gBattleTypeFlags & BATTLE_TYPE_FRONTIER) + { + if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000)) + { + if (gActiveBank == 1) + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + else + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); + } + else + { + trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); + } + } + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + { + trainerPicId = GetEreaderTrainerFrontSpriteId(); + } + else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + { + if (gActiveBank != 1) + trainerPicId = gTrainers[gTrainerBattleOpponent_B].trainerPic; + else + trainerPicId = gTrainers[gTrainerBattleOpponent_A].trainerPic; + } + else + { + trainerPicId = gTrainers[gTrainerBattleOpponent_A].trainerPic; + } + + DecompressTrainerFrontPic(trainerPicId, gActiveBank); + sub_806A12C(trainerPicId, GetBankIdentity(gActiveBank)); + gBankSpriteIds[gActiveBank] = CreateSprite(&gUnknown_0202499C, 176, (8 - gTrainerFrontPicCoords[trainerPicId].coords) * 4 + 40, 0x1E); + + gSprites[gBankSpriteIds[gActiveBank]].pos2.x = 96; + gSprites[gBankSpriteIds[gActiveBank]].pos1.x += 32; + gSprites[gBankSpriteIds[gActiveBank]].data0 = -2; + gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicId].tag); + gSprites[gBankSpriteIds[gActiveBank]].oam.affineParam = trainerPicId; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_805D7AC; + + gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; +} + +void OpponentHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_805F240; +} + +void OpponentHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) + { + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState++; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + PlaySE12WithPanning(SE_POKE_DEAD, PAN_SIDE_OPPONENT); + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_8039934; + gBattleBankFunc[gActiveBank] = sub_805FAC4; + } + } +} + +void OpponentHandlePaletteFade(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleSuccessBallThrowAnim(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleBallThrow(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlePause(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBank][3]; + gAnimMovePower = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBank][16]; + gTransformedPersonalities[gActiveBank] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE + { + OpponentBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + gBattleBankFunc[gActiveBank] = OpponentDoMoveAnimation; + } + } +} + +void OpponentDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 multihit = gBattleBufferA[gActiveBank][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) + { + case 0: + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute + && !gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8) + { + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 1; + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805EB9C(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_805EB9C(1); + if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute && multihit < 2) + { + DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->bankData[gActiveBank].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) + { + sub_805E394(); + TrySetBehindSubstituteSpriteBit(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState = 0; + OpponentBufferExecCompleted(); + } + break; + } +} + +void OpponentHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16*)(&gBattleBufferA[gActiveBank][2]); + BufferStringBattle(*stringId); + BattleHandleAddTextPrinter(gDisplayedStringBattle, 0); + gBattleBankFunc[gActiveBank] = CompleteOnInactiveTextPrinter; + sub_81A57E4(gActiveBank, *stringId); +} + +void OpponentHandlePrintStringPlayerOnly(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleChooseAction(void) +{ + AI_TrySwitchOrUseItem(); + OpponentBufferExecCompleted(); +} + +void OpponentHandleUnknownYesNoBox(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleChooseMove(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_PALACE) + { + EmitTwoReturnValues(1, 10, ChooseMoveAndTargetInBattlePalace()); + OpponentBufferExecCompleted(); + } + else + { + u8 chosenMoveId; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); + + if (gBattleTypeFlags & (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FIRST_BATTLE | BATTLE_TYPE_SAFARI | BATTLE_TYPE_ROAMER)) + { + + BattleAI_SetupAIData(0xF); + chosenMoveId = BattleAI_ChooseMoveOrAction(); + + switch (chosenMoveId) + { + case 5: + EmitTwoReturnValues(1, ACTION_WATCHES_CAREFULLY, 0); + break; + case 4: + EmitTwoReturnValues(1, ACTION_RUN, 0); + break; + case 6: + EmitTwoReturnValues(1, 15, gBankTarget); + break; + default: + if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & (MOVE_TARGET_USER | MOVE_TARGET_x10)) + gBankTarget = gActiveBank; + if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & MOVE_TARGET_BOTH) + { + gBankTarget = GetBankByIdentity(IDENTITY_PLAYER_MON1); + if (gAbsentBankFlags & gBitTable[gBankTarget]) + gBankTarget = GetBankByIdentity(IDENTITY_PLAYER_MON2); + } + EmitTwoReturnValues(1, 10, (chosenMoveId) | (gBankTarget << 8)); + break; + } + OpponentBufferExecCompleted(); + } + else + { + u16 move; + do + { + chosenMoveId = Random() & 3; + move = moveInfo->moves[chosenMoveId]; + } while (move == MOVE_NONE); + + if (gBattleMoves[move].target & (MOVE_TARGET_USER | MOVE_TARGET_x10)) + EmitTwoReturnValues(1, 10, (chosenMoveId) | (gActiveBank << 8)); + else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + EmitTwoReturnValues(1, 10, (chosenMoveId) | (GetBankByIdentity(Random() & 2) << 8)); + else + EmitTwoReturnValues(1, 10, (chosenMoveId) | (GetBankByIdentity(IDENTITY_PLAYER_MON1) << 8)); + + OpponentBufferExecCompleted(); + } + } +} diff --git a/src/battle_dome_cards.c b/src/battle_dome_cards.c index 5251ee06a..030290a0d 100644 --- a/src/battle_dome_cards.c +++ b/src/battle_dome_cards.c @@ -19,7 +19,7 @@ extern const union AffineAnimCmd *const gUnknown_082FF694[]; extern const union AnimCmd *const gUnknown_082FF70C[]; extern const union AnimCmd *const *const gMonAnimationsSpriteAnimsPtrTable[NUM_SPECIES]; extern const union AnimCmd *const *const gUnknown_0830536C[]; -extern const u8 gUnknown_0831F578[]; +extern const u8 gTrainerClassToFrontPicId[]; // Static type declarations @@ -421,9 +421,9 @@ u8 sub_818D97C(u8 a0, u8 a1) switch (a0) { default: - return gUnknown_0831F578[0x3F]; + return gTrainerClassToFrontPicId[0x3F]; case 0: - return gUnknown_0831F578[0x3C]; + return gTrainerClassToFrontPicId[0x3C]; } } return a0; diff --git a/src/pokemon_2.c b/src/pokemon_2.c index b0ec7460d..b78fd3db8 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -1222,14 +1222,14 @@ void CreateSecretBaseEnemyParty(struct SecretBaseRecord *secretBaseRecord) } } -extern const u8 gUnknown_0831F578[]; +extern const u8 gTrainerClassToFrontPicId[]; extern const u8 gTrainerClassToNameIndex[]; extern const u8 gSecretBaseTrainerClasses[][5]; u8 GetSecretBaseTrainerPicIndex(void) { u8 trainerClass = gSecretBaseTrainerClasses[gBattleResources->secretBase->gender][gBattleResources->secretBase->trainerId[0] % 5]; - return gUnknown_0831F578[trainerClass]; + return gTrainerClassToFrontPicId[trainerClass]; } u8 GetSecretBaseTrainerNameIndex(void) diff --git a/src/pokemon_3.c b/src/pokemon_3.c index 73d23fe6f..f5043db01 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -1652,11 +1652,11 @@ u8 sub_806EF84(u8 arg0, u8 arg1) return i; } -extern const u8 gUnknown_0831F578[]; +extern const u8 gTrainerClassToFrontPicId[]; u16 sub_806EFF0(u16 arg0) { - return gUnknown_0831F578[arg0]; + return gTrainerClassToFrontPicId[arg0]; } u16 PlayerGenderToFrontTrainerPicId(u8 playerGender) -- cgit v1.2.3 From 15061844651c0d0cdbe5ec0a3097b054d58e7f88 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Thu, 26 Oct 2017 23:12:48 +0200 Subject: battle controller opponent is done --- src/battle_ai_switch_items.c | 2 +- src/battle_anim.c | 2 +- src/battle_controller_link_opponent.c | 4 +- src/battle_controller_link_partner.c | 4 +- src/battle_controller_opponent.c | 686 ++++++++++++++++++++++++------ src/battle_controller_player.c | 4 +- src/battle_controller_player_partner.c | 4 +- src/battle_controller_recorded_opponent.c | 4 +- src/battle_controller_recorded_player.c | 4 +- src/battle_controller_safari.c | 2 +- src/battle_controller_wally.c | 2 +- src/battle_controllers.c | 128 +++--- 12 files changed, 633 insertions(+), 213 deletions(-) (limited to 'src') diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index de440054c..a57df85fb 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -941,7 +941,7 @@ static bool8 ShouldUseItem(void) if (shouldUse) { EmitTwoReturnValues(1, ACTION_USE_ITEM, 0); - *(gBattleStruct->field_C0 + (gActiveBank / 2) * 2) = item; + *(gBattleStruct->chosenItem + (gActiveBank / 2) * 2) = item; gBattleResources->battleHistory->trainerItems[i] = 0; return shouldUse; } diff --git a/src/battle_anim.c b/src/battle_anim.c index d41dc77c4..fa3ac73be 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -660,7 +660,7 @@ bool8 IsAnimBankSpriteVisible(u8 bank) else return FALSE; } - if (!AnimBankSpriteExists(bank)) + if (!IsBankSpritePresent(bank)) return FALSE; if (IsContest()) return TRUE; // this line wont ever be reached. diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 95cb80146..6d5059787 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -199,7 +199,7 @@ static void nullsub_28(void) { } -void SetBankFuncToLinkOpponentBufferRunCommand(void) +void SetControllerToLinkOpponent(void) { gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand; } @@ -1846,7 +1846,7 @@ static void LinkOpponentHandleCmd50(void) static void LinkOpponentHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 8ad497807..4fee08431 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -194,7 +194,7 @@ static void nullsub_112(void) { } -void SetBankFuncToLinkPartnerBufferRunCommand(void) +void SetControllerToLinkPartner(void) { gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; } @@ -1678,7 +1678,7 @@ static void LinkPartnerHandleCmd50(void) static void LinkPartnerHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 664d12142..fc19f9065 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -50,6 +50,9 @@ extern u16 gTrainerBattleOpponent_B; extern u32 gTransformedPersonalities[BATTLE_BANKS_COUNT]; extern u16 gBattle_BG0_X; extern u16 gBattle_BG0_Y; +extern u16 gUnknown_020243FC; +extern u8 gUnknown_020244B4[]; +extern void (*gPreBattleCallback1)(void); extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; extern const struct BattleMove gBattleMoves[]; @@ -57,76 +60,83 @@ extern const struct BattleMove gBattleMoves[]; extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); extern void sub_81A57E4(u8 bank, u16 stringId); +extern u8 sub_81A4CB0(void); +extern u8 sub_81D5588(u16 trainerId); +extern u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); +extern u8 GetEreaderTrainerFrontSpriteId(void); // this file's functions -void OpponentHandleGetMonData(void); -void OpponentHandleGetRawMonData(void); -void OpponentHandleSetMonData(void); -void OpponentHandleSetRawMonData(void); -void OpponentHandleLoadMonSprite(void); -void OpponentHandleSwitchInAnim(void); -void OpponentHandleReturnMonToBall(void); -void OpponentHandleDrawTrainerPic(void); -void OpponentHandleTrainerSlide(void); -void OpponentHandleTrainerSlideBack(void); -void OpponentHandleFaintAnimation(void); -void OpponentHandlePaletteFade(void); -void OpponentHandleSuccessBallThrowAnim(void); -void OpponentHandleBallThrow(void); -void OpponentHandlePause(void); -void OpponentHandleMoveAnimation(void); -void OpponentHandlePrintString(void); -void OpponentHandlePrintStringPlayerOnly(void); -void OpponentHandleChooseAction(void); -void OpponentHandleUnknownYesNoBox(void); -void OpponentHandleChooseMove(void); -void OpponentHandleOpenBag(void); -void OpponentHandleChoosePokemon(void); -void OpponentHandleCmd23(void); -void OpponentHandleHealthBarUpdate(void); -void OpponentHandleExpUpdate(void); -void OpponentHandleStatusIconUpdate(void); -void OpponentHandleStatusAnimation(void); -void OpponentHandleStatusXor(void); -void OpponentHandleDataTransfer(void); -void OpponentHandleDMA3Transfer(void); -void OpponentHandlePlayBGM(void); -void OpponentHandleCmd32(void); -void OpponentHandleCmd33(void); -void OpponentHandleCmd34(void); -void OpponentHandleCmd35(void); -void OpponentHandleCmd36(void); -void OpponentHandleCmd37(void); -void OpponentHandleCmd38(void); -void OpponentHandleCmd39(void); -void OpponentHandleCmd40(void); -void OpponentHandleHitAnimation(void); -void OpponentHandleCmd42(void); -void OpponentHandleEffectivenessSound(void); -void OpponentHandlePlayFanfareOrBGM(void); -void OpponentHandleFaintingCry(void); -void OpponentHandleIntroSlide(void); -void OpponentHandleIntroTrainerBallThrow(void); -void OpponentHandleDrawPartyStatusSummary(void); -void OpponentHandleCmd49(void); -void OpponentHandleCmd50(void); -void OpponentHandleSpriteInvisibility(void); -void OpponentHandleBattleAnimation(void); -void OpponentHandleLinkStandbyMsg(void); -void OpponentHandleResetActionMoveSelection(void); -void OpponentHandleCmd55(void); -void nullsub_91(void); - -void OpponentBufferRunCommand(void); -void OpponentBufferExecCompleted(void); -void bx_803AEDC(void); -u32 sub_8060004(u8 monId, u8 *dst); -void sub_8060890(u8 monId); -void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit); -void DoSwitchOutAnimation(void); -void OpponentDoMoveAnimation(void); - -void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void OpponentHandleGetMonData(void); +static void OpponentHandleGetRawMonData(void); +static void OpponentHandleSetMonData(void); +static void OpponentHandleSetRawMonData(void); +static void OpponentHandleLoadMonSprite(void); +static void OpponentHandleSwitchInAnim(void); +static void OpponentHandleReturnMonToBall(void); +static void OpponentHandleDrawTrainerPic(void); +static void OpponentHandleTrainerSlide(void); +static void OpponentHandleTrainerSlideBack(void); +static void OpponentHandleFaintAnimation(void); +static void OpponentHandlePaletteFade(void); +static void OpponentHandleSuccessBallThrowAnim(void); +static void OpponentHandleBallThrow(void); +static void OpponentHandlePause(void); +static void OpponentHandleMoveAnimation(void); +static void OpponentHandlePrintString(void); +static void OpponentHandlePrintStringPlayerOnly(void); +static void OpponentHandleChooseAction(void); +static void OpponentHandleUnknownYesNoBox(void); +static void OpponentHandleChooseMove(void); +static void OpponentHandleChooseItem(void); +static void OpponentHandleChoosePokemon(void); +static void OpponentHandleCmd23(void); +static void OpponentHandleHealthBarUpdate(void); +static void OpponentHandleExpUpdate(void); +static void OpponentHandleStatusIconUpdate(void); +static void OpponentHandleStatusAnimation(void); +static void OpponentHandleStatusXor(void); +static void OpponentHandleDataTransfer(void); +static void OpponentHandleDMA3Transfer(void); +static void OpponentHandlePlayBGM(void); +static void OpponentHandleCmd32(void); +static void OpponentHandleTwoReturnValues(void); +static void OpponentHandleChosenMonReturnValue(void); +static void OpponentHandleOneReturnValue(void); +static void OpponentHandleOneReturnValue_Duplicate(void); +static void OpponentHandleCmd37(void); +static void OpponentHandleCmd38(void); +static void OpponentHandleCmd39(void); +static void OpponentHandleCmd40(void); +static void OpponentHandleHitAnimation(void); +static void OpponentHandleCmd42(void); +static void OpponentHandleEffectivenessSound(void); +static void OpponentHandlePlayFanfareOrBGM(void); +static void OpponentHandleFaintingCry(void); +static void OpponentHandleIntroSlide(void); +static void OpponentHandleIntroTrainerBallThrow(void); +static void OpponentHandleDrawPartyStatusSummary(void); +static void OpponentHandleCmd49(void); +static void OpponentHandleCmd50(void); +static void OpponentHandleSpriteInvisibility(void); +static void OpponentHandleBattleAnimation(void); +static void OpponentHandleLinkStandbyMsg(void); +static void OpponentHandleResetActionMoveSelection(void); +static void OpponentHandleCmd55(void); +static void nullsub_91(void); + +static void OpponentBufferRunCommand(void); +static void OpponentBufferExecCompleted(void); +static void sub_805FC80(void); +static u32 GetOpponentMonData(u8 monId, u8 *dst); +static void SetOpponentMonData(u8 monId); +static void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit); +static void DoSwitchOutAnimation(void); +static void OpponentDoMoveAnimation(void); +static void sub_806280C(struct Sprite *sprite); +static void sub_8062828(u8 taskId); +static void sub_8062A2C(void); + +static void (*const sOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = { OpponentHandleGetMonData, OpponentHandleGetRawMonData, @@ -149,7 +159,7 @@ void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = OpponentHandleChooseAction, OpponentHandleUnknownYesNoBox, OpponentHandleChooseMove, - OpponentHandleOpenBag, + OpponentHandleChooseItem, OpponentHandleChoosePokemon, OpponentHandleCmd23, OpponentHandleHealthBarUpdate, @@ -161,10 +171,10 @@ void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = OpponentHandleDMA3Transfer, OpponentHandlePlayBGM, OpponentHandleCmd32, - OpponentHandleCmd33, - OpponentHandleCmd34, - OpponentHandleCmd35, - OpponentHandleCmd36, + OpponentHandleTwoReturnValues, + OpponentHandleChosenMonReturnValue, + OpponentHandleOneReturnValue, + OpponentHandleOneReturnValue_Duplicate, OpponentHandleCmd37, OpponentHandleCmd38, OpponentHandleCmd39, @@ -190,39 +200,39 @@ void (*const gOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = // unknown unused data static const u8 sUnknown_0831C7AC[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; -void nullsub_26(void) +static void nullsub_26(void) { } -void SetBankFuncToOpponentBufferRunCommand(void) +void SetControllerToOpponent(void) { gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; } -void OpponentBufferRunCommand(void) +static void OpponentBufferRunCommand(void) { if (gBattleExecBuffer & gBitTable[gActiveBank]) { - if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gOpponentBufferCommands)) - gOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(sOpponentBufferCommands)) + sOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); else OpponentBufferExecCompleted(); } } -void CompleteOnBankSpriteCallbackDummy(void) +static void CompleteOnBankSpriteCallbackDummy(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) OpponentBufferExecCompleted(); } -void CompleteOnBankSpriteCallbackDummy2(void) +static void CompleteOnBankSpriteCallbackDummy2(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) OpponentBufferExecCompleted(); } -void sub_805F240(void) +static void sub_805F240(void) { if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) { @@ -233,7 +243,7 @@ void sub_805F240(void) } } -void sub_805F2A8(void) +static void sub_805F2A8(void) { if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF) { @@ -242,7 +252,7 @@ void sub_805F2A8(void) } } -void sub_805F2F0(void) +static void sub_805F2F0(void) { bool8 var = FALSE; bool8 var2; @@ -303,7 +313,7 @@ void sub_805F2F0(void) } } -void sub_805F560(void) +static void sub_805F560(void) { bool32 sp = FALSE; bool32 r10 = FALSE; @@ -385,7 +395,7 @@ void sub_805F560(void) } } -void sub_805F994(void) +static void sub_805F994(void) { if (gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1) sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); @@ -400,7 +410,7 @@ void sub_805F994(void) } } -void sub_805FA70(void) +static void CompleteOnHealthbarDone(void) { s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); @@ -412,7 +422,7 @@ void sub_805FA70(void) OpponentBufferExecCompleted(); } -void sub_805FAC4(void) +static void sub_805FAC4(void) { if (!gSprites[gBankSpriteIds[gActiveBank]].inUse) { @@ -421,7 +431,7 @@ void sub_805FAC4(void) } } -void sub_805FB08(void) +static void sub_805FB08(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive) { @@ -433,13 +443,13 @@ void sub_805FB08(void) } } -void CompleteOnInactiveTextPrinter(void) +static void CompleteOnInactiveTextPrinter(void) { if (!IsTextPrinterActive(0)) OpponentBufferExecCompleted(); } -void bx_blink_t7(void) +static void DoHitAnimBlinkSpriteEffect(void) { u8 spriteId = gBankSpriteIds[gActiveBank]; @@ -458,17 +468,17 @@ void bx_blink_t7(void) } } -void sub_805FC10(void) +static void sub_805FC10(void) { if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) { if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); - gBattleBankFunc[gActiveBank] = bx_803AEDC; + gBattleBankFunc[gActiveBank] = sub_805FC80; } } -void bx_803AEDC(void) +static void sub_805FC80(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { @@ -480,7 +490,7 @@ void bx_803AEDC(void) } } -void sub_805FD00(void) +static void sub_805FD00(void) { if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) { @@ -497,7 +507,7 @@ void sub_805FD00(void) } } -void sub_805FDF0(void) +static void sub_805FDF0(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8) sub_8172EF0(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); @@ -511,19 +521,19 @@ void sub_805FDF0(void) } } -void sub_805FEB8(void) +static void CompleteOnFinishedStatusAnimation(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].statusAnimActive) OpponentBufferExecCompleted(); } -void bx_803B0F4(void) +static void CompleteOnFinishedBattleAnimation(void) { if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animFromTableActive) OpponentBufferExecCompleted(); } -void OpponentBufferExecCompleted(void) +static void OpponentBufferExecCompleted(void) { gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -539,7 +549,7 @@ void OpponentBufferExecCompleted(void) } } -void OpponentHandleGetMonData(void) +static void OpponentHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; @@ -548,7 +558,7 @@ void OpponentHandleGetMonData(void) if (gBattleBufferA[gActiveBank][2] == 0) { - size += sub_8060004(gBattlePartyID[gActiveBank], monData); + size += GetOpponentMonData(gBattlePartyID[gActiveBank], monData); } else { @@ -556,7 +566,7 @@ void OpponentHandleGetMonData(void) for (i = 0; i < 6; i++) { if (monsToCheck & 1) - size += sub_8060004(i, monData + size); + size += GetOpponentMonData(i, monData + size); monsToCheck >>= 1; } } @@ -564,7 +574,7 @@ void OpponentHandleGetMonData(void) OpponentBufferExecCompleted(); } -u32 sub_8060004(u8 monId, u8 *dst) +static u32 GetOpponentMonData(u8 monId, u8 *dst) { struct BattlePokemon battleMon; struct MovePpInfo moveData; @@ -870,7 +880,7 @@ u32 sub_8060004(u8 monId, u8 *dst) return size; } -void OpponentHandleGetRawMonData(void) +static void OpponentHandleGetRawMonData(void) { struct BattlePokemon battleMon; u8 *src = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; @@ -884,14 +894,14 @@ void OpponentHandleGetRawMonData(void) OpponentBufferExecCompleted(); } -void OpponentHandleSetMonData(void) +static void OpponentHandleSetMonData(void) { u8 monsToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) { - sub_8060890(gBattlePartyID[gActiveBank]); + SetOpponentMonData(gBattlePartyID[gActiveBank]); } else { @@ -899,14 +909,14 @@ void OpponentHandleSetMonData(void) for (i = 0; i < 6; i++) { if (monsToCheck & 1) - sub_8060890(i); + SetOpponentMonData(i); monsToCheck >>= 1; } } OpponentBufferExecCompleted(); } -void sub_8060890(u8 monId) +static void SetOpponentMonData(u8 monId) { struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBank][3]; @@ -1122,7 +1132,7 @@ void sub_8060890(u8 monId) } } -void OpponentHandleSetRawMonData(void) +static void OpponentHandleSetRawMonData(void) { u8 *dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; u8 i; @@ -1133,7 +1143,7 @@ void OpponentHandleSetRawMonData(void) OpponentBufferExecCompleted(); } -void OpponentHandleLoadMonSprite(void) +static void OpponentHandleLoadMonSprite(void) { u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); @@ -1156,7 +1166,7 @@ void OpponentHandleLoadMonSprite(void) gBattleBankFunc[gActiveBank] = sub_805F994; } -void OpponentHandleSwitchInAnim(void) +static void OpponentHandleSwitchInAnim(void) { *(gBattleStruct->field_5C + gActiveBank) = 6; gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; @@ -1164,7 +1174,7 @@ void OpponentHandleSwitchInAnim(void) gBattleBankFunc[gActiveBank] = sub_805FDF0; } -void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit) +static void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit) { u16 species; @@ -1196,7 +1206,7 @@ void sub_80613DC(u8 bank, bool8 dontClearSubstituteBit) gSprites[gUnknown_03005D7C[bank]].data0 = sub_80753E8(0, 0xFE); } -void OpponentHandleReturnMonToBall(void) +static void OpponentHandleReturnMonToBall(void) { if (gBattleBufferA[gActiveBank][1] == 0) { @@ -1213,7 +1223,7 @@ void OpponentHandleReturnMonToBall(void) } } -void DoSwitchOutAnimation(void) +static void DoSwitchOutAnimation(void) { switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState) { @@ -1234,11 +1244,6 @@ void DoSwitchOutAnimation(void) } } -u8 sub_81A4CB0(void); -u8 sub_81D5588(u16 trainerId); -u8 GetFrontierTrainerFrontSpriteId(u16 trainerId); -u8 GetEreaderTrainerFrontSpriteId(void); - // todo: get rid of it once the struct is declared in a header struct MonCoords { @@ -1249,7 +1254,7 @@ struct MonCoords }; extern const struct MonCoords gTrainerFrontPicCoords[]; -void OpponentHandleDrawTrainerPic(void) +static void OpponentHandleDrawTrainerPic(void) { u32 trainerPicId; s16 xPos; @@ -1334,7 +1339,7 @@ void OpponentHandleDrawTrainerPic(void) gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy; } -void OpponentHandleTrainerSlide(void) +static void OpponentHandleTrainerSlide(void) { u32 trainerPicId; @@ -1404,7 +1409,7 @@ void OpponentHandleTrainerSlide(void) gBattleBankFunc[gActiveBank] = CompleteOnBankSpriteCallbackDummy2; } -void OpponentHandleTrainerSlideBack(void) +static void OpponentHandleTrainerSlideBack(void) { oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; @@ -1415,7 +1420,7 @@ void OpponentHandleTrainerSlideBack(void) gBattleBankFunc[gActiveBank] = sub_805F240; } -void OpponentHandleFaintAnimation(void) +static void OpponentHandleFaintAnimation(void) { if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].animationState == 0) { @@ -1435,27 +1440,27 @@ void OpponentHandleFaintAnimation(void) } } -void OpponentHandlePaletteFade(void) +static void OpponentHandlePaletteFade(void) { OpponentBufferExecCompleted(); } -void OpponentHandleSuccessBallThrowAnim(void) +static void OpponentHandleSuccessBallThrowAnim(void) { OpponentBufferExecCompleted(); } -void OpponentHandleBallThrow(void) +static void OpponentHandleBallThrow(void) { OpponentBufferExecCompleted(); } -void OpponentHandlePause(void) +static void OpponentHandlePause(void) { OpponentBufferExecCompleted(); } -void OpponentHandleMoveAnimation(void) +static void OpponentHandleMoveAnimation(void) { if (!mplay_80342A4(gActiveBank)) { @@ -1480,7 +1485,7 @@ void OpponentHandleMoveAnimation(void) } } -void OpponentDoMoveAnimation(void) +static void OpponentDoMoveAnimation(void) { u16 move = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); u8 multihit = gBattleBufferA[gActiveBank][11]; @@ -1529,7 +1534,7 @@ void OpponentDoMoveAnimation(void) } } -void OpponentHandlePrintString(void) +static void OpponentHandlePrintString(void) { u16 *stringId; @@ -1542,23 +1547,23 @@ void OpponentHandlePrintString(void) sub_81A57E4(gActiveBank, *stringId); } -void OpponentHandlePrintStringPlayerOnly(void) +static void OpponentHandlePrintStringPlayerOnly(void) { OpponentBufferExecCompleted(); } -void OpponentHandleChooseAction(void) +static void OpponentHandleChooseAction(void) { AI_TrySwitchOrUseItem(); OpponentBufferExecCompleted(); } -void OpponentHandleUnknownYesNoBox(void) +static void OpponentHandleUnknownYesNoBox(void) { OpponentBufferExecCompleted(); } -void OpponentHandleChooseMove(void) +static void OpponentHandleChooseMove(void) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -1621,3 +1626,418 @@ void OpponentHandleChooseMove(void) } } } + +static void OpponentHandleChooseItem(void) +{ + EmitOneReturnValue(1, *(gBattleStruct->chosenItem + (gActiveBank / 2) * 2)); + OpponentBufferExecCompleted(); +} + +static void OpponentHandleChoosePokemon(void) +{ + s32 chosenMonId; + + if (*(gBattleStruct->field_294 + gActiveBank) == 6) + { + chosenMonId = GetMostSuitableMonToSwitchInto(); + + if (chosenMonId == 6) + { + s32 bank1, bank2, firstId, lastId; + + if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) + { + bank2 = bank1 = GetBankByIdentity(IDENTITY_OPPONENT_MON1); + } + else + { + bank1 = GetBankByIdentity(IDENTITY_OPPONENT_MON1); + bank2 = GetBankByIdentity(IDENTITY_OPPONENT_MON2); + } + + if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_x800000)) + { + if (gActiveBank == 1) + firstId = 0, lastId = 3; + else + firstId = 3, lastId = 6; + } + else + { + firstId = 0, lastId = 6; + } + + for (chosenMonId = firstId; chosenMonId < lastId; chosenMonId++) + { + if (GetMonData(&gEnemyParty[chosenMonId], MON_DATA_HP) != 0 + && chosenMonId != gBattlePartyID[bank1] + && chosenMonId != gBattlePartyID[bank2]) + { + break; + } + } + } + } + else + { + chosenMonId = *(gBattleStruct->field_294 + gActiveBank); + *(gBattleStruct->field_294 + gActiveBank) = 6; + } + + + *(gBattleStruct->field_5C + gActiveBank) = chosenMonId; + EmitChosenMonReturnValue(1, chosenMonId, NULL); + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd23(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = (gBattleBufferA[gActiveBank][3] << 8) | gBattleBufferA[gActiveBank][2]; + + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBank, gHealthBoxesIds[gActiveBank], maxHP, 0, hpVal); + } + + gBattleBankFunc[gActiveBank] = CompleteOnHealthbarDone; +} + +static void OpponentHandleExpUpdate(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 bank; + + UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_STATUS_ICON); + bank = gActiveBank; + gBattleSpritesDataPtr->healthBoxesData[bank].statusAnimActive = 0; + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void OpponentHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + DoStatusAnimation(gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = CompleteOnFinishedStatusAnimation; + } +} + +static void OpponentHandleStatusXor(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleDataTransfer(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleDMA3Transfer(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandlePlayBGM(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd32(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleTwoReturnValues(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleChosenMonReturnValue(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleOneReturnValue(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleOneReturnValue_Duplicate(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd37(void) +{ + gUnknown_02022D0C.field_0 = 0; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd38(void) +{ + gUnknown_02022D0C.field_0 = gBattleBufferA[gActiveBank][1]; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd39(void) +{ + gUnknown_02022D0C.flag_x80 = 0; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd40(void) +{ + gUnknown_02022D0C.flag_x80 ^= 1; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleHitAnimation(void) +{ + if (gSprites[gBankSpriteIds[gActiveBank]].invisible == TRUE) + { + OpponentBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBankSpriteIds[gActiveBank]].data1 = 0; + DoHitAnimHealthboxEffect(gActiveBank); + gBattleBankFunc[gActiveBank] = DoHitAnimBlinkSpriteEffect; + } +} + +static void OpponentHandleCmd42(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == SIDE_PLAYER) + pan = PAN_SIDE_PLAYER; + else + pan = PAN_SIDE_OPPONENT; + + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + OpponentBufferExecCompleted(); +} + +static void OpponentHandlePlayFanfareOrBGM(void) +{ + if (gBattleBufferA[gActiveBank][3]) + { + BattleMusicStop(); + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + else + { + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + } + + OpponentBufferExecCompleted(); +} + +static void OpponentHandleFaintingCry(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, 25, 5); + OpponentBufferExecCompleted(); +} + +static void OpponentHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBank][1]); + gUnknown_020243FC |= 1; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gBankSpriteIds[gActiveBank]]); + + gSprites[gBankSpriteIds[gActiveBank]].data0 = 35; + gSprites[gBankSpriteIds[gActiveBank]].data2 = 280; + gSprites[gBankSpriteIds[gActiveBank]].data4 = gSprites[gBankSpriteIds[gActiveBank]].pos1.y; + gSprites[gBankSpriteIds[gActiveBank]].callback = sub_80A6EEC; + + StoreSpriteCallbackInData6(&gSprites[gBankSpriteIds[gActiveBank]], sub_806280C); + + taskId = CreateTask(sub_8062828, 5); + gTasks[taskId].data[0] = gActiveBank; + + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattleBankFunc[gActiveBank] = nullsub_26; +} + +static void sub_806280C(struct Sprite *sprite) +{ + FreeTrainerFrontPicPalette(sprite->oam.affineParam); + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); +} + +static void sub_8062828(u8 taskId) +{ + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80613DC(gActiveBank, FALSE); + } + else if ((gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80613DC(gActiveBank, FALSE); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80613DC(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80613DC(gActiveBank, FALSE); + gActiveBank ^= BIT_MON; + } + gBattleBankFunc[gActiveBank] = sub_805F560; + gActiveBank = savedActiveBank; + DestroyTask(taskId); +} + +static void OpponentHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == SIDE_PLAYER) + { + OpponentBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1 = 1; + + if (gBattleBufferA[gActiveBank][2] != 0) + { + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E < 2) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E++; + return; + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1E = 0; + } + } + + gUnknown_020244B4[gActiveBank] = CreatePartyStatusSummarySprites(gActiveBank, (struct HpAndStatus *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + + if (gBattleBufferA[gActiveBank][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0x5D; + + gBattleBankFunc[gActiveBank] = sub_8062A2C; + } +} + +static void sub_8062A2C(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_5 = 0; + OpponentBufferExecCompleted(); + } +} + +static void OpponentHandleCmd49(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x1) + gTasks[gUnknown_020244B4[gActiveBank]].func = sub_8073C30; + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd50(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleSpriteInvisibility(void) +{ + if (IsBankSpritePresent(gActiveBank)) + { + gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + } + OpponentBufferExecCompleted(); +} + +static void OpponentHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 animationId = gBattleBufferA[gActiveBank][1]; + u16 argument = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (DoBattleAnimationFromTable(gActiveBank, gActiveBank, gActiveBank, animationId, argument)) + OpponentBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = CompleteOnFinishedBattleAnimation; + } +} + +static void OpponentHandleLinkStandbyMsg(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleResetActionMoveSelection(void) +{ + OpponentBufferExecCompleted(); +} + +static void OpponentHandleCmd55(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_LINK && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) + { + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + OpponentBufferExecCompleted(); +} + +static void nullsub_91(void) +{ +} diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 68e328acc..a07aacd20 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -239,7 +239,7 @@ void nullsub_21(void) { } -void SetBankFuncToPlayerBufferRunCommand(void) +void SetControllerToPlayer(void) { gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; gDoingBattleAnim = FALSE; @@ -3083,7 +3083,7 @@ static void PlayerHandleCmd50(void) static void PlayerHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 283c79e66..cc659972e 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -209,7 +209,7 @@ static void nullsub_77(void) { } -void SetBankFuncToPlayerPartnerBufferRunCommand(void) +void SetControllerToPlayerPartner(void) { gBattleBankFunc[gActiveBank] = PlayerPartnerBufferRunCommand; } @@ -1924,7 +1924,7 @@ static void PlayerPartnerHandleCmd50(void) static void PlayerPartnerHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 8f30febe2..9043f84e6 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -198,7 +198,7 @@ static void nullsub_70(void) { } -void SetBankFuncToRecordedOpponentBufferRunCommand(void) +void SetControllerToRecordedOpponent(void) { gBattleBankFunc[gActiveBank] = RecordedOpponentBufferRunCommand; } @@ -1788,7 +1788,7 @@ static void RecordedOpponentHandleCmd50(void) static void RecordedOpponentHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 4e71537b0..971a3e656 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -197,7 +197,7 @@ static void nullsub_120(void) { } -void SetBankFuncToRecordedPlayerBufferRunCommand(void) +void SetControllerToRecordedPlayer(void) { gBattleBankFunc[gActiveBank] = RecordedPlayerBufferRunCommand; } @@ -1808,7 +1808,7 @@ static void RecordedPlayerHandleCmd50(void) static void RecordedPlayerHandleSpriteInvisibility(void) { - if (AnimBankSpriteExists(gActiveBank)) + if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 6eb19df84..292a631f4 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -175,7 +175,7 @@ static void nullsub_114(void) { } -void SetBankFuncToSafariBufferRunCommand(void) +void SetControllerToSafari(void) { gBattleBankFunc[gActiveBank] = SafariBufferRunCommand; } diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 5e454deb5..3314cfe21 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -201,7 +201,7 @@ static void nullsub_117(void) { } -void SetBankFuncToWallyBufferRunCommand(void) +void SetControllerToWally(void) { gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; gBattleStruct->wallyBattleState = 0; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index ee835586b..2ba245363 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -145,30 +145,30 @@ static void SetControllersVariables(void) if (gBattleTypeFlags & BATTLE_TYPE_RECORDED) { - gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToPlayerPartnerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToPlayerPartner; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; } else { - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToPlayerPartnerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToPlayerPartner; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; } @@ -189,15 +189,15 @@ static void SetControllersVariables(void) gBattleMainFunc = BeginBattleIntro; if (gBattleTypeFlags & BATTLE_TYPE_SAFARI) - gBattleBankFunc[0] = SetBankFuncToSafariBufferRunCommand; + gBattleBankFunc[0] = SetControllerToSafari; else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) - gBattleBankFunc[0] = SetBankFuncToWallyBufferRunCommand; + gBattleBankFunc[0] = SetControllerToWally; else - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; gNoOfAllBanks = 2; @@ -210,20 +210,20 @@ static void SetControllersVariables(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToRecordedOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; gNoOfAllBanks = 2; } else // see how the banks are switched { - gBattleBankFunc[1] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[1] = SetControllerToRecordedPlayer; gBanksByIdentity[1] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[0] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedOpponent; gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1; gNoOfAllBanks = 2; @@ -231,10 +231,10 @@ static void SetControllersVariables(void) } else { - gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; } } @@ -243,16 +243,16 @@ static void SetControllersVariables(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToPlayer; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; gNoOfAllBanks = 4; @@ -263,16 +263,16 @@ static void SetControllersVariables(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedPlayer; gBanksByIdentity[0] = 0; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = 1; - gBattleBankFunc[2] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToRecordedPlayer; gBanksByIdentity[2] = 2; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = 3; gNoOfAllBanks = 4; @@ -307,7 +307,7 @@ static void SetControllersVariables(void) if (i == var) { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer; switch (gLinkPlayers[i].lp_field_18) { case 0: @@ -325,7 +325,7 @@ static void SetControllersVariables(void) else if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[var].lp_field_18 & 1)) || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[var].lp_field_18 & 1))) { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer; switch (gLinkPlayers[i].lp_field_18) { case 0: @@ -342,7 +342,7 @@ static void SetControllersVariables(void) } else { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedOpponent; switch (gLinkPlayers[i].lp_field_18) { case 0: @@ -361,51 +361,51 @@ static void SetControllersVariables(void) } else if (gBattleTypeFlags & BATTLE_TYPE_WILD) { - gBattleBankFunc[0] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[2] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToRecordedPlayer; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; if (gBattleTypeFlags & BATTLE_TYPE_x2000000) { - gBattleBankFunc[1] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToRecordedOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[3] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToRecordedOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; } else { - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; } } else { - gBattleBankFunc[1] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[1] = SetControllerToRecordedPlayer; gBanksByIdentity[1] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[3] = SetBankFuncToRecordedPlayerBufferRunCommand; + gBattleBankFunc[3] = SetControllerToRecordedPlayer; gBanksByIdentity[3] = IDENTITY_PLAYER_MON2; if (gBattleTypeFlags & BATTLE_TYPE_x2000000) { - gBattleBankFunc[0] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[0] = SetControllerToRecordedOpponent; gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToRecordedOpponentBufferRunCommand; + gBattleBankFunc[2] = SetControllerToRecordedOpponent; gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2; } else { - gBattleBankFunc[0] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[0] = SetControllerToOpponent; gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[2] = SetControllerToOpponent; gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2; } } @@ -424,20 +424,20 @@ static void SetControllersVariablesInLinkBattle(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToLinkOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; gNoOfAllBanks = 2; } else { - gBattleBankFunc[1] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[1] = SetControllerToPlayer; gBanksByIdentity[1] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[0] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[0] = SetControllerToLinkOpponent; gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1; gNoOfAllBanks = 2; @@ -449,32 +449,32 @@ static void SetControllersVariablesInLinkBattle(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToLinkOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToPlayer; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToLinkOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; gNoOfAllBanks = 4; } else { - gBattleBankFunc[1] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[1] = SetControllerToPlayer; gBanksByIdentity[1] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[0] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[0] = SetControllerToLinkOpponent; gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[3] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[3] = SetControllerToPlayer; gBanksByIdentity[3] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[2] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[2] = SetControllerToLinkOpponent; gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2; gNoOfAllBanks = 4; @@ -486,32 +486,32 @@ static void SetControllersVariablesInLinkBattle(void) { gBattleMainFunc = BeginBattleIntro; - gBattleBankFunc[0] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToPlayer; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToLinkPartnerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToLinkPartner; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; gNoOfAllBanks = 4; } else { - gBattleBankFunc[0] = SetBankFuncToLinkPartnerBufferRunCommand; + gBattleBankFunc[0] = SetControllerToLinkPartner; gBanksByIdentity[0] = IDENTITY_PLAYER_MON1; - gBattleBankFunc[1] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[1] = SetControllerToLinkOpponent; gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1; - gBattleBankFunc[2] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[2] = SetControllerToPlayer; gBanksByIdentity[2] = IDENTITY_PLAYER_MON2; - gBattleBankFunc[3] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[3] = SetControllerToLinkOpponent; gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2; gNoOfAllBanks = 4; @@ -549,7 +549,7 @@ static void SetControllersVariablesInLinkBattle(void) if (i == multiplayerId) { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToPlayerBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToPlayer; switch (gLinkPlayers[i].lp_field_18) { case 0: @@ -569,7 +569,7 @@ static void SetControllersVariablesInLinkBattle(void) if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[multiplayerId].lp_field_18 & 1)) || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[multiplayerId].lp_field_18 & 1))) { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToLinkPartnerBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToLinkPartner; switch (gLinkPlayers[i].lp_field_18) { case 0: @@ -586,7 +586,7 @@ static void SetControllersVariablesInLinkBattle(void) } else { - gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetBankFuncToLinkOpponentBufferRunCommand; + gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToLinkOpponent; switch (gLinkPlayers[i].lp_field_18) { case 0: -- cgit v1.2.3 From a41b90ae6224167497a8fa6a28d064195ff369da Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Thu, 26 Oct 2017 23:18:24 +0200 Subject: clear two emitters --- src/battle_controllers.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 2ba245363..9d9eea24c 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -1036,9 +1036,9 @@ void EmitTrainerSlideBack(u8 bufferId) void EmitFaintAnimation(u8 bufferId) { gBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION; - gBattleBuffersTransferData[1] = 10; - gBattleBuffersTransferData[2] = 10; - gBattleBuffersTransferData[3] = 10; + gBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION; + gBattleBuffersTransferData[2] = CONTROLLER_FAINTANIMATION; + gBattleBuffersTransferData[3] = CONTROLLER_FAINTANIMATION; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -1146,7 +1146,7 @@ void EmitPrintStringPlayerOnly(u8 bufferId, u16 stringID) struct StringInfoBattle* stringInfo; gBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRINGPLAYERONLY; - gBattleBuffersTransferData[1] = 17; + gBattleBuffersTransferData[1] = CONTROLLER_PRINTSTRINGPLAYERONLY; gBattleBuffersTransferData[2] = stringID; gBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8; -- cgit v1.2.3 From 2d14e6bb67a40f2824c9b183fc52fa0837cfebf8 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 27 Oct 2017 13:29:18 +0200 Subject: name one var --- src/battle_controller_link_opponent.c | 2 +- src/battle_controller_link_partner.c | 2 +- src/battle_controller_opponent.c | 3 +-- src/battle_controller_player.c | 24 ++++++++++++------------ src/battle_controller_player_partner.c | 2 +- src/battle_controller_recorded_opponent.c | 2 +- src/battle_controller_recorded_player.c | 2 +- src/battle_controller_wally.c | 3 +-- 8 files changed, 19 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 6d5059787..02a2ffdff 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -419,7 +419,7 @@ static void sub_8064B04(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 4fee08431..9f44fcf1c 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -301,7 +301,7 @@ static void sub_814B290(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index fc19f9065..61886575c 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -31,7 +31,6 @@ extern u8 gActiveBank; extern u8 gBankTarget; extern u8 gAbsentBankFlags; extern bool8 gDoingBattleAnim; -extern u8 gUnknown_020244CC; extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT]; extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; @@ -412,7 +411,7 @@ static void sub_805F994(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); if (hpValue != -1) { diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index a07aacd20..69df9f70b 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -33,7 +33,7 @@ extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT]; extern u8 gAbsentBankFlags; extern u8 gNoOfAllBanks; extern bool8 gDoingBattleAnim; -extern u8 gUnknown_020244CC; +extern u8 gPlayerDpadHoldFrames; extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); extern void (*gPreBattleCallback1)(void); extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; @@ -243,7 +243,7 @@ void SetControllerToPlayer(void) { gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; gDoingBattleAnim = FALSE; - gUnknown_020244CC = 0; + gPlayerDpadHoldFrames = 0; } static void PlayerBufferExecCompleted(void) @@ -287,9 +287,9 @@ static void HandleInputChooseAction(void) dp11b_obj_instanciate(gActiveBank, 0, 7, 1); if (gMain.newAndRepeatedKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) - gUnknown_020244CC++; + gPlayerDpadHoldFrames++; else - gUnknown_020244CC = 0; + gPlayerDpadHoldFrames = 0; if (gMain.newKeys & A_BUTTON) { @@ -352,7 +352,7 @@ static void HandleInputChooseAction(void) ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0); } } - else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + else if (gMain.newKeys & B_BUTTON || gPlayerDpadHoldFrames > 59) { if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON2 @@ -406,9 +406,9 @@ static void HandleInputChooseTarget(void) } if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) - gUnknown_020244CC++; + gPlayerDpadHoldFrames++; else - gUnknown_020244CC = 0; + gPlayerDpadHoldFrames = 0; if (gMain.newKeys & A_BUTTON) { @@ -418,7 +418,7 @@ static void HandleInputChooseTarget(void) dp11b_obj_free(gMultiUsePlayerCursor, 1); PlayerBufferExecCompleted(); } - else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + else if (gMain.newKeys & B_BUTTON || gPlayerDpadHoldFrames > 59) { PlaySE(SE_SELECT); gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C; @@ -519,9 +519,9 @@ static void HandleInputChooseMove(void) struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]); if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2) - gUnknown_020244CC++; + gPlayerDpadHoldFrames++; else - gUnknown_020244CC = 0; + gPlayerDpadHoldFrames = 0; if (gMain.newKeys & A_BUTTON) { @@ -585,7 +585,7 @@ static void HandleInputChooseMove(void) gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8; } } - else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59) + else if (gMain.newKeys & B_BUTTON || gPlayerDpadHoldFrames > 59) { PlaySE(SE_SELECT); EmitTwoReturnValues(1, 10, 0xFFFF); @@ -1153,7 +1153,7 @@ void c3_0802FDF4(u8 taskId) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index cc659972e..e40ba8a69 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -316,7 +316,7 @@ static void sub_81BB1D4(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 9043f84e6..69ae9e343 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -403,7 +403,7 @@ static void sub_8186C48(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 971a3e656..76ac40ef0 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -386,7 +386,7 @@ static void sub_818A064(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 3314cfe21..693008110 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -34,7 +34,6 @@ extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT]; extern u8 gAbsentBankFlags; extern u8 gNoOfAllBanks; extern bool8 gDoingBattleAnim; -extern u8 gUnknown_020244CC; extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void); extern u16 gBattlePartyID[BATTLE_BANKS_COUNT]; extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200]; @@ -377,7 +376,7 @@ static void sub_8168818(void) static void CompleteOnHealthbarDone(void) { - s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0); + s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], HEALTH_BAR, 0); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); -- cgit v1.2.3 From 712ae5616734f91fdc3cea821349f397af798905 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 31 Oct 2017 18:04:08 +0100 Subject: review change battle controllers --- src/battle_controller_link_opponent.c | 55 +++++++++++++------------------ src/battle_controller_link_partner.c | 36 ++++++++------------ src/battle_controller_opponent.c | 35 ++++++++------------ src/battle_controller_player.c | 36 ++++++++------------ src/battle_controller_player_partner.c | 36 ++++++++------------ src/battle_controller_recorded_opponent.c | 35 ++++++++------------ src/battle_controller_recorded_player.c | 36 ++++++++------------ src/battle_controller_safari.c | 15 ++------- src/battle_controller_wally.c | 31 +++++++---------- src/battle_controllers.c | 8 ++--- src/battle_dome_cards.c | 6 ++-- src/pokemon_2.c | 4 +-- src/pokemon_3.c | 4 +-- 13 files changed, 125 insertions(+), 212 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 02a2ffdff..a7e7ad022 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -21,6 +21,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -56,7 +57,7 @@ extern u16 gTrainerBattleOpponent_B; extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; extern const struct BattleMove gBattleMoves[]; -extern const u8 gTrainerClassToFrontPicId[]; +extern const u8 gUnknown_0831F578[]; extern void sub_8172EF0(u8 bank, struct Pokemon *mon); extern void sub_806A068(u16, u8); @@ -134,7 +135,7 @@ static void sub_8067618(u8 taskId); static void sub_80676FC(struct Sprite *sprite); static void sub_806782C(void); -static void (*const sLinkOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { LinkOpponentHandleGetMonData, LinkOpponentHandleGetRawMonData, @@ -519,7 +520,7 @@ static void sub_8064E50(void) UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); sub_8076918(gActiveBank); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); gBattleBankFunc[gActiveBank] = sub_8064D60; } } @@ -561,7 +562,7 @@ static void LinkOpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -573,7 +574,7 @@ static void LinkOpponentHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -582,12 +583,12 @@ static void LinkOpponentHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyLinkOpponentMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -907,7 +908,7 @@ static void LinkOpponentHandleGetRawMonData(void) static void LinkOpponentHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -916,12 +917,12 @@ static void LinkOpponentHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetLinkOpponentMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } LinkOpponentBufferExecCompleted(); @@ -1166,8 +1167,6 @@ static void LinkOpponentHandleLoadMonSprite(void) sub_80A6138(gActiveBank), sub_80A82E4(gActiveBank)); - - gSprites[gBankSpriteIds[gActiveBank]].pos2.x = -240; gSprites[gBankSpriteIds[gActiveBank]].data0 = gActiveBank; gSprites[gBankSpriteIds[gActiveBank]].oam.paletteNum = gActiveBank; @@ -1255,16 +1254,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerFrontPicCoords[]; - static void LinkOpponentHandleDrawTrainerPic(void) { s16 xPos; @@ -1290,17 +1279,17 @@ static void LinkOpponentHandleDrawTrainerPic(void) || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_LEAF_GREEN) { if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) - trainerPicId = gTrainerClassToFrontPicId[0x4F]; + trainerPicId = gUnknown_0831F578[0x4F]; else - trainerPicId = gTrainerClassToFrontPicId[0x4E]; + trainerPicId = gUnknown_0831F578[0x4E]; } else if ((gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_RUBY || (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].version & 0xFF) == VERSION_SAPPHIRE) { if (gLinkPlayers[GetBankMultiplayerId(gActiveBank)].gender != 0) - trainerPicId = gTrainerClassToFrontPicId[0x51]; + trainerPicId = gUnknown_0831F578[0x51]; else - trainerPicId = gTrainerClassToFrontPicId[0x50]; + trainerPicId = gUnknown_0831F578[0x50]; } else { @@ -1319,17 +1308,17 @@ static void LinkOpponentHandleDrawTrainerPic(void) || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_LEAF_GREEN) { if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) - trainerPicId = gTrainerClassToFrontPicId[0x4F]; + trainerPicId = gUnknown_0831F578[0x4F]; else - trainerPicId = gTrainerClassToFrontPicId[0x4E]; + trainerPicId = gUnknown_0831F578[0x4E]; } else if ((gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_RUBY || (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].version & 0xFF) == VERSION_SAPPHIRE) { if (gLinkPlayers[GetMultiplayerId() ^ BIT_SIDE].gender != 0) - trainerPicId = gTrainerClassToFrontPicId[0x51]; + trainerPicId = gUnknown_0831F578[0x51]; else - trainerPicId = gTrainerClassToFrontPicId[0x50]; + trainerPicId = gUnknown_0831F578[0x50]; } else { @@ -1849,7 +1838,7 @@ static void LinkOpponentHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } LinkOpponentBufferExecCompleted(); } diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 9f44fcf1c..33fa7abd5 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -21,6 +21,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -129,7 +130,7 @@ static void LinkPartnerDoMoveAnimation(void); static void sub_814DCCC(u8 taskId); static void sub_814DE9C(void); -static void (*const sLinkPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { LinkPartnerHandleGetMonData, LinkPartnerHandleGetRawMonData, @@ -370,7 +371,7 @@ static void sub_814B4E0(void) { if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) { - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); @@ -432,7 +433,7 @@ static void LinkPartnerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -456,7 +457,7 @@ static void LinkPartnerHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -465,12 +466,12 @@ static void LinkPartnerHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyLinkPartnerMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -790,7 +791,7 @@ static void LinkPartnerHandleGetRawMonData(void) static void LinkPartnerHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -799,12 +800,12 @@ static void LinkPartnerHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetLinkPartnerMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } LinkPartnerBufferExecCompleted(); @@ -1135,17 +1136,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; -extern const struct MonCoords gTrainerFrontPicCoords[]; - static void LinkPartnerHandleDrawTrainerPic(void) { s16 xPos; @@ -1681,7 +1671,7 @@ static void LinkPartnerHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } LinkPartnerBufferExecCompleted(); } diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 61886575c..4772cba50 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -25,6 +25,7 @@ #include "reshow_battle_screen.h" #include "rng.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -135,7 +136,7 @@ static void sub_806280C(struct Sprite *sprite); static void sub_8062828(u8 taskId); static void sub_8062A2C(void); -static void (*const sOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { OpponentHandleGetMonData, OpponentHandleGetRawMonData, @@ -501,7 +502,7 @@ static void sub_805FD00(void) UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); sub_8076918(gActiveBank); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); gBattleBankFunc[gActiveBank] = sub_805FC10; } } @@ -540,7 +541,7 @@ static void OpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -552,7 +553,7 @@ static void OpponentHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -561,12 +562,12 @@ static void OpponentHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += GetOpponentMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -895,7 +896,7 @@ static void OpponentHandleGetRawMonData(void) static void OpponentHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -904,12 +905,12 @@ static void OpponentHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetOpponentMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } OpponentBufferExecCompleted(); @@ -1243,16 +1244,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerFrontPicCoords[]; - static void OpponentHandleDrawTrainerPic(void) { u32 trainerPicId; @@ -1997,7 +1988,7 @@ static void OpponentHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } OpponentBufferExecCompleted(); } diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 69df9f70b..ffd0a6ce3 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -24,6 +24,7 @@ #include "reshow_battle_screen.h" #include "rng.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -169,7 +170,7 @@ static void PlayerDoMoveAnimation(void); static void task05_08033660(u8 taskId); static void sub_805CE38(void); -static void (*const sPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { PlayerHandleGetMonData, PlayerHandleGetRawMonData, @@ -254,7 +255,7 @@ static void PlayerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -1099,7 +1100,7 @@ static void sub_8058EDC(void) && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy) { - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0; gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0; FreeSpriteTilesByTag(0x27F9); @@ -1614,7 +1615,7 @@ static void PlayerHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -1623,12 +1624,12 @@ static void PlayerHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyPlayerMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -1957,7 +1958,7 @@ void PlayerHandleGetRawMonData(void) static void PlayerHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -1966,12 +1967,12 @@ static void PlayerHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetPlayerMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } PlayerBufferExecCompleted(); @@ -2292,17 +2293,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; -extern const struct MonCoords gTrainerFrontPicCoords[]; - // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it @@ -3086,7 +3076,7 @@ static void PlayerHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } PlayerBufferExecCompleted(); } diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index e40ba8a69..df35e54c4 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -20,6 +20,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -135,7 +136,7 @@ static void PlayerPartnerDoMoveAnimation(void); static void sub_81BE2C8(u8 taskId); static void sub_81BE498(void); -static void (*const sPlayerPartnerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { PlayerPartnerHandleGetMonData, PlayerPartnerHandleGetRawMonData, @@ -557,7 +558,7 @@ static void sub_81BB92C(void) { if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) { - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); @@ -619,7 +620,7 @@ static void PlayerPartnerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -643,7 +644,7 @@ static void PlayerPartnerHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -652,12 +653,12 @@ static void PlayerPartnerHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyPlayerPartnerMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -977,7 +978,7 @@ static void PlayerPartnerHandleGetRawMonData(void) static void PlayerPartnerHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -986,12 +987,12 @@ static void PlayerPartnerHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetPlayerPartnerMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } PlayerPartnerBufferExecCompleted(); @@ -1322,17 +1323,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; -extern const struct MonCoords gTrainerFrontPicCoords[]; - // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it @@ -1927,7 +1917,7 @@ static void PlayerPartnerHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } PlayerPartnerBufferExecCompleted(); } diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 69ae9e343..feb8aef19 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -22,6 +22,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -133,7 +134,7 @@ static void sub_8189548(u8 taskId); static void sub_818962C(struct Sprite *sprite); static void sub_818975C(void); -static void (*const sRecordedOpponentBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { RecordedOpponentHandleGetMonData, RecordedOpponentHandleGetRawMonData, @@ -504,7 +505,7 @@ static void sub_8186F94(void) UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL); sub_8076918(gActiveBank); SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]); - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); gBattleBankFunc[gActiveBank] = sub_8186EA4; } } @@ -546,7 +547,7 @@ static void RecordedOpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -558,7 +559,7 @@ static void RecordedOpponentHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -567,12 +568,12 @@ static void RecordedOpponentHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyRecordedOpponentMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -892,7 +893,7 @@ static void RecordedOpponentHandleGetRawMonData(void) static void RecordedOpponentHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -901,12 +902,12 @@ static void RecordedOpponentHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetRecordedOpponentMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } RecordedOpponentBufferExecCompleted(); @@ -1239,16 +1240,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerFrontPicCoords[]; - static void RecordedOpponentHandleDrawTrainerPic(void) { s16 xPos; @@ -1791,7 +1782,7 @@ static void RecordedOpponentHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } RecordedOpponentBufferExecCompleted(); } diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 76ac40ef0..ca9fcda52 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -21,6 +21,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -132,7 +133,7 @@ static void RecordedPlayerDoMoveAnimation(void); static void sub_818CC24(u8 taskId); static void sub_818CDF4(void); -static void (*const sRecordedPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { RecordedPlayerHandleGetMonData, RecordedPlayerHandleGetRawMonData, @@ -455,7 +456,7 @@ static void sub_818A2B4(void) { if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy) { - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute) DoSpecialBattleAnimation(gActiveBank, gActiveBank, gActiveBank, B_ANIM_MON_TO_SUBSTITUTE); @@ -517,7 +518,7 @@ static void RecordedPlayerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -541,7 +542,7 @@ static void RecordedPlayerHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -550,12 +551,12 @@ static void RecordedPlayerHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyRecordedPlayerMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -875,7 +876,7 @@ static void RecordedPlayerHandleGetRawMonData(void) static void RecordedPlayerHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -884,12 +885,12 @@ static void RecordedPlayerHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetRecordedPlayerMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } RecordedPlayerBufferExecCompleted(); @@ -1220,17 +1221,6 @@ static void DoSwitchOutAnimation(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; -extern const struct MonCoords gTrainerFrontPicCoords[]; - static void RecordedPlayerHandleDrawTrainerPic(void) { s16 xPos, yPos; @@ -1811,7 +1801,7 @@ static void RecordedPlayerHandleSpriteInvisibility(void) if (IsBankSpritePresent(gActiveBank)) { gSprites[gBankSpriteIds[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - SetBattleSpriteInvisibilityBitToSpriteInvisibility(gActiveBank); + CopyBattleSpriteInvisibility(gActiveBank); } RecordedPlayerBufferExecCompleted(); } diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 292a631f4..61097b190 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -18,6 +18,7 @@ #include "bg.h" #include "reshow_battle_screen.h" #include "pokeball.h" +#include "data2.h" extern u32 gBattleExecBuffer; extern u8 gActiveBank; @@ -110,7 +111,7 @@ static void SafariBufferRunCommand(void); static void SafariBufferExecCompleted(void); static void CompleteWhenChosePokeblock(void); -static void (*const sSafariBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { SafariHandleGetMonData, SafariHandleGetRawMonData, @@ -323,7 +324,7 @@ static void SafariBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -372,16 +373,6 @@ static void SafariHandleReturnMonToBall(void) SafariBufferExecCompleted(); } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; - static void SafariHandleDrawTrainerPic(void) { DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, gActiveBank); diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 693008110..9ff6044c4 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -24,6 +24,7 @@ #include "reshow_battle_screen.h" #include "rng.h" #include "pokeball.h" +#include "data2.h" #include "party_menu.h" extern u32 gBattleExecBuffer; @@ -135,7 +136,7 @@ static void SetWallyMonData(u8 monId); static void WallyDoMoveAnimation(void); static void sub_816AC04(u8 taskId); -static void (*const sWallyBufferCommands[CONTOLLER_CMDS_COUNT])(void) = +static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(void) = { WallyHandleGetMonData, WallyHandleGetRawMonData, @@ -441,7 +442,7 @@ static void WallyBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; } else { @@ -459,7 +460,7 @@ static void WallyHandleGetMonData(void) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data u32 size = 0; - u8 monsToCheck; + u8 monToCheck; s32 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -468,12 +469,12 @@ static void WallyHandleGetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) size += CopyWallyMonData(i, monData + size); - monsToCheck >>= 1; + monToCheck >>= 1; } } EmitDataTransfer(1, size, monData); @@ -793,7 +794,7 @@ static void WallyHandleGetRawMonData(void) static void WallyHandleSetMonData(void) { - u8 monsToCheck; + u8 monToCheck; u8 i; if (gBattleBufferA[gActiveBank][2] == 0) @@ -802,12 +803,12 @@ static void WallyHandleSetMonData(void) } else { - monsToCheck = gBattleBufferA[gActiveBank][2]; + monToCheck = gBattleBufferA[gActiveBank][2]; for (i = 0; i < 6; i++) { - if (monsToCheck & 1) + if (monToCheck & 1) SetWallyMonData(i); - monsToCheck >>= 1; + monToCheck >>= 1; } } WallyBufferExecCompleted(); @@ -1062,16 +1063,6 @@ static void WallyHandleReturnMonToBall(void) } } -// todo: get rid of it once the struct is declared in a header -struct MonCoords -{ - // This would use a bitfield, but sub_8079F44 - // uses it as a u8 and casting won't match. - u8 coords; // u8 x:4, y:4; - u8 y_offset; -}; -extern const struct MonCoords gTrainerBackPicCoords[]; - static void WallyHandleDrawTrainerPic(void) { DecompressTrainerBackPic(BACK_PIC_WALLY, gActiveBank); diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 9d9eea24c..5c874438e 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -939,11 +939,11 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId) } } -void EmitGetMonData(u8 bufferId, u8 requestId, u8 monsToCheck) +void EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck) { gBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA; gBattleBuffersTransferData[1] = requestId; - gBattleBuffersTransferData[2] = monsToCheck; + gBattleBuffersTransferData[2] = monToCheck; gBattleBuffersTransferData[3] = 0; PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } @@ -957,13 +957,13 @@ void EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes) PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4); } -void EmitSetMonData(u8 bufferId, u8 requestId, u8 monsToCheck, u8 bytes, void *data) +void EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data) { s32 i; gBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA; gBattleBuffersTransferData[1] = requestId; - gBattleBuffersTransferData[2] = monsToCheck; + gBattleBuffersTransferData[2] = monToCheck; for (i = 0; i < bytes; i++) gBattleBuffersTransferData[3 + i] = *(u8*)(data++); PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 3 + bytes); diff --git a/src/battle_dome_cards.c b/src/battle_dome_cards.c index 030290a0d..5251ee06a 100644 --- a/src/battle_dome_cards.c +++ b/src/battle_dome_cards.c @@ -19,7 +19,7 @@ extern const union AffineAnimCmd *const gUnknown_082FF694[]; extern const union AnimCmd *const gUnknown_082FF70C[]; extern const union AnimCmd *const *const gMonAnimationsSpriteAnimsPtrTable[NUM_SPECIES]; extern const union AnimCmd *const *const gUnknown_0830536C[]; -extern const u8 gTrainerClassToFrontPicId[]; +extern const u8 gUnknown_0831F578[]; // Static type declarations @@ -421,9 +421,9 @@ u8 sub_818D97C(u8 a0, u8 a1) switch (a0) { default: - return gTrainerClassToFrontPicId[0x3F]; + return gUnknown_0831F578[0x3F]; case 0: - return gTrainerClassToFrontPicId[0x3C]; + return gUnknown_0831F578[0x3C]; } } return a0; diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 9b2394184..bb0e265b5 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -1222,14 +1222,14 @@ void CreateSecretBaseEnemyParty(struct SecretBaseRecord *secretBaseRecord) } } -extern const u8 gTrainerClassToFrontPicId[]; +extern const u8 gUnknown_0831F578[]; extern const u8 gTrainerClassToNameIndex[]; extern const u8 gSecretBaseTrainerClasses[][5]; u8 GetSecretBaseTrainerPicIndex(void) { u8 trainerClass = gSecretBaseTrainerClasses[gBattleResources->secretBase->gender][gBattleResources->secretBase->trainerId[0] % 5]; - return gTrainerClassToFrontPicId[trainerClass]; + return gUnknown_0831F578[trainerClass]; } u8 GetSecretBaseTrainerNameIndex(void) diff --git a/src/pokemon_3.c b/src/pokemon_3.c index f5043db01..73d23fe6f 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -1652,11 +1652,11 @@ u8 sub_806EF84(u8 arg0, u8 arg1) return i; } -extern const u8 gTrainerClassToFrontPicId[]; +extern const u8 gUnknown_0831F578[]; u16 sub_806EFF0(u16 arg0) { - return gTrainerClassToFrontPicId[arg0]; + return gUnknown_0831F578[arg0]; } u16 PlayerGenderToFrontTrainerPicId(u8 playerGender) -- cgit v1.2.3 From f724213a040f3c6a2f9685d52ae4e06d57aa0c41 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 31 Oct 2017 18:52:18 +0100 Subject: review change 3 battle controllers --- src/battle_controller_link_opponent.c | 2 +- src/battle_controller_link_partner.c | 2 +- src/battle_controller_opponent.c | 2 +- src/battle_controller_player.c | 2 +- src/battle_controller_player_partner.c | 2 +- src/battle_controller_recorded_opponent.c | 2 +- src/battle_controller_recorded_player.c | 2 +- src/battle_controller_safari.c | 2 +- src/battle_controller_wally.c | 2 +- 9 files changed, 9 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index a7e7ad022..968f6d49f 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -562,7 +562,7 @@ static void LinkOpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 33fa7abd5..4a70a4dc1 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -433,7 +433,7 @@ static void LinkPartnerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 4772cba50..7ffd9d64b 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -541,7 +541,7 @@ static void OpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index ffd0a6ce3..10d361cb9 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -255,7 +255,7 @@ static void PlayerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index df35e54c4..34fd8a3eb 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -620,7 +620,7 @@ static void PlayerPartnerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index feb8aef19..0dc7631ce 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -547,7 +547,7 @@ static void RecordedOpponentBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index ca9fcda52..a3343a391 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -518,7 +518,7 @@ static void RecordedPlayerBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 61097b190..0c5b698cf 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -324,7 +324,7 @@ static void SafariBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 9ff6044c4..c2addd30c 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -442,7 +442,7 @@ static void WallyBufferExecCompleted(void) u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = CONTROLLER_CMDS_COUNT - 1; + gBattleBufferA[gActiveBank][0] = CONTROLLER_TERMINATOR_NOP; } else { -- cgit v1.2.3