diff options
Diffstat (limited to 'src/battle_controller_player.c')
| -rw-r--r-- | src/battle_controller_player.c | 2969 |
1 files changed, 2969 insertions, 0 deletions
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c new file mode 100644 index 000000000..b0cd92c2e --- /dev/null +++ b/src/battle_controller_player.c @@ -0,0 +1,2969 @@ +#include "global.h" +#include "bg.h" +#include "data.h" +#include "item.h" +#include "item_menu.h" +#include "link.h" +#include "main.h" +#include "m4a.h" +#include "palette.h" +#include "party_menu.h" +#include "pokeball.h" +#include "pokemon.h" +#include "random.h" +#include "sound.h" +#include "strings.h" +#include "string_util.h" +#include "pokemon_special_anim.h" +#include "task.h" +#include "text.h" +#include "util.h" +#include "window.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_controllers.h" +#include "battle_interface.h" +#include "battle_message.h" +#include "battle_setup.h" +#include "battle_script_commands.h" +#include "reshow_battle_screen.h" +#include "constants/battle_anim.h" +#include "constants/items.h" +#include "constants/moves.h" +#include "constants/songs.h" + +static void PlayerHandleGetMonData(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 PlayerHandlePrintSelectionString(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 PlayerHandlePlaySE(void); +static void PlayerHandlePlayFanfare(void); +static void PlayerHandleFaintingCry(void); +static void PlayerHandleIntroSlide(void); +static void PlayerHandleIntroTrainerBallThrow(void); +static void PlayerHandleDrawPartyStatusSummary(void); +static void PlayerHandleHidePartyStatusSummary(void); +static void PlayerHandleEndBounceEffect(void); +static void PlayerHandleSpriteInvisibility(void); +static void PlayerHandleBattleAnimation(void); +static void PlayerHandleLinkStandbyMsg(void); +static void PlayerHandleResetActionMoveSelection(void); +static void PlayerHandleCmd55(void); +static void PlayerCmdEnd(void); + +static void PlayerBufferRunCommand(void); +static void HandleInputChooseTarget(void); +static void MoveSelectionDisplayPpNumber(void); +static void MoveSelectionDisplayPpString(void); +static void MoveSelectionDisplayMoveType(void); +static void MoveSelectionDisplayMoveNames(void); +static void HandleMoveSwitching(void); +static void WaitForMonSelection(void); +static void CompleteWhenChoseItem(void); +static void Task_LaunchLvlUpAnim(u8 taskId); +static void Task_PrepareToGiveExpWithExpBar(u8 taskId); +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); +static void Task_UpdateLvlInHealthbox(u8 taskId); +static void PrintLinkStandbyMsg(void); +static u32 CopyPlayerMonData(u8 monId, u8 *dst); +static void SetPlayerMonData(u8 monId); +static void DoSwitchOutAnimation(void); +static void PlayerDoMoveAnimation(void); +static void task05_08033660(u8 taskId); +static void sub_8033AC8(void); +static void sub_802FCAC(void); +static void sub_80300F4(u8 taskId); +static void sub_80303A8(u8 taskId); +static void sub_8031FF4(u8 battlerId, bool8 dontClearSubstituteBit); +static void sub_8033830(void); + +static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +{ + PlayerHandleGetMonData, + PlayerHandleGetRawMonData, + PlayerHandleSetMonData, + PlayerHandleSetRawMonData, + PlayerHandleLoadMonSprite, + PlayerHandleSwitchInAnim, + PlayerHandleReturnMonToBall, + PlayerHandleDrawTrainerPic, + PlayerHandleTrainerSlide, + PlayerHandleTrainerSlideBack, + PlayerHandleFaintAnimation, + PlayerHandlePaletteFade, + PlayerHandleSuccessBallThrowAnim, + PlayerHandleBallThrowAnim, + PlayerHandlePause, + PlayerHandleMoveAnimation, + PlayerHandlePrintString, + PlayerHandlePrintSelectionString, + PlayerHandleChooseAction, + PlayerHandleUnknownYesNoBox, + PlayerHandleChooseMove, + PlayerHandleChooseItem, + PlayerHandleChoosePokemon, + PlayerHandleCmd23, + PlayerHandleHealthBarUpdate, + PlayerHandleExpUpdate, + PlayerHandleStatusIconUpdate, + PlayerHandleStatusAnimation, + PlayerHandleStatusXor, + PlayerHandleDataTransfer, + PlayerHandleDMA3Transfer, + PlayerHandlePlayBGM, + PlayerHandleCmd32, + PlayerHandleTwoReturnValues, + PlayerHandleChosenMonReturnValue, + PlayerHandleOneReturnValue, + PlayerHandleOneReturnValue_Duplicate, + PlayerHandleCmd37, + PlayerHandleCmd38, + PlayerHandleCmd39, + PlayerHandleCmd40, + PlayerHandleHitAnimation, + PlayerHandleCmd42, + PlayerHandlePlaySE, + PlayerHandlePlayFanfare, + PlayerHandleFaintingCry, + PlayerHandleIntroSlide, + PlayerHandleIntroTrainerBallThrow, + PlayerHandleDrawPartyStatusSummary, + PlayerHandleHidePartyStatusSummary, + PlayerHandleEndBounceEffect, + PlayerHandleSpriteInvisibility, + PlayerHandleBattleAnimation, + PlayerHandleLinkStandbyMsg, + PlayerHandleResetActionMoveSelection, + PlayerHandleCmd55, + PlayerCmdEnd, +}; + +static const u8 sTargetIdentities[] = { B_POSITION_PLAYER_LEFT, B_POSITION_PLAYER_RIGHT, B_POSITION_OPPONENT_RIGHT, B_POSITION_OPPONENT_LEFT }; + +// not used +static const u8 gUnknown_8250984[] = { 0x48, 0x48, 0x20, 0x5a, 0x50, 0x50, 0x50, 0x58 }; + +void nullsub_13(void) +{ +} + +void SetControllerToPlayer(void) +{ + gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand; + gDoingBattleAnim = FALSE; +} + +static void PlayerBufferExecCompleted(void) +{ + gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleBufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + } + else + { + gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + } +} + +static void PlayerBufferRunCommand(void) +{ + if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + { + if (gBattleBufferA[gActiveBattler][0] < NELEMS(sPlayerBufferCommands)) + sPlayerBufferCommands[gBattleBufferA[gActiveBattler][0]](); + else + PlayerBufferExecCompleted(); + } +} + +static void CompleteOnBattlerSpritePosX_0(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].pos2.x == 0) + PlayerBufferExecCompleted(); +} + +static void HandleInputChooseAction(void) +{ + u16 itemId = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8); + + DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + if (JOY_NEW(A_BUTTON)) + { + PlaySE(SE_SELECT); + + switch (gActionSelectionCursor[gActiveBattler]) + { + case 0: + BtlController_EmitTwoReturnValues(1, B_ACTION_USE_MOVE, 0); + break; + case 1: + BtlController_EmitTwoReturnValues(1, B_ACTION_USE_ITEM, 0); + break; + case 2: + BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0); + break; + case 3: + BtlController_EmitTwoReturnValues(1, B_ACTION_RUN, 0); + break; + } + PlayerBufferExecCompleted(); + } + else if (JOY_NEW(DPAD_LEFT)) + { + if (gActionSelectionCursor[gActiveBattler] & 1) // if is B_ACTION_USE_ITEM or B_ACTION_RUN + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); + gActionSelectionCursor[gActiveBattler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + } + } + else if (JOY_NEW(DPAD_RIGHT)) + { + if (!(gActionSelectionCursor[gActiveBattler] & 1)) // if is B_ACTION_USE_MOVE or B_ACTION_SWITCH + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); + gActionSelectionCursor[gActiveBattler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + } + } + else if (JOY_NEW(DPAD_UP)) + { + if (gActionSelectionCursor[gActiveBattler] & 2) // if is B_ACTION_SWITCH or B_ACTION_RUN + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); + gActionSelectionCursor[gActiveBattler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + } + } + else if (JOY_NEW(DPAD_DOWN)) + { + if (!(gActionSelectionCursor[gActiveBattler] & 2)) // if is B_ACTION_USE_MOVE or B_ACTION_USE_ITEM + { + PlaySE(SE_SELECT); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); + gActionSelectionCursor[gActiveBattler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + } + } + else if (JOY_NEW(B_BUTTON)) + { + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_RIGHT + && !(gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]) + && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if (gBattleBufferA[gActiveBattler][1] == B_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); + BtlController_EmitTwoReturnValues(1, B_ACTION_CANCEL_PARTNER, 0); + PlayerBufferExecCompleted(); + } + } + else if (JOY_NEW(START_BUTTON)) + { + SwapHpBarsWithHpText(); + } +} + +static void sub_802E640(void) +{ + EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX); + EndBounceEffect(gActiveBattler, BOUNCE_MON); + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseTarget; +} + +static void HandleInputChooseTarget(void) +{ + s32 i; + u8 identities[4]; + + memcpy(identities, sTargetIdentities, NELEMS(sTargetIdentities)); + DoBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX, 15, 1); + i = 0; + if (gBattlersCount != 0) + { + do + { + if (i != gMultiUsePlayerCursor) + EndBounceEffect(i, BOUNCE_HEALTHBOX); + ++i; + } + while (i < gBattlersCount); + } + if (JOY_NEW(A_BUTTON)) + { + PlaySE(SE_SELECT); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012098; + BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX); + PlayerBufferExecCompleted(); + } + else if (JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012098; + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; + DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX); + } + else if (JOY_NEW(DPAD_LEFT | DPAD_UP)) + { + PlaySE(SE_SELECT); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012098; + + do + { + u8 currSelIdentity = GetBattlerPosition(gMultiUsePlayerCursor); + + for (i = 0; i < MAX_BATTLERS_COUNT; ++i) + if (currSelIdentity == identities[i]) + break; + do + { + if (--i < 0) + i = MAX_BATTLERS_COUNT; // UB: array out of range + gMultiUsePlayerCursor = GetBattlerAtPosition(identities[i]); + } + while (gMultiUsePlayerCursor == gBattlersCount); + i = 0; + switch (GetBattlerPosition(gMultiUsePlayerCursor)) + { + case B_POSITION_PLAYER_LEFT: + case B_POSITION_PLAYER_RIGHT: + if (gActiveBattler != gMultiUsePlayerCursor) + ++i; + else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBattler])].target & MOVE_TARGET_USER_OR_SELECTED) + ++i; + break; + case B_POSITION_OPPONENT_LEFT: + case B_POSITION_OPPONENT_RIGHT: + ++i; + break; + } + if (gAbsentBattlerFlags & gBitTable[gMultiUsePlayerCursor]) + i = 0; + } + while (i == 0); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012044; + } + else if (JOY_NEW(DPAD_RIGHT | DPAD_DOWN)) + { + PlaySE(SE_SELECT); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012098; + + do + { + u8 currSelIdentity = GetBattlerPosition(gMultiUsePlayerCursor); + + for (i = 0; i < MAX_BATTLERS_COUNT; ++i) + if (currSelIdentity == identities[i]) + break; + do + { + if (++i > 3) + i = 0; + gMultiUsePlayerCursor = GetBattlerAtPosition(identities[i]); + } + while (gMultiUsePlayerCursor == gBattlersCount); + i = 0; + switch (GetBattlerPosition(gMultiUsePlayerCursor)) + { + case B_POSITION_PLAYER_LEFT: + case B_POSITION_PLAYER_RIGHT: + if (gActiveBattler != gMultiUsePlayerCursor) + ++i; + else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBattler])].target & MOVE_TARGET_USER_OR_SELECTED) + ++i; + break; + case B_POSITION_OPPONENT_LEFT: + case B_POSITION_OPPONENT_RIGHT: + ++i; + break; + } + if (gAbsentBattlerFlags & gBitTable[gMultiUsePlayerCursor]) + i = 0; + } + while (i == 0); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012044; + } +} + +void HandleInputChooseMove(void) +{ + bool32 canSelectTarget = FALSE; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + + sub_8033AC8(); + if (JOY_NEW(A_BUTTON)) + { + u8 moveTarget; + + PlaySE(SE_SELECT); + if (moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] == MOVE_CURSE) + { + if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST) + moveTarget = MOVE_TARGET_USER; + else + moveTarget = MOVE_TARGET_SELECTED; + } + else + { + moveTarget = gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].target; + } + + if (moveTarget & MOVE_TARGET_USER) + gMultiUsePlayerCursor = gActiveBattler; + else + gMultiUsePlayerCursor = GetBattlerAtPosition((GetBattlerPosition(gActiveBattler) & BIT_SIDE) ^ BIT_SIDE); + + if (!gBattleBufferA[gActiveBattler][1]) // not a double battle + { + if (moveTarget & MOVE_TARGET_USER_OR_SELECTED && !gBattleBufferA[gActiveBattler][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_USER))) + ++canSelectTarget; // either selected or user + if (moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] == 0) + { + canSelectTarget = FALSE; + } + else if (!(moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) <= 1) + { + gMultiUsePlayerCursor = GetDefaultMoveTarget(gActiveBattler); + canSelectTarget = FALSE; + } + } + ResetPaletteFadeControl(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + if (!canSelectTarget) + { + BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + PlayerBufferExecCompleted(); + } + else + { + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseTarget; + if (moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) + gMultiUsePlayerCursor = gActiveBattler; + else if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)]) + gMultiUsePlayerCursor = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + else + gMultiUsePlayerCursor = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = sub_8012044; + } + } + else if (JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + BtlController_EmitTwoReturnValues(1, 10, 0xFFFF); + PlayerBufferExecCompleted(); + ResetPaletteFadeControl(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + } + else if (JOY_NEW(DPAD_LEFT)) + { + if (gMoveSelectionCursor[gActiveBattler] & 1) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + } + } + else if (JOY_NEW(DPAD_RIGHT)) + { + if (!(gMoveSelectionCursor[gActiveBattler] & 1) + && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + } + } + else if (JOY_NEW(DPAD_UP)) + { + if (gMoveSelectionCursor[gActiveBattler] & 2) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + } + } + else if (JOY_NEW(DPAD_DOWN)) + { + if (!(gMoveSelectionCursor[gActiveBattler] & 2) + && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE); + } + } + else if (JOY_NEW(SELECT_BUTTON)) + { + if (gNumberOfMovesToChoose > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) + { + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + if (gMoveSelectionCursor[gActiveBattler] != 0) + gMultiUsePlayerCursor = 0; + else + gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBattler] + 1; + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + BattlePutTextOnWindow(gText_BattleSwitchWhich, 0xB); + gBattlerControllerFuncs[gActiveBattler] = HandleMoveSwitching; + } + } +} + +// not used +static u32 sub_802EDDC(void) +{ + u32 var = 0; + + if (JOY_NEW(A_BUTTON)) + { + PlaySE(SE_SELECT); + var = 1; + } + if (JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0x140; + var = 0xFF; + } + if (JOY_NEW(DPAD_LEFT) && gMoveSelectionCursor[gActiveBattler] & 1) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + } + if (JOY_NEW(DPAD_RIGHT) && !(gMoveSelectionCursor[gActiveBattler] & 1) + && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 1; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + } + if (JOY_NEW(DPAD_UP) && gMoveSelectionCursor[gActiveBattler] & 2) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + } + if (JOY_NEW(DPAD_DOWN) && !(gMoveSelectionCursor[gActiveBattler] & 2) + && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose) + { + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); + gMoveSelectionCursor[gActiveBattler] ^= 2; + PlaySE(SE_SELECT); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + } + return var; +} + +static void HandleMoveSwitching(void) +{ + u8 perMovePPBonuses[4]; + struct ChooseMoveStruct moveStruct; + u8 totalPPBonuses; + + if (JOY_NEW(A_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + + if (gMoveSelectionCursor[gActiveBattler] != gMultiUsePlayerCursor) + { + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + s32 i; + + // swap moves and pp + i = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]; + moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] = moveInfo->moves[gMultiUsePlayerCursor]; + moveInfo->moves[gMultiUsePlayerCursor] = i; + i = moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]]; + moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->currentPp[gMultiUsePlayerCursor]; + moveInfo->currentPp[gMultiUsePlayerCursor] = i; + i = moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]]; + moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->maxPp[gMultiUsePlayerCursor]; + moveInfo->maxPp[gMultiUsePlayerCursor] = i; + if (gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[gMoveSelectionCursor[gActiveBattler]]) + { + gDisableStructs[gActiveBattler].mimickedMoves &= (~gBitTable[gMoveSelectionCursor[gActiveBattler]]); + gDisableStructs[gActiveBattler].mimickedMoves |= gBitTable[gMultiUsePlayerCursor]; + } + MoveSelectionDisplayMoveNames(); + for (i = 0; i < MAX_MON_MOVES; ++i) + perMovePPBonuses[i] = (gBattleMons[gActiveBattler].ppBonuses & (3 << (i * 2))) >> (i * 2); + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor]; + perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; + totalPPBonuses = 0; + for (i = 0; i < MAX_MON_MOVES; ++i) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + gBattleMons[gActiveBattler].ppBonuses = totalPPBonuses; + for (i = 0; i < MAX_MON_MOVES; ++i) + { + gBattleMons[gActiveBattler].moves[i] = moveInfo->moves[i]; + gBattleMons[gActiveBattler].pp[i] = moveInfo->currentPp[i]; + } + if (!(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED)) + { + for (i = 0; i < MAX_MON_MOVES; ++i) + { + moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + i); + moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP1 + i); + } + + totalPPBonuses = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES); + for (i = 0; i < MAX_MON_MOVES; ++i) + perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); + i = moveStruct.moves[gMoveSelectionCursor[gActiveBattler]]; + moveStruct.moves[gMoveSelectionCursor[gActiveBattler]] = moveStruct.moves[gMultiUsePlayerCursor]; + moveStruct.moves[gMultiUsePlayerCursor] = i; + i = moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]]; + moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]] = moveStruct.currentPp[gMultiUsePlayerCursor]; + moveStruct.currentPp[gMultiUsePlayerCursor] = i; + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor]; + perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; + totalPPBonuses = 0; + for (i = 0; i < MAX_MON_MOVES; ++i) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + for (i = 0; i < MAX_MON_MOVES; ++i) + { + SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]); + SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]); + } + SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES, &totalPPBonuses); + } + } + if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE) + gBattlerControllerFuncs[gActiveBattler] = sub_80E7988; + else + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; + gMoveSelectionCursor[gActiveBattler] = gMultiUsePlayerCursor; + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + if (JOY_NEW(B_BUTTON)) + { + PlaySE(SE_SELECT); + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE) + gBattlerControllerFuncs[gActiveBattler] = sub_80E7988; + else + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); + } + if (JOY_NEW(DPAD_LEFT)) + { + if (gMultiUsePlayerCursor & 1) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor ^= 1; + PlaySE(SE_SELECT); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + if (JOY_NEW(DPAD_RIGHT)) + { + if (!(gMultiUsePlayerCursor & 1) && (gMultiUsePlayerCursor ^ 1) < gNumberOfMovesToChoose) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor ^= 1; + PlaySE(SE_SELECT); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + if (JOY_NEW(DPAD_UP)) + { + if (gMultiUsePlayerCursor & 2) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor ^= 2; + PlaySE(SE_SELECT); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } + if (JOY_NEW(DPAD_DOWN)) + { + if (!(gMultiUsePlayerCursor & 2) && (gMultiUsePlayerCursor ^ 2) < gNumberOfMovesToChoose) + { + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + else + MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); + gMultiUsePlayerCursor ^= 2; + PlaySE(SE_SELECT); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); + else + MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); + } + } +} + +static void sub_802F610(void) +{ + if (gWirelessCommType == 0) + { + if (gReceivedRemoteLinkPlayers == 0) + { + m4aSongNumStop(SE_T_OOAME); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(sub_8011A1C); + FreeAllWindowBuffers(); + } + } + else if (IsLinkTaskFinished()) + { + m4aSongNumStop(SE_T_OOAME); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(sub_8011A1C); + FreeAllWindowBuffers(); + } +} + +void sub_802F6A8(void) +{ + if (!gPaletteFade.active) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gWirelessCommType == 0) + sub_800AAC0(); + else + sub_800AB9C(); + gBattlerControllerFuncs[gActiveBattler] = sub_802F610; + } + else + { + m4aSongNumStop(SE_T_OOAME); + gMain.inBattle = 0; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + } +} + +static void CompleteOnBattlerSpriteCallbackDummy(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +static void CompleteOnBattlerSpriteCallbackDummy2(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +static void sub_802F7A0(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + { + nullsub_16(gSaveBlock2Ptr->playerGender); + FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + PlayerBufferExecCompleted(); + } +} + +static void sub_802F810(void) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_9 == 0xFF) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_9 = 0; + PlayerBufferExecCompleted(); + } +} + +static void sub_802F858(void) +{ + bool8 var = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + var = TRUE; + } + else + { + if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK]].callback == SpriteCallbackDummy) + var = TRUE; + } + if (IsCryPlayingOrClearCrySongs()) + var = FALSE; + if (var && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_1_x1 + && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_1_x1 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + m4aMPlayContinue(&gMPlayInfo_BGM); + else + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 256); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + if (IsDoubleBattle()) + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]], gActiveBattler ^ BIT_FLANK); + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_9 = 3; + gBattlerControllerFuncs[gActiveBattler] = sub_802F810; + } +} + +static void sub_802FA58(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].ballAnimActive) + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].flag_x80) + sub_80F1720(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].flag_x80) + sub_80F1720(gActiveBattler ^ BIT_FLANK, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]]); + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_3004FFC[gActiveBattler ^ BIT_FLANK]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK], + &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]], + HEALTHBOX_ALL); + sub_804BD94(gActiveBattler ^ BIT_FLANK); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK]); + } + DestroySprite(&gSprites[gUnknown_3004FFC[gActiveBattler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], + &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], + HEALTHBOX_ALL); + sub_804BD94(gActiveBattler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + gBattleSpritesDataPtr->animationData->field_9_x1 = 0; + gBattlerControllerFuncs[gActiveBattler] = sub_802F858; + } +} + +static void sub_802FBF4(void) +{ + if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy + && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_1_x1) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].flag_x80 = 0; + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_1_x1 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + gBattlerControllerFuncs[gActiveBattler] = sub_802FCAC; + } +} + +static void sub_802FCAC(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive + && !IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x100); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + PlayerBufferExecCompleted(); + } +} + +static void sub_802FD18(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].flag_x80 + && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + sub_80F1720(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (gSprites[gUnknown_3004FFC[gActiveBattler]].callback == SpriteCallbackDummy + && !(gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)) + { + DestroySprite(&gSprites[gUnknown_3004FFC[gActiveBattler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], + &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], + HEALTHBOX_ALL); + sub_804BD94(gActiveBattler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + CopyBattleSpriteInvisibility(gActiveBattler); + gBattlerControllerFuncs[gActiveBattler] = sub_802FBF4; + } +} + +void c3_0802FDF4(u8 taskId) +{ + if (!IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x100); + DestroyTask(taskId); + } +} + +static void CompleteOnHealthbarDone(void) +{ + s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0); + + SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + + if (hpValue != -1) + { + UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], hpValue, HP_CURRENT); + } + else + { + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + PlayerBufferExecCompleted(); + } +} + +void CompleteOnInactiveTextPrinter(void) +{ + if (!IsTextPrinterActive(0)) + PlayerBufferExecCompleted(); +} + +#define tExpTask_monId data[0] +#define tExpTask_gainedExp data[1] +#define tExpTask_battler data[2] +#define tExpTask_frames data[10] +// TODO: document other used fields + +static void Task_GiveExpToMon(u8 taskId) +{ + u32 monId = (u8)(gTasks[taskId].tExpTask_monId); + u8 battlerId = gTasks[taskId].tExpTask_battler; + s16 gainedExp = gTasks[taskId].tExpTask_gainedExp; + + if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battlerId]) // Give exp without moving 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 savedActiveBattler; + + SetMonData(mon, MON_DATA_EXP, &nextLvlExp); + CalculateMonStats(mon); + gainedExp -= nextLvlExp - currExp; + savedActiveBattler = gActiveBattler; + gActiveBattler = battlerId; + BtlController_EmitTwoReturnValues(1, RET_VALUE_LEVELED_UP, gainedExp); + gActiveBattler = savedActiveBattler; + if (IsDoubleBattle() == TRUE + && ((u16)(monId) == gBattlerPartyIndexes[battlerId] || (u16)(monId) == gBattlerPartyIndexes[battlerId ^ BIT_FLANK])) + gTasks[taskId].func = Task_LaunchLvlUpAnim; + else + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } + else + { + currExp += gainedExp; + SetMonData(mon, MON_DATA_EXP, &currExp); + gBattlerControllerFuncs[battlerId] = 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 battlerId = gTasks[taskId].tExpTask_battler; + 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(battlerId, gHealthboxSpriteIds[battlerId], expToNextLvl, exp, -gainedExp); + PlaySE(SE_U); + gTasks[taskId].func = sub_80300F4; +} + +static void sub_80300F4(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 battlerId = gTasks[taskId].tExpTask_battler; + s16 newExpPoints; + + newExpPoints = MoveBattleBar(battlerId, gHealthboxSpriteIds[battlerId], EXP_BAR, 0); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battlerId]); + if (newExpPoints == -1) // The bar has been filled with given exp points. + { + u8 level; + s32 currExp; + u16 species; + s32 expOnNextLvl; + + m4aSongNumStop(SE_U); + 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 savedActiveBattler; + + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &expOnNextLvl); + CalculateMonStats(&gPlayerParty[monId]); + gainedExp -= expOnNextLvl - currExp; + savedActiveBattler = gActiveBattler; + gActiveBattler = battlerId; + BtlController_EmitTwoReturnValues(1, RET_VALUE_LEVELED_UP, gainedExp); + gActiveBattler = savedActiveBattler; + gTasks[taskId].func = Task_LaunchLvlUpAnim; + } + else + { + currExp += gainedExp; + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp); + gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } + } + } +} + +static void Task_LaunchLvlUpAnim(u8 taskId) +{ + u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 monIndex = gTasks[taskId].tExpTask_monId; + + if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[battlerId ^ BIT_FLANK]) + battlerId ^= BIT_FLANK; + InitAndLaunchSpecialAnimation(battlerId, battlerId, battlerId, B_ANIM_LVL_UP); + gTasks[taskId].func = Task_UpdateLvlInHealthbox; +} + +static void Task_UpdateLvlInHealthbox(u8 taskId) +{ + u8 battlerId = gTasks[taskId].tExpTask_battler; + + if (!gBattleSpritesDataPtr->healthBoxesData[battlerId].specialAnimActive) + { + u8 monIndex = gTasks[taskId].tExpTask_monId; + + GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL); // Unused return value. + if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[battlerId ^ BIT_FLANK]) + UpdateHealthboxAttribute(gHealthboxSpriteIds[battlerId ^ BIT_FLANK], &gPlayerParty[monIndex], HEALTHBOX_ALL); + else + UpdateHealthboxAttribute(gHealthboxSpriteIds[battlerId], &gPlayerParty[monIndex], HEALTHBOX_ALL); + gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter; + } +} + +static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId) +{ + u8 monIndex; + s32 battlerId = gTasks[taskId].tExpTask_battler; + + if (IsBattlerSpriteVisible((u8)battlerId) == TRUE) + { + gTasks[taskId].func = sub_80303A8; + gTasks[taskId].data[15] = 0; + } + else + { + gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + } +} + +static void sub_80303A8(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + u8 battlerId = tExpTask_battler; + u16 v5 = sub_80768B0(battlerId); + bool32 v6 = ((v5 ^ BIT_SIDE)) != B_SIDE_PLAYER; + struct Sprite *sprite = &gSprites[gBattlerSpriteIds[battlerId]]; + + switch (data[15]) + { + case 0: + if (!IsTextPrinterActive(0)) + { + if (!v6) + { + data[14] = gBattle_BG1_X; + data[13] = gBattle_BG1_Y; + gBattle_BG1_X = -(sprite->pos1.x + sprite->pos2.x) + 32; + gBattle_BG1_Y = -(sprite->pos1.y + sprite->pos2.y) + 32; + } + else + { + data[14] = gBattle_BG2_X; + data[13] = gBattle_BG2_Y; + gBattle_BG2_X = -(sprite->pos1.x + sprite->pos2.x) + 32; + gBattle_BG2_Y = -(sprite->pos1.y + sprite->pos2.y) + 32; + } + ++data[15]; + } + break; + case 1: + { + u32 battlerIdAlt = battlerId; + bool32 v6Alt = v6; + + sub_8072E48(battlerIdAlt, v6Alt); + } + ++data[15]; + break; + case 2: + PlaySE(SE_T_KAMI2); + if (IsMonGettingExpSentOut()) + sub_811E5B8(sprite->pos1.x + sprite->pos2.x, + sprite->pos1.y + sprite->pos2.y, + 10000, + 10000, + 1, + 0); + ++data[15]; + break; + case 3: + if (!sub_811E680()) + { + sprite->invisible = FALSE; + ++data[15]; + } + break; + case 5: + sub_8073128(v6); + ++data[15]; + break; + case 4: + ++data[15]; + break; + case 6: + if (!v6) + { + gBattle_BG1_X = data[14]; + gBattle_BG1_Y = data[13]; + } + else + { + gBattle_BG2_X = data[14]; + gBattle_BG2_Y = data[13]; + } + gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter; + DestroyTask(taskId); + break; + } +} + +static void sub_8030538(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].pos1.y + gSprites[gBattlerSpriteIds[gActiveBattler]].pos2.y > DISPLAY_HEIGHT) + { + FreeOamMatrix(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.matrixNum); + DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); + PlayerBufferExecCompleted(); + } +} + +static void sub_80305A0(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + { + FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); + PlayerBufferExecCompleted(); + } +} + +static void CompleteOnInactiveTextPrinter2(void) +{ + if (!IsTextPrinterActive(0)) + PlayerBufferExecCompleted(); +} + +static void OpenPartyMenuToChooseMon(void) +{ + if (!gPaletteFade.active) + { + u8 caseId; + + gBattlerControllerFuncs[gActiveBattler] = WaitForMonSelection; + caseId = gTasks[gUnknown_3004FFC[gActiveBattler]].data[0]; + DestroyTask(gUnknown_3004FFC[gActiveBattler]); + FreeAllWindowBuffers(); + OpenPartyMenuInBattle(caseId); + } +} + +static void WaitForMonSelection(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + if (gUnknown_203B0C0 == 1) + BtlController_EmitChosenMonReturnValue(1, gUnknown_203B0C1, gUnknown_203B0DC); + else + BtlController_EmitChosenMonReturnValue(1, 6, NULL); + + if ((gBattleBufferA[gActiveBattler][1] & 0xF) == 1) + PrintLinkStandbyMsg(); + PlayerBufferExecCompleted(); + } +} + +static void OpenBagAndChooseItem(void) +{ + if (!gPaletteFade.active) + { + gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChoseItem; + nullsub_44(); + FreeAllWindowBuffers(); + sub_8107ECC(); + } +} + +static void CompleteWhenChoseItem(void) +{ + if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) + { + BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId); + PlayerBufferExecCompleted(); + } +} + +static void CompleteOnSpecialAnimDone(void) +{ + if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + PlayerBufferExecCompleted(); +} + +static void DoHitAnimBlinkSpriteEffect(void) +{ + u8 spriteId = gBattlerSpriteIds[gActiveBattler]; + + if (gSprites[spriteId].data[1] == 32) + { + gSprites[spriteId].data[1] = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = FALSE; + PlayerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data[1] % 4) == 0) + gSprites[spriteId].invisible ^= 1; + ++gSprites[spriteId].data[1]; + } +} + +static void MoveSelectionDisplayMoveNames(void) +{ + s32 i; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + gNumberOfMovesToChoose = 0; + + for (i = 0; i < MAX_MON_MOVES; ++i) + { + MoveSelectionDestroyCursorAt(i); + StringCopy(gDisplayedStringBattle, gUnknown_83FE770); + StringAppend(gDisplayedStringBattle, gMoveNames[moveInfo->moves[i]]); + BattlePutTextOnWindow(gDisplayedStringBattle, i + 3); + if (moveInfo->moves[i] != MOVE_NONE) + ++gNumberOfMovesToChoose; + } +} + +static void MoveSelectionDisplayPpString(void) +{ + StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); + BattlePutTextOnWindow(gDisplayedStringBattle, 7); +} + +static void MoveSelectionDisplayPpNumber(void) +{ + u8 *txtPtr; + struct ChooseMoveStruct *moveInfo; + + if (gBattleBufferA[gActiveBattler][2] == TRUE) // check if we didn't want to display pp number + return; + SetPpNumbersPaletteInMoveSelection(); + moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2); + *txtPtr = CHAR_SLASH; + ConvertIntToDecimalStringN(++txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2); + BattlePutTextOnWindow(gDisplayedStringBattle, 9); +} + +static void MoveSelectionDisplayMoveType(void) +{ + u8 *txtPtr; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + + txtPtr = StringCopy(gDisplayedStringBattle, gText_MoveInterfaceType); + *txtPtr++ = EXT_CTRL_CODE_BEGIN; + *txtPtr++ = 6; + *txtPtr++ = 1; + txtPtr = StringCopy(txtPtr, gUnknown_83FE770); + StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].type]); + BattlePutTextOnWindow(gDisplayedStringBattle, 8); +} + +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] = 32; + src[1] = 32; + 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] = 32; + src[1] = 32; + 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); +} + +static void CompleteOnFinishedStatusAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive) + PlayerBufferExecCompleted(); +} + +static void CompleteOnFinishedBattleAnimation(void) +{ + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive) + PlayerBufferExecCompleted(); +} + +static void PrintLinkStandbyMsg(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + BattlePutTextOnWindow(gText_LinkStandby, 0); + } +} + +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 monToCheck; + s32 i; + + if (gBattleBufferA[gActiveBattler][2] == 0) + { + size += CopyPlayerMonData(gBattlerPartyIndexes[gActiveBattler], monData); + } + else + { + monToCheck = gBattleBufferA[gActiveBattler][2]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (monToCheck & 1) + size += CopyPlayerMonData(i, monData + size); + monToCheck >>= 1; + } + } + BtlController_EmitDataTransfer(1, size, monData); + PlayerBufferExecCompleted(); +} + +static 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[gActiveBattler][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 < MAX_MON_MOVES; ++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.abilityNum = GetMonData(&gPlayerParty[monId], MON_DATA_ABILITY_NUM); + 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 < MAX_MON_MOVES; ++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[gActiveBattler][1] - REQUEST_MOVE1_BATTLE); + dst[0] = data16; + dst[1] = data16 >> 8; + size = 2; + break; + case REQUEST_PP_DATA_BATTLE: + for (size = 0; size < MAX_MON_MOVES; ++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[gActiveBattler][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; +} + +void PlayerHandleGetRawMonData(void) +{ + struct BattlePokemon battleMon; + u8 *src = (u8 *)&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1]; + u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBattler][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i) + dst[i] = src[i]; + + BtlController_EmitDataTransfer(1, gBattleBufferA[gActiveBattler][2], dst); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleSetMonData(void) +{ + u8 monToCheck; + u8 i; + + if (gBattleBufferA[gActiveBattler][2] == 0) + { + SetPlayerMonData(gBattlerPartyIndexes[gActiveBattler]); + } + else + { + monToCheck = gBattleBufferA[gActiveBattler][2]; + for (i = 0; i < PARTY_SIZE; ++i) + { + if (monToCheck & 1) + SetPlayerMonData(i); + monToCheck >>= 1; + } + } + PlayerBufferExecCompleted(); +} + +static void SetPlayerMonData(u8 monId) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBattler][3]; + struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBattler][3]; + s32 i; + + switch (gBattleBufferA[gActiveBattler][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 < MAX_MON_MOVES; ++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[gActiveBattler][3]); + break; + case REQUEST_HELDITEM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_MOVES_PP_BATTLE: + for (i = 0; i < MAX_MON_MOVES; ++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[gActiveBattler][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_PP_DATA_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBattler][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBattler][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBattler][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBattler][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBattler][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[gActiveBattler][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_OTID_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_EXP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_HP_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_ATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_DEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPEED_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPATK_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPDEF_EV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_FRIENDSHIP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_POKERUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_MET_LOCATION_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_MET_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_MET_GAME_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_POKEBALL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_ALL_IVS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]); + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][4]); + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][5]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][6]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][7]); + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][8]); + break; + case REQUEST_HP_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_ATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_DEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPEED_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPATK_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPDEF_IV_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_PERSONALITY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_CHECKSUM_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_STATUS_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_LEVEL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_MAX_HP_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_ATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_DEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPEED_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPATK_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SPDEF_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_COOL_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_BEAUTY_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_CUTE_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SMART_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_TOUGH_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SHEEN_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_COOL_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_BEAUTY_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_CUTE_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_SMART_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBattler][3]); + break; + case REQUEST_TOUGH_RIBBON_BATTLE: + SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBattler][3]); + break; + } + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); +} + +static void PlayerHandleSetRawMonData(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i) + dst[i] = gBattleBufferA[gActiveBattler][3 + i]; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleLoadMonSprite(void) +{ + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler; + gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpritePosX_0; +} + +static void PlayerHandleSwitchInAnim(void) +{ + ClearTemporarySpeciesSpriteData(gActiveBattler, gBattleBufferA[gActiveBattler][2]); + gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + gActionSelectionCursor[gActiveBattler] = 0; + gMoveSelectionCursor[gActiveBattler] = 0; + sub_8031FF4(gActiveBattler, gBattleBufferA[gActiveBattler][2]); + gBattlerControllerFuncs[gActiveBattler] = sub_802FD18; +} + +static void sub_8031FF4(u8 battlerId, bool8 dontClearSubstituteBit) +{ + u16 species; + + ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit); + gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1]; + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + gUnknown_3004FFC[battlerId] = CreateInvisibleSpriteWithCallback(sub_8033E3C); + SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId)); + gBattlerSpriteIds[battlerId] = CreateSprite(&gMultiuseSpriteTemplate, + GetBattlerSpriteCoord(battlerId, 2), + GetBattlerSpriteDefault_Y(battlerId), + GetBattlerSpriteSubpriority(battlerId)); + gSprites[gUnknown_3004FFC[battlerId]].data[1] = gBattlerSpriteIds[battlerId]; + gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId; + gSprites[gBattlerSpriteIds[battlerId]].data[2] = species; + gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId; + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]); + gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE; + gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy; + gSprites[gUnknown_3004FFC[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT); +} + +static void PlayerHandleReturnMonToBall(void) +{ + if (gBattleBufferA[gActiveBattler][1] == 0) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; + gBattlerControllerFuncs[gActiveBattler] = DoSwitchOutAnimation; + } + else + { + FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); + PlayerBufferExecCompleted(); + } +} + +static void DoSwitchOutAnimation(void) +{ + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState) + { + case 0: + if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SWITCH_OUT_PLAYER_MON); + gBattlerControllerFuncs[gActiveBattler] = sub_80305A0; + } + break; + } +} + +static void PlayerHandleDrawTrainerPic(void) +{ + s16 xPos; + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right. + xPos = 90; + else // First mon, on the left. + xPos = 32; + + } + else + { + xPos = 80; + } + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_SAPPHIRE + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_EMERALD) + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + 2; + else + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + 0; + } + else + { + trainerPicId = gSaveBlock2Ptr->playerGender + 0; + } + DecompressTrainerBackPalette(trainerPicId, gActiveBattler); + SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(gActiveBattler)); + gBattlerSpriteIds[gActiveBattler] = CreateSprite(&gMultiuseSpriteTemplate, + xPos, + (8 - gTrainerBackPicCoords[trainerPicId].size) * 4 + 80, + GetBattlerSpriteSubpriority(gActiveBattler)); + gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler; + gSprites[gBattlerSpriteIds[gActiveBattler]].pos2.x = 240; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = -2; + gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8033EEC; + gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy; +} + +static void PlayerHandleTrainerSlide(void) +{ + u32 trainerPicId; + + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if ((gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_SAPPHIRE + || (gLinkPlayers[GetMultiplayerId()].version & 0xFF) == VERSION_EMERALD) + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + 2; + else + trainerPicId = gLinkPlayers[GetMultiplayerId()].gender + 0; + } + else + { + trainerPicId = gSaveBlock2Ptr->playerGender + 0; + } + DecompressTrainerBackPalette(trainerPicId, gActiveBattler); + SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(gActiveBattler)); + gBattlerSpriteIds[gActiveBattler] = CreateSprite(&gMultiuseSpriteTemplate, + 80, + (8 - gTrainerBackPicCoords[trainerPicId].size) * 4 + 80, + 30); + gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler; + gSprites[gBattlerSpriteIds[gActiveBattler]].pos2.x = -96; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 2; + gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8033EEC; + gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy2; +} + +static void PlayerHandleTrainerSlideBack(void) +{ + SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 50; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = -40; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[4] = gSprites[gBattlerSpriteIds[gActiveBattler]].pos1.y; + gSprites[gBattlerSpriteIds[gActiveBattler]].callback = StartAnimLinearTranslation; + StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[gActiveBattler]], SpriteCallbackDummy); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 1); + gBattlerControllerFuncs[gActiveBattler] = sub_802F7A0; +} + +static void PlayerHandleFaintAnimation(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0) + { + if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON); + ++gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState; + } + else + { + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + PlaySE12WithPanning(SE_POKE_DEAD, SOUND_PAN_ATTACKER); + gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 5; + gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_8012110; + gBattlerControllerFuncs[gActiveBattler] = sub_8030538; + } + } +} + +static void PlayerHandlePaletteFade(void) +{ + BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, RGB_BLACK); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleSuccessBallThrowAnim(void) +{ + gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS; + gDoingBattleAnim = TRUE; + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW); + gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone; +} + +static void PlayerHandleBallThrowAnim(void) +{ + u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1]; + + gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId; + gDoingBattleAnim = TRUE; + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW); + gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone; +} + +static void PlayerHandlePause(void) +{ + u8 var = gBattleBufferA[gActiveBattler][1]; + + while (var) + --var; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBattler)) + { + u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8); + + gAnimMoveTurn = gBattleBufferA[gActiveBattler][3]; + gAnimMovePower = gBattleBufferA[gActiveBattler][4] | (gBattleBufferA[gActiveBattler][5] << 8); + gAnimMoveDmg = gBattleBufferA[gActiveBattler][6] | (gBattleBufferA[gActiveBattler][7] << 8) | (gBattleBufferA[gActiveBattler][8] << 16) | (gBattleBufferA[gActiveBattler][9] << 24); + gAnimFriendship = gBattleBufferA[gActiveBattler][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBattler][12] | (gBattleBufferA[gActiveBattler][13] << 8); + gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBattler][16]; + gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality; + if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // Always returns FALSE. + { + PlayerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; + gBattlerControllerFuncs[gActiveBattler] = PlayerDoMoveAnimation; + } + } +} + +static void PlayerDoMoveAnimation(void) +{ + u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8); + u8 multihit = gBattleBufferA[gActiveBattler][11]; + + switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState) + { + case 0: + if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute + && !gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8) + { + gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 1; + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON); + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1; + break; + case 1: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + { + sub_8035450(0); + DoMoveAnim(move); + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_8035450(1); + if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute && multihit < 2) + { + InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 0; + } + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 3; + } + break; + case 3: + if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + { + CopyAllBattleSpritesInvisibilities(); + TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; + PlayerBufferExecCompleted(); + } + break; + } +} + +static void PlayerHandlePrintString(void) +{ + u16 *stringId; + + gBattle_BG0_X = 0; + gBattle_BG0_Y = 0; + stringId = (u16 *)(&gBattleBufferA[gActiveBattler][2]); + BufferStringBattle(*stringId); + if (sub_80D89B0(*stringId)) + BattlePutTextOnWindow(gDisplayedStringBattle, 64); + else + BattlePutTextOnWindow(gDisplayedStringBattle, 0); + gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter2; +} + +static void PlayerHandlePrintSelectionString(void) +{ + if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + PlayerHandlePrintString(); + else + PlayerBufferExecCompleted(); +} + +static void HandleChooseActionAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 160; + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseAction; + } +} + +static void PlayerHandleChooseAction(void) +{ + s32 i; + + gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3; + BattlePutTextOnWindow(gUnknown_83FDA4C, 0); + BattlePutTextOnWindow(gUnknown_83FE725, 2); + for (i = 0; i < 4; ++i) + ActionSelectionDestroyCursorAt(i); + ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo); + BattlePutTextOnWindow(gDisplayedStringBattle, 1); +} + +static void PlayerHandleUnknownYesNoBox(void) +{ +} + +static void HandleChooseMoveAfterDma3(void) +{ + if (!IsDma3ManagerBusyWithBgCopy()) + { + gBattle_BG0_X = 0; + gBattle_BG0_Y = 320; + gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; + } +} + +static void PlayerHandleChooseMove(void) +{ + InitMoveSelectionsVarsAndStrings(); + gBattlerControllerFuncs[gActiveBattler] = HandleChooseMoveAfterDma3; +} + +void InitMoveSelectionsVarsAndStrings(void) +{ + MoveSelectionDisplayMoveNames(); + gMultiUsePlayerCursor = 0xFF; + MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionDisplayPpString(); + MoveSelectionDisplayPpNumber(); + MoveSelectionDisplayMoveType(); +} + +static void PlayerHandleChooseItem(void) +{ + s32 i; + + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); + gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem; + gBattlerInMenuId = gActiveBattler; + for (i = 0; i < 3; ++i) + gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][1 + i]; +} + +static void PlayerHandleChoosePokemon(void) +{ + s32 i; + + gUnknown_3004FFC[gActiveBattler] = CreateTask(TaskDummy, 0xFF); + gTasks[gUnknown_3004FFC[gActiveBattler]].data[0] = gBattleBufferA[gActiveBattler][1] & 0xF; + *(&gBattleStruct->battlerPreventingSwitchout) = gBattleBufferA[gActiveBattler][1] >> 4; + *(&gBattleStruct->field_8B) = gBattleBufferA[gActiveBattler][2]; + *(&gBattleStruct->abilityPreventingSwitchout) = gBattleBufferA[gActiveBattler][3]; + for (i = 0; i < 3; ++i) + gUnknown_203B0DC[i] = gBattleBufferA[gActiveBattler][4 + i]; + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_BLACK); + gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon; + gBattlerInMenuId = gActiveBattler; +} + +static void PlayerHandleCmd23(void) +{ + BattleStopLowHpSound(); + BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, RGB_BLACK); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleHealthBarUpdate(void) +{ + s16 hpVal; + + LoadBattleBarGfx(0); + hpVal = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8); + if (hpVal != INSTANT_HP_BAR_DROP) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP); + + SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, curHP, hpVal); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP); + + SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, 0, hpVal); + UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], 0, HP_CURRENT); + } + gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone; +} + +static void PlayerHandleExpUpdate(void) +{ + u8 monId = gBattleBufferA[gActiveBattler][1]; + + if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL) + { + PlayerBufferExecCompleted(); + } + else + { + s16 expPointsToGive; + u8 taskId; + + LoadBattleBarGfx(1); + GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES); // Unused return value. + expPointsToGive = T1_READ_16(&gBattleBufferA[gActiveBattler][2]); + taskId = CreateTask(Task_GiveExpToMon, 10); + gTasks[taskId].tExpTask_monId = monId; + gTasks[taskId].tExpTask_gainedExp = expPointsToGive; + gTasks[taskId].tExpTask_battler = gActiveBattler; + gBattlerControllerFuncs[gActiveBattler] = nullsub_13; + } +} + +static void PlayerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBattler)) + { + u8 battlerId; + + UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON); + battlerId = gActiveBattler; + gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = 0; + gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBattler)) + { + InitAndLaunchChosenStatusAnimation(gBattleBufferA[gActiveBattler][1], + gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8) | (gBattleBufferA[gActiveBattler][4] << 16) | (gBattleBufferA[gActiveBattler][5] << 24)); + gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation; + } +} + +static void PlayerHandleStatusXor(void) +{ + u8 val = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS) ^ gBattleBufferA[gActiveBattler][1]; + + SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS, &val); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleDataTransfer(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandleDMA3Transfer(void) +{ + u32 dstArg = gBattleBufferA[gActiveBattler][1] + | (gBattleBufferA[gActiveBattler][2] << 8) + | (gBattleBufferA[gActiveBattler][3] << 16) + | (gBattleBufferA[gActiveBattler][4] << 24); + u16 sizeArg = gBattleBufferA[gActiveBattler][5] | (gBattleBufferA[gActiveBattler][6] << 8); + const u8 *src = &gBattleBufferA[gActiveBattler][7]; + u8 *dst = (u8 *)(dstArg); + u32 size = sizeArg; + + while (TRUE) + { + 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[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8)); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd32(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandleTwoReturnValues(void) +{ + BtlController_EmitTwoReturnValues(1, 0, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleChosenMonReturnValue(void) +{ + BtlController_EmitChosenMonReturnValue(1, 0, NULL); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleOneReturnValue(void) +{ + BtlController_EmitOneReturnValue(1, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleOneReturnValue_Duplicate(void) +{ + BtlController_EmitOneReturnValue_Duplicate(1, 0); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd37(void) +{ + gUnknown_2022870.field_0 = 0; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd38(void) +{ + gUnknown_2022870.field_0 = gBattleBufferA[gActiveBattler][1]; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd39(void) +{ + gUnknown_2022870.flag_x80 = 0; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd40(void) +{ + gUnknown_2022870.flag_x80 ^= 1; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleHitAnimation(void) +{ + if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE) + { + PlayerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0; + DoHitAnimHealthboxEffect(gActiveBattler); + gBattlerControllerFuncs[gActiveBattler] = DoHitAnimBlinkSpriteEffect; + } +} + +static void PlayerHandleCmd42(void) +{ + PlayerBufferExecCompleted(); +} + +static void PlayerHandlePlaySE(void) +{ + s8 pan; + + if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + pan = SOUND_PAN_ATTACKER; + else + pan = SOUND_PAN_TARGET; + PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan); + PlayerBufferExecCompleted(); +} + +static void PlayerHandlePlayFanfare(void) +{ + PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8)); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleFaintingCry(void) +{ + PlayCry3(GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES), -25, 5); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleIntroSlide(void) +{ + HandleIntroSlide(gBattleBufferA[gActiveBattler][1]); + gIntroSlideFlags |= 1; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleIntroTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]); + gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 50; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = -40; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[4] = gSprites[gBattlerSpriteIds[gActiveBattler]].pos1.y; + gSprites[gBattlerSpriteIds[gActiveBattler]].callback = sub_80755B8; + gSprites[gBattlerSpriteIds[gActiveBattler]].data[5] = gActiveBattler; + StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[gActiveBattler]], sub_80335F8); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 1); + paletteNum = AllocSpritePalette(0xD6F8); + LoadCompressedPalette(gTrainerBackPicPaletteTable[gSaveBlock2Ptr->playerGender].data, 0x100 + paletteNum * 16, 32); + gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = paletteNum; + taskId = CreateTask(task05_08033660, 5); + gTasks[taskId].data[0] = gActiveBattler; + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown) + gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary; + gBattleSpritesDataPtr->animationData->field_9_x1 = 1; + gBattlerControllerFuncs[gActiveBattler] = nullsub_13; +} + +void sub_80335F8(struct Sprite *sprite) +{ + u8 battlerId = sprite->data[5]; + + FreeSpriteOamMatrix(sprite); + FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); + DestroySprite(sprite); + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battlerId]], battlerId); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], 0); +} + +static void task05_08033660(u8 taskId) +{ + if (gTasks[taskId].data[1] < 31) + { + ++gTasks[taskId].data[1]; + } + else + { + u8 savedActiveBattler = gActiveBattler; + + gActiveBattler = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; + sub_8031FF4(gActiveBattler, FALSE); + } + else + { + gBattleBufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; + sub_8031FF4(gActiveBattler, FALSE); + gActiveBattler ^= BIT_FLANK; + gBattleBufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; + BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + sub_8031FF4(gActiveBattler, FALSE); + gActiveBattler ^= BIT_FLANK; + } + gBattlerControllerFuncs[gActiveBattler] = sub_802FA58; + gActiveBattler = savedActiveBattler; + DestroyTask(taskId); + } +} + +static void PlayerHandleDrawPartyStatusSummary(void) +{ + if (gBattleBufferA[gActiveBattler][1] && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + { + PlayerBufferExecCompleted(); + } + else + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown = 1; + gBattlerStatusSummaryTaskId[gActiveBattler] = CreatePartyStatusSummarySprites(gActiveBattler, (struct HpAndStatus *)&gBattleBufferA[gActiveBattler][4], gBattleBufferA[gActiveBattler][1], gBattleBufferA[gActiveBattler][2]); + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_5 = 0; + if (gBattleBufferA[gActiveBattler][2] != 0) + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_5 = 0x5D; + gBattlerControllerFuncs[gActiveBattler] = sub_8033830; + } +} + +static void sub_8033830(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_5++ > 0x5C) + { + gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].field_5 = 0; + PlayerBufferExecCompleted(); + } +} + +static void PlayerHandleHidePartyStatusSummary(void) +{ + if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown) + gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary; + PlayerBufferExecCompleted(); +} + +static void PlayerHandleEndBounceEffect(void) +{ + EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX); + EndBounceEffect(gActiveBattler, BOUNCE_MON); + PlayerBufferExecCompleted(); +} + +static void PlayerHandleSpriteInvisibility(void) +{ + if (IsBattlerSpritePresent(gActiveBattler)) + { + gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleBufferA[gActiveBattler][1]; + CopyBattleSpriteInvisibility(gActiveBattler); + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBattler)) + { + u8 animationId = gBattleBufferA[gActiveBattler][1]; + u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8); + + if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument)) + PlayerBufferExecCompleted(); + else + gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation; + } +} + +static void PlayerHandleLinkStandbyMsg(void) +{ + switch (gBattleBufferA[gActiveBattler][1]) + { + case 0: + PrintLinkStandbyMsg(); + // fall through + case 1: + EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX); + EndBounceEffect(gActiveBattler, BOUNCE_MON); + break; + case 2: + PrintLinkStandbyMsg(); + break; + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleResetActionMoveSelection(void) +{ + switch (gBattleBufferA[gActiveBattler][1]) + { + case RESET_ACTION_MOVE_SELECTION: + gActionSelectionCursor[gActiveBattler] = 0; + gMoveSelectionCursor[gActiveBattler] = 0; + break; + case RESET_ACTION_SELECTION: + gActionSelectionCursor[gActiveBattler] = 0; + break; + case RESET_MOVE_SELECTION: + gMoveSelectionCursor[gActiveBattler] = 0; + break; + } + PlayerBufferExecCompleted(); +} + +static void PlayerHandleCmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBattler][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + PlayerBufferExecCompleted(); + gBattlerControllerFuncs[gActiveBattler] = sub_802F6A8; +} + +static void PlayerCmdEnd(void) +{ +} + +static void sub_8033AC8(void) +{ + u32 bitMask = 0; + u8 startY = 0; + + if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + u8 moveTarget; + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]); + u16 move = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]; + + if (move == MOVE_CURSE) + { + if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST) + moveTarget = MOVE_TARGET_USER; + else + moveTarget = MOVE_TARGET_SELECTED; + } + else + { + moveTarget = gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].target; + } + switch (moveTarget) + { + case MOVE_TARGET_SELECTED: + case MOVE_TARGET_DEPENDS: + case MOVE_TARGET_USER_OR_SELECTED: + case MOVE_TARGET_RANDOM: + bitMask = 0xF0000; + startY = 0; + break; + case MOVE_TARGET_BOTH: + case MOVE_TARGET_OPPONENTS_FIELD: + bitMask = (gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)] + | gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)]) << 16; + startY = 8; + break; + case MOVE_TARGET_USER: + switch (move) + { + case MOVE_HAZE: + case MOVE_SANDSTORM: + case MOVE_PERISH_SONG: + case MOVE_RAIN_DANCE: + case MOVE_SUNNY_DAY: + case MOVE_HAIL: + case MOVE_MUD_SPORT: + case MOVE_WATER_SPORT: + bitMask = 0xF0000; + break; + case MOVE_SAFEGUARD: + case MOVE_REFLECT: + case MOVE_LIGHT_SCREEN: + case MOVE_MIST: + case MOVE_HEAL_BELL: + case MOVE_AROMATHERAPY: + bitMask = (gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)] + | gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)]) << 16; + break; + case MOVE_HELPING_HAND: + bitMask = (gBitTable[GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK)]) << 16; + break; + default: + bitMask = (gBitTable[gActiveBattler]) << 16; + break; + } + startY = 8; + break; + case MOVE_TARGET_FOES_AND_ALLY: + bitMask = (gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)] + | gBitTable[GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK)] + | gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)]) << 16; + startY = 8; + break; + } + BeginNormalPaletteFade(bitMask, 8, startY, 0, RGB_WHITE); + } +} |