diff --git a/common_syms/battle_controllers.txt b/common_syms/battle_controllers.txt new file mode 100644 index 000000000..0b3c25266 --- /dev/null +++ b/common_syms/battle_controllers.txt @@ -0,0 +1,3 @@ +gBattlerControllerFuncs +gBattleControllerData +gBattlerControllerEndFuncs diff --git a/common_syms/battle_main.txt b/common_syms/battle_main.txt index f6f02c48d..7a9faa5a1 100644 --- a/common_syms/battle_main.txt +++ b/common_syms/battle_main.txt @@ -2,8 +2,6 @@ gPreBattleCallback1 gBattleMainFunc gBattleResults gLeveledUpInBattle -gBattlerControllerFuncs gHealthboxSpriteIds gMultiUsePlayerCursor gNumberOfMovesToChoose -gBattleControllerData diff --git a/include/battle.h b/include/battle.h index 00893d105..5e7c4bf52 100644 --- a/include/battle.h +++ b/include/battle.h @@ -1002,11 +1002,9 @@ extern void (*gPreBattleCallback1)(void); extern void (*gBattleMainFunc)(void); extern struct BattleResults gBattleResults; extern u8 gLeveledUpInBattle; -extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void); extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT]; extern u8 gMultiUsePlayerCursor; extern u8 gNumberOfMovesToChoose; -extern u8 gBattleControllerData[MAX_BATTLERS_COUNT]; extern bool8 gHasFetchedBall; extern u8 gLastUsedBall; extern u16 gLastThrownBall; diff --git a/include/battle_controllers.h b/include/battle_controllers.h index 2188cd789..e9498ec01 100644 --- a/include/battle_controllers.h +++ b/include/battle_controllers.h @@ -197,7 +197,9 @@ enum }; extern struct UnusedControllerStruct gUnusedControllerStruct; -extern void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(void); +extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler); +extern void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(u32 battler); +extern u8 gBattleControllerData[MAX_BATTLERS_COUNT]; // general functions void HandleLinkBattleSetup(void); @@ -253,87 +255,87 @@ void BtlController_EmitEndLinkBattle(u8 bufferId, u8 battleOutcome); void BtlController_EmitDebugMenu(u8 bufferId); void BattleControllerComplete(u32 battler); // Can be used for all the controllers. -void BtlController_Empty(void); // Empty command, does nothing, only completes the execution. -void BtlController_TerminatorNop(void); // Dummy function at the end of the table. +void BtlController_Empty(u32 battler); // Empty command, does nothing, only completes the execution. +void BtlController_TerminatorNop(u32 battler); // Dummy function at the end of the table. +void BattleControllerDummy(u32 battler); void StartSendOutAnim(u32 battler, bool32 dontClearSubstituteBit); -void Controller_WaitForString(void); -void Controller_WaitForHealthBar(void); +void Controller_WaitForString(u32 battler); +void Controller_WaitForHealthBar(u32 battler); // handlers -void BtlController_HandleGetMonData(void); -void BtlController_HandleGetRawMonData(void); -void BtlController_HandleSetMonData(void); -void BtlController_HandleSetRawMonData(void); -void BtlController_HandleLoadMonSprite(u32 battler, struct Pokemon *party, void (*controllerCallback)(void)); -void BtlController_HandleSwitchInAnim(u32 battler, bool32 isPlayerSide, void (*controllerCallback)(void)); -void BtlController_HandleReturnMonToBall(void); +void BtlController_HandleGetMonData(u32 battler); +void BtlController_HandleGetRawMonData(u32 battler); +void BtlController_HandleSetMonData(u32 battler); +void BtlController_HandleSetRawMonData(u32 battler); +void BtlController_HandleLoadMonSprite(u32 battler, struct Pokemon *party, void (*controllerCallback)(u32 battler)); +void BtlController_HandleSwitchInAnim(u32 battler, bool32 isPlayerSide, void (*controllerCallback)(u32 battler)); +void BtlController_HandleReturnMonToBall(u32 battler); void BtlController_HandleDrawTrainerPic(u32 battlerId, u32 trainerPicId, bool32 isFrontPic, s16 xPos, s16 yPos, s32 subpriority); void BtlController_HandleTrainerSlide(u32 battler, u32 trainerPicId); void BtlController_HandleTrainerSlideBack(u32 battlerId, s16 data0, bool32 startAnim); -void BtlController_HandleFaintAnimation(void); +void BtlController_HandleFaintAnimation(u32 battler); void BtlController_HandleSuccessBallThrowAnim(u32 battler, u32 target, u32 animId, bool32 allowCriticalCapture); void BtlController_HandleBallThrowAnim(u32 battler, u32 target, u32 animId, bool32 allowCriticalCapture); void BtlController_HandleMoveAnimation(u32 battler, bool32 updateTvData); void BtlController_HandlePrintString(u32 battler, bool32 updateTvData, bool32 arenaPtsDeduct); void BtlController_HandleHealthBarUpdate(u32 battler, bool32 updateHpText); void DoStatusIconUpdate(u32 battler); -void BtlController_HandleStatusIconUpdate(void); -void BtlController_HandleStatusAnimation(void); -void BtlController_HandleClearUnkVar(void); -void BtlController_HandleSetUnkVar(void); -void BtlController_HandleClearUnkFlag(void); -void BtlController_HandleToggleUnkFlag(void); -void BtlController_HandleHitAnimation(void); -void BtlController_HandlePlaySE(void); -void BtlController_HandlePlayFanfareOrBGM(void); -void BtlController_HandleFaintingCry(void); -void BtlController_HandleIntroSlide(void); -void BtlController_HandleSpriteInvisibility(void); +void BtlController_HandleStatusIconUpdate(u32 battler); +void BtlController_HandleStatusAnimation(u32 battler); +void BtlController_HandleClearUnkVar(u32 battler); +void BtlController_HandleSetUnkVar(u32 battler); +void BtlController_HandleClearUnkFlag(u32 battler); +void BtlController_HandleToggleUnkFlag(u32 battler); +void BtlController_HandleHitAnimation(u32 battler); +void BtlController_HandlePlaySE(u32 battler); +void BtlController_HandlePlayFanfareOrBGM(u32 battler); +void BtlController_HandleFaintingCry(u32 battler); +void BtlController_HandleIntroSlide(u32 battler); +void BtlController_HandleSpriteInvisibility(u32 battler); bool32 TwoPlayerIntroMons(u32 battlerId); // Double battle with both player pokemon active. bool32 TwoOpponentIntroMons(u32 battlerId); // Double battle with both opponent pokemon active. -void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u32 *trainerPal, s16 framesToWait, void (*controllerCallback)(void)); +void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u32 *trainerPal, s16 framesToWait, void (*controllerCallback)(u32 battler)); void BtlController_HandleDrawPartyStatusSummary(u32 battler, u32 side, bool32 considerDelay); -void BtlController_HandleHidePartyStatusSummary(void); +void BtlController_HandleHidePartyStatusSummary(u32 battler); void BtlController_HandleBattleAnimation(u32 battler, bool32 ignoreSE, bool32 updateTvData); // player controller -void SetControllerToPlayer(void); -void BattleControllerDummy(void); -void SetBattleEndCallbacks(void); -void PlayerHandleExpUpdate(void); +void SetControllerToPlayer(u32 battler); +void SetBattleEndCallbacks(u32 battler); +void PlayerHandleExpUpdate(u32 battler); u32 LinkPlayerGetTrainerPicId(u32 multiplayerId); void CB2_SetUpReshowBattleScreenAfterMenu(void); void CB2_SetUpReshowBattleScreenAfterMenu2(void); void Task_PlayerController_RestoreBgmAfterCry(u8 taskId); void ActionSelectionCreateCursorAt(u8 cursorPos, u8 unused); void ActionSelectionDestroyCursorAt(u8 cursorPos); -void InitMoveSelectionsVarsAndStrings(void); +void InitMoveSelectionsVarsAndStrings(u32 battler); void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1); void MoveSelectionDestroyCursorAt(u8 cursorPosition); // recorded player controller -void SetControllerToRecordedPlayer(void); +void SetControllerToRecordedPlayer(u32 battler); // opponent controller -void SetControllerToOpponent(void); +void SetControllerToOpponent(u32 battler); // player partner controller -void Controller_PlayerPartnerShowIntroHealthbox(void); // Also used by the link partner. -void SetControllerToPlayerPartner(void); +void Controller_PlayerPartnerShowIntroHealthbox(u32 battler); // Also used by the link partner. +void SetControllerToPlayerPartner(u32 battler); // safari controller -void SetControllerToSafari(void); +void SetControllerToSafari(u32 battler); // wally controller -void SetControllerToWally(void); +void SetControllerToWally(u32 battler); // recorded opponent controller -void SetControllerToRecordedOpponent(void); +void SetControllerToRecordedOpponent(u32 battler); // link opponent -void SetControllerToLinkOpponent(void); +void SetControllerToLinkOpponent(u32 battler); // link partner -void SetControllerToLinkPartner(void); +void SetControllerToLinkPartner(u32 battler); #endif // GUARD_BATTLE_CONTROLLERS_H diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 98f2e6451..60ef924b9 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -29,25 +29,25 @@ #include "constants/trainers.h" #include "recorded_battle.h" -static void LinkOpponentHandleLoadMonSprite(void); -static void LinkOpponentHandleSwitchInAnim(void); -static void LinkOpponentHandleDrawTrainerPic(void); -static void LinkOpponentHandleTrainerSlide(void); -static void LinkOpponentHandleTrainerSlideBack(void); -static void LinkOpponentHandleMoveAnimation(void); -static void LinkOpponentHandlePrintString(void); -static void LinkOpponentHandleHealthBarUpdate(void); -static void LinkOpponentHandleIntroTrainerBallThrow(void); -static void LinkOpponentHandleDrawPartyStatusSummary(void); -static void LinkOpponentHandleBattleAnimation(void); -static void LinkOpponentHandleLinkStandbyMsg(void); -static void LinkOpponentHandleEndLinkBattle(void); +static void LinkOpponentHandleLoadMonSprite(u32 battler); +static void LinkOpponentHandleSwitchInAnim(u32 battler); +static void LinkOpponentHandleDrawTrainerPic(u32 battler); +static void LinkOpponentHandleTrainerSlide(u32 battler); +static void LinkOpponentHandleTrainerSlideBack(u32 battler); +static void LinkOpponentHandleMoveAnimation(u32 battler); +static void LinkOpponentHandlePrintString(u32 battler); +static void LinkOpponentHandleHealthBarUpdate(u32 battler); +static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler); +static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler); +static void LinkOpponentHandleBattleAnimation(u32 battler); +static void LinkOpponentHandleLinkStandbyMsg(u32 battler); +static void LinkOpponentHandleEndLinkBattle(u32 battler); -static void LinkOpponentBufferRunCommand(void); -static void LinkOpponentBufferExecCompleted(void); -static void SwitchIn_HandleSoundAndEnd(void); +static void LinkOpponentBufferRunCommand(u32 battler); +static void LinkOpponentBufferExecCompleted(u32 battler); +static void SwitchIn_HandleSoundAndEnd(u32 battler); -static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -109,46 +109,46 @@ static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToLinkOpponent(void) +void SetControllerToLinkOpponent(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = LinkOpponentBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = LinkOpponentBufferRunCommand; + gBattlerControllerEndFuncs[battler] = LinkOpponentBufferExecCompleted; + gBattlerControllerFuncs[battler] = LinkOpponentBufferRunCommand; } -static void LinkOpponentBufferRunCommand(void) +static void LinkOpponentBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sLinkOpponentBufferCommands)) - sLinkOpponentBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sLinkOpponentBufferCommands)) + sLinkOpponentBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - LinkOpponentBufferExecCompleted(); + LinkOpponentBufferExecCompleted(battler); } } -static void Intro_DelayAndEnd(void) +static void Intro_DelayAndEnd(u32 battler) { - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - LinkOpponentBufferExecCompleted(); + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + LinkOpponentBufferExecCompleted(battler); } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool32 healthboxAnimDone = FALSE; bool32 twoMons = FALSE; if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { healthboxAnimDone = TRUE; } @@ -157,87 +157,87 @@ static void Intro_WaitForShinyAnimAndHealthbox(void) if (healthboxAnimDone) { - if (twoMons || !IsBattlerSpriteVisible(BATTLE_PARTNER(gActiveBattler))) + if (twoMons || !IsBattlerSpriteVisible(BATTLE_PARTNER(battler))) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) return; - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) return; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); } else { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) return; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; - if (GetBattlerPosition(gActiveBattler) == B_POSITION_OPPONENT_RIGHT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_RIGHT) { FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); } } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { bool32 bgmRestored = FALSE; - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); } if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + TryShinyAnimation(BATTLE_PARTNER(battler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); } - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = TRUE; } - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].waitForCry - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].waitForCry + if (!gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry + && gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].waitForCry && !IsCryPlayingOrClearCrySongs()) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored) { if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) { - if (GetBattlerPosition(gActiveBattler) == B_POSITION_OPPONENT_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) m4aMPlayContinue(&gMPlayInfo_BGM); } else @@ -246,189 +246,189 @@ static void Intro_TryShinyAnimShowHealthbox(void) } } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = TRUE; bgmRestored = TRUE; } if (bgmRestored) { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - if (gBattleTypeFlags & BATTLE_TYPE_MULTI && GetBattlerPosition(gActiveBattler) == B_POSITION_OPPONENT_RIGHT) + if (gBattleTypeFlags & BATTLE_TYPE_MULTI && GetBattlerPosition(battler) == B_POSITION_OPPONENT_RIGHT) { - if (++gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == 1) + if (++gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == 1) return; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; } if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - SetBattlerShadowSpriteCallback(BATTLE_PARTNER(gActiveBattler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + SetBattlerShadowSpriteCallback(BATTLE_PARTNER(battler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], MON_DATA_SPECIES)); } - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } } -static void TryShinyAnimAfterMonAnim(void) +static void TryShinyAnimAfterMonAnim(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].x2 == 0) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) { - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); } - else if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + else if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - LinkOpponentBufferExecCompleted(); + LinkOpponentBufferExecCompleted(battler); } } } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_HandleSoundAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_HandleSoundAndEnd; } } -static void SwitchIn_HandleSoundAndEnd(void) +static void SwitchIn_HandleSoundAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - || gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy_2) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + || gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy_2) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); - LinkOpponentBufferExecCompleted(); + LinkOpponentBufferExecCompleted(battler); } } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); - CopyBattleSpriteInvisibility(gActiveBattler); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + CopyBattleSpriteInvisibility(battler); + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) { - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); } - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void LinkOpponentBufferExecCompleted(void) +static void LinkOpponentBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = LinkOpponentBufferRunCommand; + gBattlerControllerFuncs[battler] = LinkOpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void LinkOpponentHandleLoadMonSprite(void) +static void LinkOpponentHandleLoadMonSprite(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gEnemyParty, TryShinyAnimAfterMonAnim); + BtlController_HandleLoadMonSprite(battler, gEnemyParty, TryShinyAnimAfterMonAnim); } -static void LinkOpponentHandleSwitchInAnim(void) +static void LinkOpponentHandleSwitchInAnim(u32 battler) { - BtlController_HandleSwitchInAnim(gActiveBattler, FALSE, SwitchIn_TryShinyAnim); + BtlController_HandleSwitchInAnim(battler, FALSE, SwitchIn_TryShinyAnim); } -static void LinkOpponentHandleDrawTrainerPic(void) +static void LinkOpponentHandleDrawTrainerPic(u32 battler) { s16 xPos; u32 trainerPicId; if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != 0) // second mon + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 152; else // first mon xPos = 200; if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) { - if (gActiveBattler == B_POSITION_OPPONENT_LEFT) + if (battler == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); else trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); } else { - if ((gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].version & 0xFF) == VERSION_FIRE_RED - || (gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].version & 0xFF) == VERSION_LEAF_GREEN) + if ((gLinkPlayers[GetBattlerMultiplayerId(battler)].version & 0xFF) == VERSION_FIRE_RED + || (gLinkPlayers[GetBattlerMultiplayerId(battler)].version & 0xFF) == VERSION_LEAF_GREEN) { - if (gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender != MALE) + if (gLinkPlayers[GetBattlerMultiplayerId(battler)].gender != MALE) trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_LEAF]; else trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_RED]; } - else if ((gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].version & 0xFF) == VERSION_RUBY - || (gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].version & 0xFF) == VERSION_SAPPHIRE) + else if ((gLinkPlayers[GetBattlerMultiplayerId(battler)].version & 0xFF) == VERSION_RUBY + || (gLinkPlayers[GetBattlerMultiplayerId(battler)].version & 0xFF) == VERSION_SAPPHIRE) { - if (gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender != MALE) + if (gLinkPlayers[GetBattlerMultiplayerId(battler)].gender != MALE) trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_RS_MAY]; else trainerPicId = gFacilityClassToPicIndex[FACILITY_CLASS_RS_BRENDAN]; } else { - trainerPicId = PlayerGenderToFrontTrainerPicId(gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender); + trainerPicId = PlayerGenderToFrontTrainerPicId(gLinkPlayers[GetBattlerMultiplayerId(battler)].gender); } } } @@ -461,77 +461,77 @@ static void LinkOpponentHandleDrawTrainerPic(void) } } - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, TRUE, + BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicId].size), -1); } -static void LinkOpponentHandleTrainerSlide(void) +static void LinkOpponentHandleTrainerSlide(u32 battler) { u32 trainerPicId; - if (gActiveBattler == 1) + if (battler == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); else trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); - BtlController_HandleTrainerSlide(gActiveBattler, trainerPicId); - LinkOpponentBufferExecCompleted(); // Possibly a bug, because execution should be completed after the slide in finishes. See Controller_WaitForTrainerPic. + BtlController_HandleTrainerSlide(battler, trainerPicId); + LinkOpponentBufferExecCompleted(battler); // Possibly a bug, because execution should be completed after the slide in finishes. See Controller_WaitForTrainerPic. } -static void LinkOpponentHandleTrainerSlideBack(void) +static void LinkOpponentHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void LinkOpponentHandleMoveAnimation(void) +static void LinkOpponentHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, TRUE); + BtlController_HandleMoveAnimation(battler, TRUE); } -static void LinkOpponentHandlePrintString(void) +static void LinkOpponentHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, TRUE, FALSE); + BtlController_HandlePrintString(battler, TRUE, FALSE); } -static void LinkOpponentHandleHealthBarUpdate(void) +static void LinkOpponentHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, FALSE); + BtlController_HandleHealthBarUpdate(battler, FALSE); } -static void LinkOpponentHandleIntroTrainerBallThrow(void) +static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler) { - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void LinkOpponentHandleDrawPartyStatusSummary(void) +static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_OPPONENT, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void LinkOpponentHandleBattleAnimation(void) +static void LinkOpponentHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, TRUE); + BtlController_HandleBattleAnimation(battler, FALSE, TRUE); } -static void LinkOpponentHandleLinkStandbyMsg(void) +static void LinkOpponentHandleLinkStandbyMsg(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][2]); - LinkOpponentBufferExecCompleted(); + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); + LinkOpponentBufferExecCompleted(battler); } -static void LinkOpponentHandleEndLinkBattle(void) +static void LinkOpponentHandleEndLinkBattle(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][4]); + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); - if (gBattleResources->bufferA[gActiveBattler][1] == B_OUTCOME_DREW) - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + if (gBattleResources->bufferA[battler][1] == B_OUTCOME_DREW) + gBattleOutcome = gBattleResources->bufferA[battler][1]; else - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1] ^ B_OUTCOME_DREW; + gBattleOutcome = gBattleResources->bufferA[battler][1] ^ B_OUTCOME_DREW; - gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[gActiveBattler][2]; + gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[battler][2]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - LinkOpponentBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + LinkOpponentBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index 41337a6c7..b08e8c087 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -29,24 +29,24 @@ #include "constants/trainers.h" #include "recorded_battle.h" -static void LinkPartnerHandleLoadMonSprite(void); -static void LinkPartnerHandleSwitchInAnim(void); -static void LinkPartnerHandleDrawTrainerPic(void); -static void LinkPartnerHandleTrainerSlideBack(void); -static void LinkPartnerHandleMoveAnimation(void); -static void LinkPartnerHandlePrintString(void); -static void LinkPartnerHandleHealthBarUpdate(void); -static void LinkPartnerHandleIntroTrainerBallThrow(void); -static void LinkPartnerHandleDrawPartyStatusSummary(void); -static void LinkPartnerHandleBattleAnimation(void); -static void LinkPartnerHandleLinkStandbyMsg(void); -static void LinkPartnerHandleEndLinkBattle(void); +static void LinkPartnerHandleLoadMonSprite(u32 battler); +static void LinkPartnerHandleSwitchInAnim(u32 battler); +static void LinkPartnerHandleDrawTrainerPic(u32 battler); +static void LinkPartnerHandleTrainerSlideBack(u32 battler); +static void LinkPartnerHandleMoveAnimation(u32 battler); +static void LinkPartnerHandlePrintString(u32 battler); +static void LinkPartnerHandleHealthBarUpdate(u32 battler); +static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler); +static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler); +static void LinkPartnerHandleBattleAnimation(u32 battler); +static void LinkPartnerHandleLinkStandbyMsg(u32 battler); +static void LinkPartnerHandleEndLinkBattle(u32 battler); -static void LinkPartnerBufferRunCommand(void); -static void LinkPartnerBufferExecCompleted(void); -static void SwitchIn_WaitAndEnd(void); +static void LinkPartnerBufferRunCommand(u32 battler); +static void LinkPartnerBufferExecCompleted(u32 battler); +static void SwitchIn_WaitAndEnd(u32 battler); -static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -108,121 +108,121 @@ static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToLinkPartner(void) +void SetControllerToLinkPartner(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = LinkPartnerBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = LinkPartnerBufferRunCommand; + gBattlerControllerEndFuncs[battler] = LinkPartnerBufferExecCompleted; + gBattlerControllerFuncs[battler] = LinkPartnerBufferRunCommand; } -static void LinkPartnerBufferRunCommand(void) +static void LinkPartnerBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sLinkPartnerBufferCommands)) - sLinkPartnerBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sLinkPartnerBufferCommands)) + sLinkPartnerBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - LinkPartnerBufferExecCompleted(); + LinkPartnerBufferExecCompleted(battler); } } -static void WaitForMonAnimAfterLoad(void) +static void WaitForMonAnimAfterLoad(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) - LinkPartnerBufferExecCompleted(); + if (gSprites[gBattlerSpriteIds[battler]].animEnded && gSprites[gBattlerSpriteIds[battler]].x2 == 0) + LinkPartnerBufferExecCompleted(battler); } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - CopyBattleSpriteInvisibility(gActiveBattler); - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + CopyBattleSpriteInvisibility(battler); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_WaitAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_WaitAndEnd; } } -static void SwitchIn_WaitAndEnd(void) +static void SwitchIn_WaitAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - LinkPartnerBufferExecCompleted(); + LinkPartnerBufferExecCompleted(battler); } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); CreateTask(Task_PlayerController_RestoreBgmAfterCry, 10); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); } - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void LinkPartnerBufferExecCompleted(void) +static void LinkPartnerBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = LinkPartnerBufferRunCommand; + gBattlerControllerFuncs[battler] = LinkPartnerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void LinkPartnerHandleLoadMonSprite(void) +static void LinkPartnerHandleLoadMonSprite(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gPlayerParty, WaitForMonAnimAfterLoad); + BtlController_HandleLoadMonSprite(battler, gPlayerParty, WaitForMonAnimAfterLoad); } -static void LinkPartnerHandleSwitchInAnim(void) +static void LinkPartnerHandleSwitchInAnim(u32 battler) { - BtlController_HandleSwitchInAnim(gActiveBattler, TRUE, SwitchIn_TryShinyAnim); + BtlController_HandleSwitchInAnim(battler, TRUE, SwitchIn_TryShinyAnim); } -static void LinkPartnerHandleDrawTrainerPic(void) +static void LinkPartnerHandleDrawTrainerPic(u32 battler) { s16 xPos; u32 trainerPicId; if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != 0) // second mon + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 90; else // first mon xPos = 32; @@ -232,76 +232,63 @@ static void LinkPartnerHandleDrawTrainerPic(void) xPos = 80; } - trainerPicId = LinkPlayerGetTrainerPicId(GetBattlerMultiplayerId(gActiveBattler)); - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, FALSE, + trainerPicId = LinkPlayerGetTrainerPicId(GetBattlerMultiplayerId(battler)); + BtlController_HandleDrawTrainerPic(battler, trainerPicId, FALSE, xPos, 80 + 4 * (8 - gTrainerBackPicCoords[trainerPicId].size), -1); } -static void LinkPartnerHandleTrainerSlideBack(void) +static void LinkPartnerHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void LinkPartnerHandleMoveAnimation(void) +static void LinkPartnerHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, TRUE); + BtlController_HandleMoveAnimation(battler, TRUE); } -static void LinkPartnerHandlePrintString(void) +static void LinkPartnerHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, TRUE, FALSE); + BtlController_HandlePrintString(battler, TRUE, FALSE); } -static void LinkPartnerHandleHealthBarUpdate(void) +static void LinkPartnerHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, FALSE); + BtlController_HandleHealthBarUpdate(battler, FALSE); } -static void LinkPartnerHandleIntroTrainerBallThrow(void) +static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler) { - u32 trainerPicId; - u8 gameVersion, playerGender; - const u32 *trainerPal; - - gameVersion = gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].version & 0xFF; - playerGender = gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender; - - if (gameVersion == VERSION_FIRE_RED || gameVersion == VERSION_LEAF_GREEN) - trainerPicId = playerGender + TRAINER_BACK_PIC_RED; - else if (gameVersion == VERSION_RUBY || gameVersion == VERSION_SAPPHIRE) - trainerPicId = playerGender + TRAINER_BACK_PIC_RUBY_SAPPHIRE_BRENDAN; - else - trainerPicId = playerGender + TRAINER_BACK_PIC_BRENDAN; - - trainerPal = gTrainerBackPicPaletteTable[trainerPicId].data; + u32 trainerPicId = LinkPlayerGetTrainerPicId(GetBattlerMultiplayerId(battler)); + const u32 *trainerPal = gTrainerBackPicPaletteTable[trainerPicId].data; // Link partner uses the same intro sequence as the player partner. - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); } -static void LinkPartnerHandleDrawPartyStatusSummary(void) +static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_PLAYER, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void LinkPartnerHandleBattleAnimation(void) +static void LinkPartnerHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, TRUE); + BtlController_HandleBattleAnimation(battler, FALSE, TRUE); } -static void LinkPartnerHandleLinkStandbyMsg(void) +static void LinkPartnerHandleLinkStandbyMsg(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][2]); - LinkPartnerBufferExecCompleted(); + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); + LinkPartnerBufferExecCompleted(battler); } -static void LinkPartnerHandleEndLinkBattle(void) +static void LinkPartnerHandleEndLinkBattle(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][4]); - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; - gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[gActiveBattler][2]; + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); + gBattleOutcome = gBattleResources->bufferA[battler][1]; + gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[battler][2]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - LinkPartnerBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + LinkPartnerBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 5da0ce204..2a89148d3 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -39,29 +39,29 @@ #include "constants/trainers.h" #include "trainer_hill.h" -static void OpponentHandleLoadMonSprite(void); -static void OpponentHandleSwitchInAnim(void); -static void OpponentHandleDrawTrainerPic(void); -static void OpponentHandleTrainerSlide(void); -static void OpponentHandleTrainerSlideBack(void); -static void OpponentHandleMoveAnimation(void); -static void OpponentHandlePrintString(void); -static void OpponentHandleChooseAction(void); -static void OpponentHandleChooseMove(void); -static void OpponentHandleChooseItem(void); -static void OpponentHandleChoosePokemon(void); -static void OpponentHandleHealthBarUpdate(void); -static void OpponentHandleIntroTrainerBallThrow(void); -static void OpponentHandleDrawPartyStatusSummary(void); -static void OpponentHandleBattleAnimation(void); -static void OpponentHandleEndLinkBattle(void); +static void OpponentHandleLoadMonSprite(u32 battler); +static void OpponentHandleSwitchInAnim(u32 battler); +static void OpponentHandleDrawTrainerPic(u32 battler); +static void OpponentHandleTrainerSlide(u32 battler); +static void OpponentHandleTrainerSlideBack(u32 battler); +static void OpponentHandleMoveAnimation(u32 battler); +static void OpponentHandlePrintString(u32 battler); +static void OpponentHandleChooseAction(u32 battler); +static void OpponentHandleChooseMove(u32 battler); +static void OpponentHandleChooseItem(u32 battler); +static void OpponentHandleChoosePokemon(u32 battler); +static void OpponentHandleHealthBarUpdate(u32 battler); +static void OpponentHandleIntroTrainerBallThrow(u32 battler); +static void OpponentHandleDrawPartyStatusSummary(u32 battler); +static void OpponentHandleBattleAnimation(u32 battler); +static void OpponentHandleEndLinkBattle(u32 battler); static u8 CountAIAliveNonEggMonsExcept(u8 slotToIgnore); -static void OpponentBufferRunCommand(void); -static void OpponentBufferExecCompleted(void); -static void SwitchIn_HandleSoundAndEnd(void); +static void OpponentBufferRunCommand(u32 battler); +static void OpponentBufferExecCompleted(u32 battler); +static void SwitchIn_HandleSoundAndEnd(u32 battler); -static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -123,78 +123,78 @@ static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToOpponent(void) +void SetControllerToOpponent(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = OpponentBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = OpponentBufferRunCommand; + gBattlerControllerEndFuncs[battler] = OpponentBufferExecCompleted; + gBattlerControllerFuncs[battler] = OpponentBufferRunCommand; } -static void OpponentBufferRunCommand(void) +static void OpponentBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sOpponentBufferCommands)) - sOpponentBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sOpponentBufferCommands)) + sOpponentBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } } -static void Intro_DelayAndEnd(void) +static void Intro_DelayAndEnd(u32 battler) { - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - OpponentBufferExecCompleted(); + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + OpponentBufferExecCompleted(battler); } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool8 healthboxAnimDone = FALSE; bool8 twoMons; - twoMons = TwoOpponentIntroMons(gActiveBattler); + twoMons = TwoOpponentIntroMons(battler); if (!twoMons || ((twoMons && (gBattleTypeFlags & BATTLE_TYPE_MULTI) && !BATTLE_TWO_VS_ONE_OPPONENT) || (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; twoMons = FALSE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; twoMons = TRUE; } - gBattleControllerOpponentHealthboxData = &gBattleSpritesDataPtr->healthBoxesData[gActiveBattler]; - gBattleControllerOpponentFlankHealthboxData = &gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)]; + gBattleControllerOpponentHealthboxData = &gBattleSpritesDataPtr->healthBoxesData[battler]; + gBattleControllerOpponentFlankHealthboxData = &gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)]; if (healthboxAnimDone) { if (twoMons == TRUE) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); } else return; } - else if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + else if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - if (GetBattlerPosition(gActiveBattler) == 3) + if (GetBattlerPosition(battler) == 3) { - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); @@ -202,87 +202,87 @@ static void Intro_WaitForShinyAnimAndHealthbox(void) else return; } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; } else return; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; bool32 twoMons; - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); - twoMons = TwoOpponentIntroMons(gActiveBattler); + twoMons = TwoOpponentIntroMons(battler); if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) && (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) || BATTLE_TWO_VS_ONE_OPPONENT) && twoMons - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) + TryShinyAnimation(BATTLE_PARTNER(battler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted) { if (twoMons && (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) || BATTLE_TWO_VS_ONE_OPPONENT)) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = TRUE; } - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].waitForCry - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].waitForCry + if (!gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry + && gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].waitForCry && !IsCryPlayingOrClearCrySongs()) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored) { if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) { - if (GetBattlerPosition(gActiveBattler) == 1) + if (GetBattlerPosition(battler) == 1) m4aMPlayContinue(&gMPlayInfo_BGM); } else m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = TRUE; bgmRestored = TRUE; } if (!twoMons || (twoMons && gBattleTypeFlags & BATTLE_TYPE_MULTI && !BATTLE_TWO_VS_ONE_OPPONENT)) { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } } else { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } @@ -292,119 +292,119 @@ static void Intro_TryShinyAnimShowHealthbox(void) { if (twoMons && (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) || BATTLE_TWO_VS_ONE_OPPONENT)) { - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - SetBattlerShadowSpriteCallback(BATTLE_PARTNER(gActiveBattler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + SetBattlerShadowSpriteCallback(BATTLE_PARTNER(battler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], MON_DATA_SPECIES)); } - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } -static void TryShinyAnimAfterMonAnim(void) +static void TryShinyAnimAfterMonAnim(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0 - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + if (gSprites[gBattlerSpriteIds[battler]].x2 == 0 + && !gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_HandleSoundAndEnd; + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); + gBattlerControllerFuncs[battler] = SwitchIn_HandleSoundAndEnd; } } -static void SwitchIn_HandleSoundAndEnd(void) +static void SwitchIn_HandleSoundAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - || gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy_2) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + || gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy_2) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); - CopyBattleSpriteInvisibility(gActiveBattler); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + CopyBattleSpriteInvisibility(battler); + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void OpponentBufferExecCompleted(void) +static void OpponentBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = OpponentBufferRunCommand; + gBattlerControllerFuncs[battler] = OpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void OpponentHandleLoadMonSprite(void) +static void OpponentHandleLoadMonSprite(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gEnemyParty, TryShinyAnimAfterMonAnim); + BtlController_HandleLoadMonSprite(battler, gEnemyParty, TryShinyAnimAfterMonAnim); } -static void OpponentHandleSwitchInAnim(void) +static void OpponentHandleSwitchInAnim(u32 battler) { - gBattleStruct->monToSwitchIntoId[gActiveBattler] = PARTY_SIZE; - BtlController_HandleSwitchInAnim(gActiveBattler, FALSE, SwitchIn_TryShinyAnim); + gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; + BtlController_HandleSwitchInAnim(battler, FALSE, SwitchIn_TryShinyAnim); } static u32 OpponentGetTrainerPicId(u32 battlerId) @@ -466,14 +466,14 @@ static u32 OpponentGetTrainerPicId(u32 battlerId) return trainerPicId; } -static void OpponentHandleDrawTrainerPic(void) +static void OpponentHandleDrawTrainerPic(u32 battler) { s16 xPos; - u32 trainerPicId = OpponentGetTrainerPicId(gActiveBattler); + u32 trainerPicId = OpponentGetTrainerPicId(battler); if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != 0) // second mon + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 152; else // first mon xPos = 200; @@ -483,42 +483,42 @@ static void OpponentHandleDrawTrainerPic(void) xPos = 176; } - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, TRUE, + BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicId].size), -1); } -static void OpponentHandleTrainerSlide(void) +static void OpponentHandleTrainerSlide(u32 battler) { - u32 trainerPicId = OpponentGetTrainerPicId(gActiveBattler); - BtlController_HandleTrainerSlide(gActiveBattler, trainerPicId); + u32 trainerPicId = OpponentGetTrainerPicId(battler); + BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void OpponentHandleTrainerSlideBack(void) +static void OpponentHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void OpponentHandleMoveAnimation(void) +static void OpponentHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, FALSE); + BtlController_HandleMoveAnimation(battler, FALSE); } -static void OpponentHandlePrintString(void) +static void OpponentHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, FALSE, TRUE); + BtlController_HandlePrintString(battler, FALSE, TRUE); } -static void OpponentHandleChooseAction(void) +static void OpponentHandleChooseAction(u32 battler) { AI_TrySwitchOrUseItem(); - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } -static void OpponentHandleChooseMove(void) +static void OpponentHandleChooseMove(u32 battler) { u8 chosenMoveId; - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); if (gBattleTypeFlags & (BATTLE_TYPE_TRAINER | BATTLE_TYPE_FIRST_BATTLE | BATTLE_TYPE_SAFARI | BATTLE_TYPE_ROAMER) || IsWildMonSmart()) @@ -529,8 +529,8 @@ static void OpponentHandleChooseMove(void) } else { - chosenMoveId = gBattleStruct->aiMoveOrAction[gActiveBattler]; - gBattlerTarget = gBattleStruct->aiChosenTarget[gActiveBattler]; + chosenMoveId = gBattleStruct->aiMoveOrAction[battler]; + gBattlerTarget = gBattleStruct->aiChosenTarget[battler]; switch (chosenMoveId) { case AI_CHOICE_WATCH: @@ -549,17 +549,17 @@ static void OpponentHandleChooseMove(void) { u16 chosenMove = moveInfo->moves[chosenMoveId]; - if (GetBattlerMoveTargetType(gActiveBattler, chosenMove) & (MOVE_TARGET_USER_OR_SELECTED | MOVE_TARGET_USER)) - gBattlerTarget = gActiveBattler; - if (GetBattlerMoveTargetType(gActiveBattler, chosenMove) & MOVE_TARGET_BOTH) + if (GetBattlerMoveTargetType(battler, chosenMove) & (MOVE_TARGET_USER_OR_SELECTED | MOVE_TARGET_USER)) + gBattlerTarget = battler; + if (GetBattlerMoveTargetType(battler, chosenMove) & MOVE_TARGET_BOTH) { gBattlerTarget = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); if (gAbsentBattlerFlags & gBitTable[gBattlerTarget]) gBattlerTarget = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); } - if (ShouldUseZMove(gActiveBattler, gBattlerTarget, chosenMove)) - QueueZMove(gActiveBattler, chosenMove); - if (CanMegaEvolve(gActiveBattler)) // If opponent can mega evolve, do it. + if (ShouldUseZMove(battler, gBattlerTarget, chosenMove)) + QueueZMove(battler, chosenMove); + if (CanMegaEvolve(battler)) // If opponent can mega evolve, do it. BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (RET_MEGA_EVOLUTION) | (gBattlerTarget << 8)); else BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); @@ -567,7 +567,7 @@ static void OpponentHandleChooseMove(void) break; } } - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } else // Wild pokemon - use random move { @@ -579,13 +579,13 @@ static void OpponentHandleChooseMove(void) move = moveInfo->moves[chosenMoveId]; } while (move == MOVE_NONE); - if (GetBattlerMoveTargetType(gActiveBattler, move) & (MOVE_TARGET_USER_OR_SELECTED | MOVE_TARGET_USER)) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (gActiveBattler << 8)); + if (GetBattlerMoveTargetType(battler, move) & (MOVE_TARGET_USER_OR_SELECTED | MOVE_TARGET_USER)) + BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (battler << 8)); else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { do { target = GetBattlerAtPosition(Random() & 2); - } while (!CanTargetBattler(gActiveBattler, target, move)); + } while (!CanTargetBattler(battler, target, move)); #if B_WILD_NATURAL_ENEMIES == TRUE // Don't bother to loop through table if the move can't attack ally @@ -602,8 +602,8 @@ static void OpponentHandleChooseMove(void) {SPECIES_SABLEYE, SPECIES_CARBINK}, {SPECIES_MAREANIE, SPECIES_CORSOLA}, }; - speciesAttacker = gBattleMons[gActiveBattler].species; - speciesTarget = gBattleMons[GetBattlerAtPosition(BATTLE_PARTNER(gActiveBattler))].species; + speciesAttacker = gBattleMons[battler].species; + speciesTarget = gBattleMons[GetBattlerAtPosition(BATTLE_PARTNER(battler))].species; for (i = 0; i < ARRAY_COUNT(naturalEnemies); i++) { @@ -613,8 +613,8 @@ static void OpponentHandleChooseMove(void) break; } } - if (isPartnerEnemy && CanTargetBattler(gActiveBattler, target, move)) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(gActiveBattler)) << 8)); + if (isPartnerEnemy && CanTargetBattler(battler, target, move)) + BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8)); else BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (target << 8)); } @@ -625,28 +625,28 @@ static void OpponentHandleChooseMove(void) else BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8)); - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } } -static void OpponentHandleChooseItem(void) +static void OpponentHandleChooseItem(u32 battler) { - BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[gActiveBattler]); - OpponentBufferExecCompleted(); + BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[battler]); + OpponentBufferExecCompleted(battler); } -static void OpponentHandleChoosePokemon(void) +static void OpponentHandleChoosePokemon(u32 battler) { s32 chosenMonId; s32 pokemonInBattle = 1; // Choosing Revival Blessing target - if ((gBattleResources->bufferA[gActiveBattler][1] & 0xF) == PARTY_ACTION_CHOOSE_FAINTED_MON) + if ((gBattleResources->bufferA[battler][1] & 0xF) == PARTY_ACTION_CHOOSE_FAINTED_MON) { - chosenMonId = gSelectedMonPartyId = GetFirstFaintedPartyIndex(gActiveBattler); + chosenMonId = gSelectedMonPartyId = GetFirstFaintedPartyIndex(battler); } // Switching out - else if (*(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) == PARTY_SIZE) + else if (*(gBattleStruct->AI_monToSwitchIntoId + battler) == PARTY_SIZE) { chosenMonId = GetMostSuitableMonToSwitchInto(); @@ -666,7 +666,7 @@ static void OpponentHandleChoosePokemon(void) } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); for (chosenMonId = (lastId-1); chosenMonId >= firstId; chosenMonId--) { @@ -681,16 +681,16 @@ static void OpponentHandleChoosePokemon(void) } } } - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = chosenMonId; + *(gBattleStruct->monToSwitchIntoId + battler) = chosenMonId; } else { - chosenMonId = *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler); - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = chosenMonId; + chosenMonId = *(gBattleStruct->AI_monToSwitchIntoId + battler); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = PARTY_SIZE; + *(gBattleStruct->monToSwitchIntoId + battler) = chosenMonId; } BtlController_EmitChosenMonReturnValue(BUFFER_B, chosenMonId, NULL); - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } @@ -701,9 +701,7 @@ static u8 CountAIAliveNonEggMonsExcept(u8 slotToIgnore) for (i = 0, count = 0; i < PARTY_SIZE; i++) { if (i != slotToIgnore - && GetMonData(&gEnemyParty[i], MON_DATA_SPECIES) != SPECIES_NONE - && !GetMonData(&gEnemyParty[i], MON_DATA_IS_EGG) - && GetMonData(&gEnemyParty[i], MON_DATA_HP) != 0) + && IsValidForBattle(&gEnemyParty[i])) { count++; } @@ -712,27 +710,27 @@ static u8 CountAIAliveNonEggMonsExcept(u8 slotToIgnore) return count; } -static void OpponentHandleHealthBarUpdate(void) +static void OpponentHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, FALSE); + BtlController_HandleHealthBarUpdate(battler, FALSE); } -static void OpponentHandleIntroTrainerBallThrow(void) +static void OpponentHandleIntroTrainerBallThrow(u32 battler) { - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void OpponentHandleDrawPartyStatusSummary(void) +static void OpponentHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_OPPONENT, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void OpponentHandleBattleAnimation(void) +static void OpponentHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, FALSE); + BtlController_HandleBattleAnimation(battler, FALSE, FALSE); } -static void OpponentHandleEndLinkBattle(void) +static void OpponentHandleEndLinkBattle(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK && !(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)) { @@ -740,5 +738,5 @@ static void OpponentHandleEndLinkBattle(void) gMain.callback1 = gPreBattleCallback1; SetMainCallback2(gMain.savedCallback); } - OpponentBufferExecCompleted(); + OpponentBufferExecCompleted(battler); } diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index e944721e6..591b776fb 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -37,67 +37,63 @@ #include "constants/trainers.h" #include "constants/rgb.h" -static void PlayerBufferExecCompleted(void); -static void PlayerHandleLoadMonSprite(void); -static void PlayerHandleSwitchInAnim(void); -static void PlayerHandleDrawTrainerPic(void); -static void PlayerHandleTrainerSlide(void); -static void PlayerHandleTrainerSlideBack(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 PlayerHandleYesNoBox(void); -static void PlayerHandleChooseMove(void); -static void PlayerHandleChooseItem(void); -static void PlayerHandleChoosePokemon(void); -static void PlayerHandleCmd23(void); -static void PlayerHandleHealthBarUpdate(void); -static void PlayerHandleStatusXor(void); -static void PlayerHandleDMA3Transfer(void); -static void PlayerHandlePlayBGM(void); -static void PlayerHandleTwoReturnValues(void); -static void PlayerHandleChosenMonReturnValue(void); -static void PlayerHandleOneReturnValue(void); -static void PlayerHandleOneReturnValue_Duplicate(void); -static void PlayerHandleIntroTrainerBallThrow(void); -static void PlayerHandleDrawPartyStatusSummary(void); -static void PlayerHandleEndBounceEffect(void); -static void PlayerHandleBattleAnimation(void); -static void PlayerHandleLinkStandbyMsg(void); -static void PlayerHandleResetActionMoveSelection(void); -static void PlayerHandleEndLinkBattle(void); -static void PlayerHandleBattleDebug(void); +static void PlayerBufferExecCompleted(u32 battler); +static void PlayerHandleLoadMonSprite(u32 battler); +static void PlayerHandleSwitchInAnim(u32 battler); +static void PlayerHandleDrawTrainerPic(u32 battler); +static void PlayerHandleTrainerSlide(u32 battler); +static void PlayerHandleTrainerSlideBack(u32 battler); +static void PlayerHandlePaletteFade(u32 battler); +static void PlayerHandleSuccessBallThrowAnim(u32 battler); +static void PlayerHandleBallThrowAnim(u32 battler); +static void PlayerHandlePause(u32 battler); +static void PlayerHandleMoveAnimation(u32 battler); +static void PlayerHandlePrintString(u32 battler); +static void PlayerHandlePrintSelectionString(u32 battler); +static void PlayerHandleChooseAction(u32 battler); +static void PlayerHandleYesNoBox(u32 battler); +static void PlayerHandleChooseMove(u32 battler); +static void PlayerHandleChooseItem(u32 battler); +static void PlayerHandleChoosePokemon(u32 battler); +static void PlayerHandleCmd23(u32 battler); +static void PlayerHandleHealthBarUpdate(u32 battler); +static void PlayerHandleStatusXor(u32 battler); +static void PlayerHandleDMA3Transfer(u32 battler); +static void PlayerHandlePlayBGM(u32 battler); +static void PlayerHandleTwoReturnValues(u32 battler); +static void PlayerHandleChosenMonReturnValue(u32 battler); +static void PlayerHandleOneReturnValue(u32 battler); +static void PlayerHandleOneReturnValue_Duplicate(u32 battler); +static void PlayerHandleIntroTrainerBallThrow(u32 battler); +static void PlayerHandleDrawPartyStatusSummary(u32 battler); +static void PlayerHandleEndBounceEffect(u32 battler); +static void PlayerHandleBattleAnimation(u32 battler); +static void PlayerHandleLinkStandbyMsg(u32 battler); +static void PlayerHandleResetActionMoveSelection(u32 battler); +static void PlayerHandleEndLinkBattle(u32 battler); +static void PlayerHandleBattleDebug(u32 battler); -static void PlayerBufferRunCommand(void); -static void HandleInputChooseTarget(void); -static void HandleInputChooseMove(void); -static void MoveSelectionDisplayPpNumber(void); -static void MoveSelectionDisplayPpString(void); -static void MoveSelectionDisplayMoveType(void); -static void MoveSelectionDisplayMoveNames(void); -static void HandleMoveSwitching(void); -static void SwitchIn_HandleSoundAndEnd(void); -static void WaitForMonSelection(void); -static void CompleteWhenChoseItem(void); +static void PlayerBufferRunCommand(u32 battler); +static void HandleInputChooseTarget(u32 battler); +static void HandleInputChooseMove(u32 battler); +static void MoveSelectionDisplayPpNumber(u32 battler); +static void MoveSelectionDisplayPpString(u32 battler); +static void MoveSelectionDisplayMoveType(u32 battler); +static void MoveSelectionDisplayMoveNames(u32 battler); +static void HandleMoveSwitching(u32 battler); +static void SwitchIn_HandleSoundAndEnd(u32 battler); +static void WaitForMonSelection(u32 battler); +static void CompleteWhenChoseItem(u32 battler); static void Task_LaunchLvlUpAnim(u8); static void Task_PrepareToGiveExpWithExpBar(u8); static void Task_SetControllerToWaitForString(u8); static void Task_GiveExpWithExpBar(u8); static void Task_UpdateLvlInHealthbox(u8); static void PrintLinkStandbyMsg(void); -static u32 CopyPlayerMonData(u8, u8 *); -static void SetPlayerMonData(u8); -static void PlayerDoMoveAnimation(void); -static void Task_StartSendOutAnim(u8); -static void ReloadMoveNames(void); +static void ReloadMoveNames(u32 battler); -static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -159,57 +155,53 @@ static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void BattleControllerDummy(void) +void SetControllerToPlayer(u32 battler) { -} - -void SetControllerToPlayer(void) -{ - gBattlerControllerEndFuncs[gActiveBattler] = PlayerBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand; + gBattlerControllerEndFuncs[battler] = PlayerBufferExecCompleted; + gBattlerControllerFuncs[battler] = PlayerBufferRunCommand; gDoingBattleAnim = FALSE; gPlayerDpadHoldFrames = 0; } -static void PlayerBufferExecCompleted(void) +static void PlayerBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand; + gBattlerControllerFuncs[battler] = PlayerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void PlayerBufferRunCommand(void) +static void PlayerBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sPlayerBufferCommands)) - sPlayerBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sPlayerBufferCommands)) + sPlayerBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void CompleteOnBattlerSpritePosX_0(void) +static void CompleteOnBattlerSpritePosX_0(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) - PlayerBufferExecCompleted(); + if (gSprites[gBattlerSpriteIds[battler]].x2 == 0) + PlayerBufferExecCompleted(battler); } -static void HandleInputChooseAction(void) +static void HandleInputChooseAction(u32 battler) { - u16 itemId = gBattleResources->bufferA[gActiveBattler][2] | (gBattleResources->bufferA[gActiveBattler][3] << 8); + u16 itemId = gBattleResources->bufferA[battler][2] | (gBattleResources->bufferA[battler][3] << 8); - DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); - DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(battler, BOUNCE_MON, 7, 1); if (JOY_REPEAT(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -221,7 +213,7 @@ static void HandleInputChooseAction(void) PlaySE(SE_SELECT); TryHideLastUsedBall(); - switch (gActionSelectionCursor[gActiveBattler]) + switch (gActionSelectionCursor[battler]) { case 0: // Top left BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); @@ -236,63 +228,63 @@ static void HandleInputChooseAction(void) BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_RUN, 0); break; } - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } else if (JOY_NEW(DPAD_LEFT)) { - if (gActionSelectionCursor[gActiveBattler] & 1) // if is B_ACTION_USE_ITEM or B_ACTION_RUN + if (gActionSelectionCursor[battler] & 1) // if is B_ACTION_USE_ITEM or B_ACTION_RUN { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 1; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_RIGHT)) { - if (!(gActionSelectionCursor[gActiveBattler] & 1)) // if is B_ACTION_USE_MOVE or B_ACTION_SWITCH + if (!(gActionSelectionCursor[battler] & 1)) // if is B_ACTION_USE_MOVE or B_ACTION_SWITCH { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 1; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_UP)) { - if (gActionSelectionCursor[gActiveBattler] & 2) // if is B_ACTION_SWITCH or B_ACTION_RUN + if (gActionSelectionCursor[battler] & 2) // if is B_ACTION_SWITCH or B_ACTION_RUN { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 2; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_DOWN)) { - if (!(gActionSelectionCursor[gActiveBattler] & 2)) // if is B_ACTION_USE_MOVE or B_ACTION_USE_ITEM + if (!(gActionSelectionCursor[battler] & 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); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(B_BUTTON) || gPlayerDpadHoldFrames > 59) { if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) - && GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_RIGHT + && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT && !(gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)]) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { // Return item to bag if partner had selected one. - if (gBattleResources->bufferA[gActiveBattler][1] == B_ACTION_USE_ITEM) + if (gBattleResources->bufferA[battler][1] == B_ACTION_USE_ITEM) { AddBagItem(itemId, 1); } PlaySE(SE_SELECT); BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_CANCEL_PARTNER, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } else if (JOY_NEW(START_BUTTON)) @@ -303,7 +295,7 @@ static void HandleInputChooseAction(void) else if (JOY_NEW(SELECT_BUTTON)) { BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_DEBUG, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } #endif #if B_LAST_USED_BALL == TRUE @@ -312,17 +304,17 @@ static void HandleInputChooseAction(void) PlaySE(SE_SELECT); TryHideLastUsedBall(); BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_THROW_BALL, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } #endif } -static void HandleInputChooseTarget(void) +static void HandleInputChooseTarget(u32 battler) { s32 i; static const u8 identities[MAX_BATTLERS_COUNT] = {B_POSITION_PLAYER_LEFT, B_POSITION_PLAYER_RIGHT, B_POSITION_OPPONENT_RIGHT, B_POSITION_OPPONENT_LEFT}; - u16 move = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBattler]); - u16 moveTarget = GetBattlerMoveTargetType(gActiveBattler, move); + u16 move = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + gMoveSelectionCursor[battler]); + u16 moveTarget = GetBattlerMoveTargetType(battler, move); DoBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX, 15, 1); for (i = 0; i < gBattlersCount; i++) @@ -341,21 +333,21 @@ static void HandleInputChooseTarget(void) PlaySE(SE_SELECT); gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget; if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX); TryHideLastUsedBall(); HideTriggerSprites(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } else if (JOY_NEW(B_BUTTON) || gPlayerDpadHoldFrames > 59) { PlaySE(SE_SELECT); gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget; - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; - DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); - DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + gBattlerControllerFuncs[battler] = HandleInputChooseMove; + DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(battler, BOUNCE_MON, 7, 1); EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX); } else if (JOY_NEW(DPAD_LEFT | DPAD_UP)) @@ -390,7 +382,7 @@ static void HandleInputChooseTarget(void) { case B_POSITION_PLAYER_LEFT: case B_POSITION_PLAYER_RIGHT: - if (gActiveBattler != gMultiUsePlayerCursor) + if (battler != gMultiUsePlayerCursor) i++; else if (moveTarget & MOVE_TARGET_USER_OR_SELECTED) i++; @@ -402,7 +394,7 @@ static void HandleInputChooseTarget(void) } if (gAbsentBattlerFlags & gBitTable[gMultiUsePlayerCursor] - || !CanTargetBattler(gActiveBattler, gMultiUsePlayerCursor, move)) + || !CanTargetBattler(battler, gMultiUsePlayerCursor, move)) i = 0; } while (i == 0); } @@ -440,7 +432,7 @@ static void HandleInputChooseTarget(void) { case B_POSITION_PLAYER_LEFT: case B_POSITION_PLAYER_RIGHT: - if (gActiveBattler != gMultiUsePlayerCursor) + if (battler != gMultiUsePlayerCursor) i++; else if (moveTarget & MOVE_TARGET_USER_OR_SELECTED) i++; @@ -452,7 +444,7 @@ static void HandleInputChooseTarget(void) } if (gAbsentBattlerFlags & gBitTable[gMultiUsePlayerCursor] - || !CanTargetBattler(gActiveBattler, gMultiUsePlayerCursor, move)) + || !CanTargetBattler(battler, gMultiUsePlayerCursor, move)) i = 0; } while (i == 0); } @@ -474,12 +466,12 @@ static void HideAllTargets(void) } } -static void HideShownTargets(void) +static void HideShownTargets(u32 battler) { s32 i; for (i = 0; i < MAX_BATTLERS_COUNT; i++) { - if (IsBattlerAlive(i) && gBattleSpritesDataPtr->healthBoxesData[i].healthboxIsBouncing && i != gActiveBattler) + if (IsBattlerAlive(i) && gBattleSpritesDataPtr->healthBoxesData[i].healthboxIsBouncing && i != battler) { gSprites[gBattlerSpriteIds[i]].callback = SpriteCB_HideAsMoveTarget; EndBounceEffect(i, BOUNCE_HEALTHBOX); @@ -487,7 +479,7 @@ static void HideShownTargets(void) } } -static void HandleInputShowEntireFieldTargets(void) +static void HandleInputShowEntireFieldTargets(u32 battler) { if (JOY_HELD(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -499,23 +491,23 @@ static void HandleInputShowEntireFieldTargets(void) PlaySE(SE_SELECT); HideAllTargets(); if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideMegaTriggerSprite(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } else if (JOY_NEW(B_BUTTON) || gPlayerDpadHoldFrames > 59) { PlaySE(SE_SELECT); HideAllTargets(); - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; - DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); - DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + gBattlerControllerFuncs[battler] = HandleInputChooseMove; + DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(battler, BOUNCE_MON, 7, 1); } } -static void HandleInputShowTargets(void) +static void HandleInputShowTargets(u32 battler) { if (JOY_HELD(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -525,22 +517,22 @@ static void HandleInputShowTargets(void) if (JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - HideShownTargets(); + HideShownTargets(battler); if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideTriggerSprites(); TryHideLastUsedBall(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } else if (JOY_NEW(B_BUTTON) || gPlayerDpadHoldFrames > 59) { PlaySE(SE_SELECT); - HideShownTargets(); - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; - DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1); - DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1); + HideShownTargets(battler); + gBattlerControllerFuncs[battler] = HandleInputChooseMove; + DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1); + DoBounceEffect(battler, BOUNCE_MON, 7, 1); } } @@ -553,11 +545,11 @@ static void TryShowAsTarget(u32 battlerId) } } -static void HandleInputChooseMove(void) +static void HandleInputChooseMove(u32 battler) { u16 moveTarget; u32 canSelectTarget = 0; - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); if (JOY_HELD(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -567,7 +559,7 @@ static void HandleInputChooseMove(void) if (JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - if (moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] == MOVE_CURSE) + if (moveInfo->moves[gMoveSelectionCursor[battler]] == MOVE_CURSE) { if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST && moveInfo->monType3 != TYPE_GHOST) moveTarget = MOVE_TARGET_USER; @@ -576,43 +568,43 @@ static void HandleInputChooseMove(void) } else { - moveTarget = GetBattlerMoveTargetType(gActiveBattler, moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]); + moveTarget = GetBattlerMoveTargetType(battler, moveInfo->moves[gMoveSelectionCursor[battler]]); } if (gBattleStruct->zmove.viewing) { - u16 chosenMove = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]; + u16 chosenMove = moveInfo->moves[gMoveSelectionCursor[battler]]; - QueueZMove(gActiveBattler, chosenMove); + QueueZMove(battler, chosenMove); gBattleStruct->zmove.viewing = FALSE; - if (gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].split != SPLIT_STATUS) + if (gBattleMoves[moveInfo->moves[gMoveSelectionCursor[battler]]].split != SPLIT_STATUS) moveTarget = MOVE_TARGET_SELECTED; //damaging z moves always have selected target } if (moveTarget & MOVE_TARGET_USER) - gMultiUsePlayerCursor = gActiveBattler; + gMultiUsePlayerCursor = battler; else - gMultiUsePlayerCursor = GetBattlerAtPosition(BATTLE_OPPOSITE(GET_BATTLER_SIDE(gActiveBattler))); + gMultiUsePlayerCursor = GetBattlerAtPosition(BATTLE_OPPOSITE(GET_BATTLER_SIDE(battler))); - if (!gBattleResources->bufferA[gActiveBattler][1]) // not a double battle + if (!gBattleResources->bufferA[battler][1]) // not a double battle { - if (moveTarget & MOVE_TARGET_USER_OR_SELECTED && !gBattleResources->bufferA[gActiveBattler][2]) + if (moveTarget & MOVE_TARGET_USER_OR_SELECTED && !gBattleResources->bufferA[battler][2]) canSelectTarget = 1; } 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 | MOVE_TARGET_ALLY))) canSelectTarget = 1; // either selected or user - if (moveTarget == (MOVE_TARGET_USER | MOVE_TARGET_ALLY) && IsBattlerAlive(BATTLE_PARTNER(gActiveBattler))) + if (moveTarget == (MOVE_TARGET_USER | MOVE_TARGET_ALLY) && IsBattlerAlive(BATTLE_PARTNER(battler))) canSelectTarget = 1; - if (moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] == 0) + if (moveInfo->currentPp[gMoveSelectionCursor[battler]] == 0) { canSelectTarget = 0; } else if (!(moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) <= 1) { - gMultiUsePlayerCursor = GetDefaultMoveTarget(gActiveBattler); + gMultiUsePlayerCursor = GetDefaultMoveTarget(battler); canSelectTarget = 0; } @@ -631,7 +623,7 @@ static void HandleInputChooseMove(void) TryShowAsTarget(gMultiUsePlayerCursor); TryShowAsTarget(BATTLE_PARTNER(gMultiUsePlayerCursor)); if (moveTarget & MOVE_TARGET_FOES_AND_ALLY) - TryShowAsTarget(BATTLE_PARTNER(gActiveBattler)); + TryShowAsTarget(BATTLE_PARTNER(battler)); canSelectTarget = 2; } #endif @@ -642,18 +634,18 @@ static void HandleInputChooseMove(void) case 0: default: if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideTriggerSprites(); TryHideLastUsedBall(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); break; case 1: - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseTarget; + gBattlerControllerFuncs[battler] = HandleInputChooseTarget; if (moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) - gMultiUsePlayerCursor = gActiveBattler; + gMultiUsePlayerCursor = battler; else if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)]) gMultiUsePlayerCursor = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); else @@ -662,10 +654,10 @@ static void HandleInputChooseMove(void) gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_ShowAsMoveTarget; break; case 2: - gBattlerControllerFuncs[gActiveBattler] = HandleInputShowTargets; + gBattlerControllerFuncs[battler] = HandleInputShowTargets; break; case 3: // Entire field - gBattlerControllerFuncs[gActiveBattler] = HandleInputShowEntireFieldTargets; + gBattlerControllerFuncs[battler] = HandleInputShowEntireFieldTargets; break; } } @@ -674,7 +666,7 @@ static void HandleInputChooseMove(void) PlaySE(SE_SELECT); if (gBattleStruct->zmove.viewing) { - ReloadMoveNames(); + ReloadMoveNames(battler); } else { @@ -682,82 +674,82 @@ static void HandleInputChooseMove(void) gBattleStruct->zmove.viable = FALSE; BtlController_EmitTwoReturnValues(BUFFER_B, 10, 0xFFFF); HideTriggerSprites(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } else if (JOY_NEW(DPAD_LEFT) && !gBattleStruct->zmove.viewing) { - if (gMoveSelectionCursor[gActiveBattler] & 1) + if (gMoveSelectionCursor[battler] & 1) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 1; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 1; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); - TryChangeZIndicator(gActiveBattler, gMoveSelectionCursor[gActiveBattler]); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); + TryChangeZIndicator(battler, gMoveSelectionCursor[battler]); } } else if (JOY_NEW(DPAD_RIGHT) && !gBattleStruct->zmove.viewing) { - if (!(gMoveSelectionCursor[gActiveBattler] & 1) - && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose) + if (!(gMoveSelectionCursor[battler] & 1) + && (gMoveSelectionCursor[battler] ^ 1) < gNumberOfMovesToChoose) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 1; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 1; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); - TryChangeZIndicator(gActiveBattler, gMoveSelectionCursor[gActiveBattler]); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); + TryChangeZIndicator(battler, gMoveSelectionCursor[battler]); } } else if (JOY_NEW(DPAD_UP) && !gBattleStruct->zmove.viewing) { - if (gMoveSelectionCursor[gActiveBattler] & 2) + if (gMoveSelectionCursor[battler] & 2) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 2; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 2; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); - TryChangeZIndicator(gActiveBattler, gMoveSelectionCursor[gActiveBattler]); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); + TryChangeZIndicator(battler, gMoveSelectionCursor[battler]); } } else if (JOY_NEW(DPAD_DOWN) && !gBattleStruct->zmove.viewing) { - if (!(gMoveSelectionCursor[gActiveBattler] & 2) - && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose) + if (!(gMoveSelectionCursor[battler] & 2) + && (gMoveSelectionCursor[battler] ^ 2) < gNumberOfMovesToChoose) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 2; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 2; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); - TryChangeZIndicator(gActiveBattler, gMoveSelectionCursor[gActiveBattler]); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); + TryChangeZIndicator(battler, gMoveSelectionCursor[battler]); } } else if (JOY_NEW(SELECT_BUTTON) && !gBattleStruct->zmove.viewing) { if (gNumberOfMovesToChoose > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) { - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29); - if (gMoveSelectionCursor[gActiveBattler] != 0) + if (gMoveSelectionCursor[battler] != 0) gMultiUsePlayerCursor = 0; else - gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBattler] + 1; + gMultiUsePlayerCursor = gMoveSelectionCursor[battler] + 1; MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); BattlePutTextOnWindow(gText_BattleSwitchWhich, B_WIN_SWITCH_PROMPT); - gBattlerControllerFuncs[gActiveBattler] = HandleMoveSwitching; + gBattlerControllerFuncs[battler] = HandleMoveSwitching; } } else if (JOY_NEW(START_BUTTON)) { - if (CanMegaEvolve(gActiveBattler)) + if (CanMegaEvolve(battler)) { gBattleStruct->mega.playerSelect ^= 1; ChangeMegaTriggerSprite(gBattleStruct->mega.triggerSpriteId, gBattleStruct->mega.playerSelect); @@ -771,23 +763,23 @@ static void HandleInputChooseMove(void) if (!gBattleStruct->zmove.viewing) MoveSelectionDisplayZMove(gBattleStruct->zmove.chosenZMove); else - ReloadMoveNames(); + ReloadMoveNames(battler); } } } -static void ReloadMoveNames(void) +static void ReloadMoveNames(u32 battler) { gBattleStruct->mega.playerSelect = FALSE; gBattleStruct->zmove.viewing = FALSE; - MoveSelectionDestroyCursorAt(0); - MoveSelectionDisplayMoveNames(); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); + MoveSelectionDestroyCursorAt(battler); + MoveSelectionDisplayMoveNames(battler); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); } -static u32 HandleMoveInputUnused(void) +static u32 HandleMoveInputUnused(u32 battler) { u32 var = 0; @@ -803,41 +795,41 @@ static u32 HandleMoveInputUnused(void) gBattle_BG0_Y = DISPLAY_HEIGHT * 2; var = 0xFF; } - if (JOY_NEW(DPAD_LEFT) && gMoveSelectionCursor[gActiveBattler] & 1) + if (JOY_NEW(DPAD_LEFT) && gMoveSelectionCursor[battler] & 1) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 1; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 1; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); } - if (JOY_NEW(DPAD_RIGHT) && !(gMoveSelectionCursor[gActiveBattler] & 1) - && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose) + if (JOY_NEW(DPAD_RIGHT) && !(gMoveSelectionCursor[battler] & 1) + && (gMoveSelectionCursor[battler] ^ 1) < gNumberOfMovesToChoose) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 1; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 1; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); } - if (JOY_NEW(DPAD_UP) && gMoveSelectionCursor[gActiveBattler] & 2) + if (JOY_NEW(DPAD_UP) && gMoveSelectionCursor[battler] & 2) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 2; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 2; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); } - if (JOY_NEW(DPAD_DOWN) && !(gMoveSelectionCursor[gActiveBattler] & 2) - && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose) + if (JOY_NEW(DPAD_DOWN) && !(gMoveSelectionCursor[battler] & 2) + && (gMoveSelectionCursor[battler] ^ 2) < gNumberOfMovesToChoose) { - MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]); - gMoveSelectionCursor[gActiveBattler] ^= 2; + MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]); + gMoveSelectionCursor[battler] ^= 2; PlaySE(SE_SELECT); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); } return var; } -static void HandleMoveSwitching(void) +static void HandleMoveSwitching(u32 battler) { u8 perMovePPBonuses[MAX_MON_MOVES]; struct ChooseMoveStruct moveStruct; @@ -845,76 +837,76 @@ static void HandleMoveSwitching(void) if (JOY_NEW(A_BUTTON | SELECT_BUTTON)) { - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); PlaySE(SE_SELECT); - if (gMoveSelectionCursor[gActiveBattler] != gMultiUsePlayerCursor) + if (gMoveSelectionCursor[battler] != gMultiUsePlayerCursor) { - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); s32 i; // swap moves and pp - i = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]; - moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] = moveInfo->moves[gMultiUsePlayerCursor]; + i = moveInfo->moves[gMoveSelectionCursor[battler]]; + moveInfo->moves[gMoveSelectionCursor[battler]] = moveInfo->moves[gMultiUsePlayerCursor]; moveInfo->moves[gMultiUsePlayerCursor] = i; - i = moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]]; - moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->currentPp[gMultiUsePlayerCursor]; + i = moveInfo->currentPp[gMoveSelectionCursor[battler]]; + moveInfo->currentPp[gMoveSelectionCursor[battler]] = moveInfo->currentPp[gMultiUsePlayerCursor]; moveInfo->currentPp[gMultiUsePlayerCursor] = i; - i = moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]]; - moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->maxPp[gMultiUsePlayerCursor]; + i = moveInfo->maxPp[gMoveSelectionCursor[battler]]; + moveInfo->maxPp[gMoveSelectionCursor[battler]] = moveInfo->maxPp[gMultiUsePlayerCursor]; moveInfo->maxPp[gMultiUsePlayerCursor] = i; - if (gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[gMoveSelectionCursor[gActiveBattler]]) + if (gDisableStructs[battler].mimickedMoves & gBitTable[gMoveSelectionCursor[battler]]) { - gDisableStructs[gActiveBattler].mimickedMoves &= (~gBitTable[gMoveSelectionCursor[gActiveBattler]]); - gDisableStructs[gActiveBattler].mimickedMoves |= gBitTable[gMultiUsePlayerCursor]; + gDisableStructs[battler].mimickedMoves &= (~gBitTable[gMoveSelectionCursor[battler]]); + gDisableStructs[battler].mimickedMoves |= gBitTable[gMultiUsePlayerCursor]; } - MoveSelectionDisplayMoveNames(); + MoveSelectionDisplayMoveNames(battler); for (i = 0; i < MAX_MON_MOVES; i++) - perMovePPBonuses[i] = (gBattleMons[gActiveBattler].ppBonuses & (3 << (i * 2))) >> (i * 2); + perMovePPBonuses[i] = (gBattleMons[battler].ppBonuses & (3 << (i * 2))) >> (i * 2); - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor]; + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[battler]]; + perMovePPBonuses[gMoveSelectionCursor[battler]] = perMovePPBonuses[gMultiUsePlayerCursor]; perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; totalPPBonuses = 0; for (i = 0; i < MAX_MON_MOVES; i++) totalPPBonuses |= perMovePPBonuses[i] << (i * 2); - gBattleMons[gActiveBattler].ppBonuses = totalPPBonuses; + gBattleMons[battler].ppBonuses = totalPPBonuses; for (i = 0; i < MAX_MON_MOVES; i++) { - gBattleMons[gActiveBattler].moves[i] = moveInfo->moves[i]; - gBattleMons[gActiveBattler].pp[i] = moveInfo->currentPp[i]; + gBattleMons[battler].moves[i] = moveInfo->moves[i]; + gBattleMons[battler].pp[i] = moveInfo->currentPp[i]; } - if (!(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED)) + if (!(gBattleMons[battler].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); + moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + i); + moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + i); } - totalPPBonuses = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES); + totalPPBonuses = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], 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]; + i = moveStruct.moves[gMoveSelectionCursor[battler]]; + moveStruct.moves[gMoveSelectionCursor[battler]] = moveStruct.moves[gMultiUsePlayerCursor]; moveStruct.moves[gMultiUsePlayerCursor] = i; - i = moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]]; - moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]] = moveStruct.currentPp[gMultiUsePlayerCursor]; + i = moveStruct.currentPp[gMoveSelectionCursor[battler]]; + moveStruct.currentPp[gMoveSelectionCursor[battler]] = moveStruct.currentPp[gMultiUsePlayerCursor]; moveStruct.currentPp[gMultiUsePlayerCursor] = i; - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor]; + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[battler]]; + perMovePPBonuses[gMoveSelectionCursor[battler]] = perMovePPBonuses[gMultiUsePlayerCursor]; perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses; totalPPBonuses = 0; @@ -923,45 +915,45 @@ static void HandleMoveSwitching(void) 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[battler]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]); + SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]); } - SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES, &totalPPBonuses); + SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP_BONUSES, &totalPPBonuses); } } - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; - gMoveSelectionCursor[gActiveBattler] = gMultiUsePlayerCursor; - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpString(); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); - GetUsableZMoves(gActiveBattler, moveInfo->moves); + gBattlerControllerFuncs[battler] = HandleInputChooseMove; + gMoveSelectionCursor[battler] = gMultiUsePlayerCursor; + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpString(battler); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); + GetUsableZMoves(battler, moveInfo->moves); } else if (JOY_NEW(B_BUTTON | SELECT_BUTTON)) { PlaySE(SE_SELECT); MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; - MoveSelectionDisplayPpString(); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + gBattlerControllerFuncs[battler] = HandleInputChooseMove; + MoveSelectionDisplayPpString(battler); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); } else if (JOY_NEW(DPAD_LEFT)) { if (gMultiUsePlayerCursor & 1) { - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29); else MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); gMultiUsePlayerCursor ^= 1; PlaySE(SE_SELECT); - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); else MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); @@ -971,15 +963,15 @@ static void HandleMoveSwitching(void) { if (!(gMultiUsePlayerCursor & 1) && (gMultiUsePlayerCursor ^ 1) < gNumberOfMovesToChoose) { - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29); else MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); gMultiUsePlayerCursor ^= 1; PlaySE(SE_SELECT); - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); else MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); @@ -989,15 +981,15 @@ static void HandleMoveSwitching(void) { if (gMultiUsePlayerCursor & 2) { - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29); else MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); gMultiUsePlayerCursor ^= 2; PlaySE(SE_SELECT); - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); else MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); @@ -1007,15 +999,15 @@ static void HandleMoveSwitching(void) { if (!(gMultiUsePlayerCursor & 2) && (gMultiUsePlayerCursor ^ 2) < gNumberOfMovesToChoose) { - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29); + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29); else MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor); gMultiUsePlayerCursor ^= 2; PlaySE(SE_SELECT); - if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler]) + if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler]) MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0); else MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27); @@ -1023,7 +1015,7 @@ static void HandleMoveSwitching(void) } } -static void SetLinkBattleEndCallbacks(void) +static void SetLinkBattleEndCallbacks(u32 battler) { if (gWirelessCommType == 0) { @@ -1054,7 +1046,7 @@ static void SetLinkBattleEndCallbacks(void) } // Despite handling link battles separately, this is only ever used by link battles -void SetBattleEndCallbacks(void) +void SetBattleEndCallbacks(u32 battler) { if (!gPaletteFade.active) { @@ -1067,7 +1059,7 @@ void SetBattleEndCallbacks(void) else SetLinkStandbyCallback(); - gBattlerControllerFuncs[gActiveBattler] = SetLinkBattleEndCallbacks; + gBattlerControllerFuncs[battler] = SetLinkBattleEndCallbacks; } } else @@ -1080,120 +1072,120 @@ void SetBattleEndCallbacks(void) } } -static void Intro_DelayAndEnd(void) +static void Intro_DelayAndEnd(u32 battler) { - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - PlayerBufferExecCompleted(); + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + PlayerBufferExecCompleted(battler); } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool8 healthboxAnimDone = FALSE; // Check if healthbox has finished sliding in - if (TwoPlayerIntroMons(gActiveBattler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + if (TwoPlayerIntroMons(battler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; } // If healthbox and shiny anim are done - if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { // Reset shiny anim (even if it didn't occur) - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); - if (TwoPlayerIntroMons(gActiveBattler)) - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], BATTLE_PARTNER(gActiveBattler)); + if (TwoPlayerIntroMons(battler)) + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], BATTLE_PARTNER(battler)); - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; // Start shiny animation if applicable for 1st pokemon - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); // Start shiny animation if applicable for 2nd pokemon - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) + TryShinyAnimation(BATTLE_PARTNER(battler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); // Show healthbox after ball anim - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted) { - if (TwoPlayerIntroMons(gActiveBattler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + if (TwoPlayerIntroMons(battler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = TRUE; } // Restore bgm after cry has played and healthbox anim is started - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].waitForCry - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].waitForCry + if (!gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry + && gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].waitForCry && !IsCryPlayingOrClearCrySongs()) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored) { if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) m4aMPlayContinue(&gMPlayInfo_BGM); else m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = TRUE; bgmRestored = TRUE; } // Wait for battler anims - if (TwoPlayerIntroMons(gActiveBattler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + if (TwoPlayerIntroMons(battler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } } else { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } @@ -1202,67 +1194,67 @@ static void Intro_TryShinyAnimShowHealthbox(void) // Clean up if (bgmRestored && battlerAnimsDone) { - if (TwoPlayerIntroMons(gActiveBattler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); + if (TwoPlayerIntroMons(battler) && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + DestroySprite(&gSprites[gBattleControllerData[battler]]); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } -static void SwitchIn_CleanShinyAnimShowSubstitute(void) +static void SwitchIn_CleanShinyAnimShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - CopyBattleSpriteInvisibility(gActiveBattler); + CopyBattleSpriteInvisibility(battler); // Reset shiny anim (even if it didn't occur) - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); // Check if Substitute should be shown - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_HandleSoundAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_HandleSoundAndEnd; } } -static void SwitchIn_HandleSoundAndEnd(void) +static void SwitchIn_HandleSoundAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - PlayerBufferExecCompleted(); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + PlayerBufferExecCompleted(battler); } } -static void SwitchIn_TryShinyAnimShowHealthbox(void) +static void SwitchIn_TryShinyAnimShowHealthbox(u32 battler) { // Start shiny animation if applicable - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); // Wait for ball anim, then show healthbox - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_CleanShinyAnimShowSubstitute; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + gBattlerControllerFuncs[battler] = SwitchIn_CleanShinyAnimShowSubstitute; } } @@ -1436,21 +1428,21 @@ static void Task_SetControllerToWaitForString(u8 taskId) DestroyTask(taskId); } -static void OpenPartyMenuToChooseMon(void) +static void OpenPartyMenuToChooseMon(u32 battler) { if (!gPaletteFade.active) { u8 caseId; - gBattlerControllerFuncs[gActiveBattler] = WaitForMonSelection; - caseId = gTasks[gBattleControllerData[gActiveBattler]].data[0]; - DestroyTask(gBattleControllerData[gActiveBattler]); + gBattlerControllerFuncs[battler] = WaitForMonSelection; + caseId = gTasks[gBattleControllerData[battler]].data[0]; + DestroyTask(gBattleControllerData[battler]); FreeAllWindowBuffers(); OpenPartyMenuInBattle(caseId); } } -static void WaitForMonSelection(void) +static void WaitForMonSelection(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -1459,34 +1451,34 @@ static void WaitForMonSelection(void) else BtlController_EmitChosenMonReturnValue(BUFFER_B, PARTY_SIZE, NULL); - if ((gBattleResources->bufferA[gActiveBattler][1] & 0xF) == 1) + if ((gBattleResources->bufferA[battler][1] & 0xF) == 1) PrintLinkStandbyMsg(); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void OpenBagAndChooseItem(void) +static void OpenBagAndChooseItem(u32 battler) { if (!gPaletteFade.active) { - gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChoseItem; + gBattlerControllerFuncs[battler] = CompleteWhenChoseItem; ReshowBattleScreenDummy(); FreeAllWindowBuffers(); CB2_BagMenuFromBattle(); } } -static void CompleteWhenChoseItem(void) +static void CompleteWhenChoseItem(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void PlayerHandleYesNoInput(void) +static void PlayerHandleYesNoInput(u32 battler) { if (JOY_NEW(DPAD_UP) && gMultiUsePlayerCursor != 0) { @@ -1512,20 +1504,20 @@ static void PlayerHandleYesNoInput(void) else BtlController_EmitTwoReturnValues(BUFFER_B, 0xD, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } if (JOY_NEW(B_BUTTON)) { HandleBattleWindow(YESNOBOX_X_Y, WINDOW_CLEAR); PlaySE(SE_SELECT); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void MoveSelectionDisplayMoveNames(void) +static void MoveSelectionDisplayMoveNames(u32 battler) { s32 i; - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); gNumberOfMovesToChoose = 0; for (i = 0; i < MAX_MON_MOVES; i++) @@ -1539,40 +1531,40 @@ static void MoveSelectionDisplayMoveNames(void) } } -static void MoveSelectionDisplayPpString(void) +static void MoveSelectionDisplayPpString(u32 battler) { StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP); } -static void MoveSelectionDisplayPpNumber(void) +static void MoveSelectionDisplayPpNumber(u32 battler) { u8 *txtPtr; struct ChooseMoveStruct *moveInfo; - if (gBattleResources->bufferA[gActiveBattler][2] == TRUE) // check if we didn't want to display pp number + if (gBattleResources->bufferA[battler][2] == TRUE) // check if we didn't want to display pp number return; SetPpNumbersPaletteInMoveSelection(); - moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); - txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2); + moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); + txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[battler]], STR_CONV_MODE_RIGHT_ALIGN, 2); *(txtPtr)++ = CHAR_SLASH; - ConvertIntToDecimalStringN(txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2); + ConvertIntToDecimalStringN(txtPtr, moveInfo->maxPp[gMoveSelectionCursor[battler]], STR_CONV_MODE_RIGHT_ALIGN, 2); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP_REMAINING); } -static void MoveSelectionDisplayMoveType(void) +static void MoveSelectionDisplayMoveType(u32 battler) { u8 *txtPtr; - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); txtPtr = StringCopy(gDisplayedStringBattle, gText_MoveInterfaceType); *(txtPtr)++ = EXT_CTRL_CODE_BEGIN; *(txtPtr)++ = EXT_CTRL_CODE_FONT; *(txtPtr)++ = FONT_NORMAL; - StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].type]); + StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[battler]]].type]); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MOVE_TYPE); } @@ -1636,18 +1628,18 @@ static void PrintLinkStandbyMsg(void) } } -static void PlayerHandleLoadMonSprite(void) +static void PlayerHandleLoadMonSprite(u32 battler) { - BattleLoadMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler; - gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpritePosX_0; + BattleLoadMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler; + gBattlerControllerFuncs[battler] = CompleteOnBattlerSpritePosX_0; } -static void PlayerHandleSwitchInAnim(void) +static void PlayerHandleSwitchInAnim(u32 battler) { - gActionSelectionCursor[gActiveBattler] = 0; - gMoveSelectionCursor[gActiveBattler] = 0; - BtlController_HandleSwitchInAnim(gActiveBattler, TRUE, SwitchIn_TryShinyAnimShowHealthbox); + gActionSelectionCursor[battler] = 0; + gMoveSelectionCursor[battler] = 0; + BtlController_HandleSwitchInAnim(battler, TRUE, SwitchIn_TryShinyAnimShowHealthbox); } u32 LinkPlayerGetTrainerPicId(u32 multiplayerId) @@ -1682,7 +1674,7 @@ static u32 PlayerGetTrainerBackPicId(void) // In emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) // that use an animated back pic. -static void PlayerHandleDrawTrainerPic(void) +static void PlayerHandleDrawTrainerPic(u32 battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -1691,7 +1683,7 @@ static void PlayerHandleDrawTrainerPic(void) trainerPicId = PlayerGetTrainerBackPicId(); if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right. + if ((GetBattlerPosition(battler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right. xPos = 90; else // First mon, on the left. xPos = 32; @@ -1724,79 +1716,79 @@ static void PlayerHandleDrawTrainerPic(void) isFrontPic = FALSE; } - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, isFrontPic, xPos, yPos, -1); + BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void PlayerHandleTrainerSlide(void) +static void PlayerHandleTrainerSlide(u32 battler) { u32 trainerPicId = PlayerGetTrainerBackPicId(); - BtlController_HandleTrainerSlide(gActiveBattler, trainerPicId); + BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void PlayerHandleTrainerSlideBack(void) +static void PlayerHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 50, TRUE); + BtlController_HandleTrainerSlideBack(battler, 50, TRUE); } -static void PlayerHandlePaletteFade(void) +static void PlayerHandlePaletteFade(u32 battler) { BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleSuccessBallThrowAnim(void) +static void PlayerHandleSuccessBallThrowAnim(u32 battler) { - BtlController_HandleSuccessBallThrowAnim(gActiveBattler, gBattlerTarget, B_ANIM_BALL_THROW, TRUE); + BtlController_HandleSuccessBallThrowAnim(battler, gBattlerTarget, B_ANIM_BALL_THROW, TRUE); } -static void PlayerHandleBallThrowAnim(void) +static void PlayerHandleBallThrowAnim(u32 battler) { - BtlController_HandleBallThrowAnim(gActiveBattler, gBattlerTarget, B_ANIM_BALL_THROW, TRUE); + BtlController_HandleBallThrowAnim(battler, gBattlerTarget, B_ANIM_BALL_THROW, TRUE); } -static void PlayerHandlePause(void) +static void PlayerHandlePause(u32 battler) { - u8 timer = gBattleResources->bufferA[gActiveBattler][1]; + u8 timer = gBattleResources->bufferA[battler][1]; while (timer != 0) timer--; - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleMoveAnimation(void) +static void PlayerHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, TRUE); + BtlController_HandleMoveAnimation(battler, TRUE); } -static void PlayerHandlePrintString(void) +static void PlayerHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, TRUE, TRUE); + BtlController_HandlePrintString(battler, TRUE, TRUE); } -static void PlayerHandlePrintSelectionString(void) +static void PlayerHandlePrintSelectionString(u32 battler) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) - PlayerHandlePrintString(); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + PlayerHandlePrintString(battler); else - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void HandleChooseActionAfterDma3(void) +static void HandleChooseActionAfterDma3(u32 battler) { if (!IsDma3ManagerBusyWithBgCopy()) { gBattle_BG0_X = 0; gBattle_BG0_Y = DISPLAY_HEIGHT; - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseAction; + gBattlerControllerFuncs[battler] = HandleInputChooseAction; } } -static void PlayerHandleChooseAction(void) +static void PlayerHandleChooseAction(u32 battler) { s32 i; - gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3; + gBattlerControllerFuncs[battler] = HandleChooseActionAfterDma3; BattleTv_ClearExplosionFaintCause(); BattlePutTextOnWindow(gText_BattleMenu, B_WIN_ACTION_MENU); @@ -1804,155 +1796,155 @@ static void PlayerHandleChooseAction(void) ActionSelectionDestroyCursorAt(i); TryRestoreLastUsedBall(); - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT); } -static void PlayerHandleYesNoBox(void) +static void PlayerHandleYesNoBox(u32 battler) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) { HandleBattleWindow(YESNOBOX_X_Y, 0); BattlePutTextOnWindow(gText_BattleYesNoChoice, B_WIN_YESNO); gMultiUsePlayerCursor = 1; BattleCreateYesNoCursorAt(1); - gBattlerControllerFuncs[gActiveBattler] = PlayerHandleYesNoInput; + gBattlerControllerFuncs[battler] = PlayerHandleYesNoInput; } else { - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void HandleChooseMoveAfterDma3(void) +static void HandleChooseMoveAfterDma3(u32 battler) { if (!IsDma3ManagerBusyWithBgCopy()) { gBattle_BG0_X = 0; gBattle_BG0_Y = DISPLAY_HEIGHT * 2; - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove; + gBattlerControllerFuncs[battler] = HandleInputChooseMove; } } // arenaMindPoints is used here as a placeholder for a timer. -static void PlayerChooseMoveInBattlePalace(void) +static void PlayerChooseMoveInBattlePalace(u32 battler) { - if (--*(gBattleStruct->arenaMindPoints + gActiveBattler) == 0) + if (--*(gBattleStruct->arenaMindPoints + battler) == 0) { gBattlePalaceMoveSelectionRngValue = gRngValue; BtlController_EmitTwoReturnValues(BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void PlayerHandleChooseMove(void) +static void PlayerHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { - *(gBattleStruct->arenaMindPoints + gActiveBattler) = 8; - gBattlerControllerFuncs[gActiveBattler] = PlayerChooseMoveInBattlePalace; + *(gBattleStruct->arenaMindPoints + battler) = 8; + gBattlerControllerFuncs[battler] = PlayerChooseMoveInBattlePalace; } else { - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); - InitMoveSelectionsVarsAndStrings(); + InitMoveSelectionsVarsAndStrings(battler); gBattleStruct->mega.playerSelect = FALSE; if (!IsMegaTriggerSpriteActive()) gBattleStruct->mega.triggerSpriteId = 0xFF; - if (CanMegaEvolve(gActiveBattler)) - CreateMegaTriggerSprite(gActiveBattler, 0); + if (CanMegaEvolve(battler)) + CreateMegaTriggerSprite(battler, 0); if (!IsZMoveTriggerSpriteActive()) gBattleStruct->zmove.triggerSpriteId = 0xFF; - GetUsableZMoves(gActiveBattler, moveInfo->moves); - gBattleStruct->zmove.viable = IsZMoveUsable(gActiveBattler, gMoveSelectionCursor[gActiveBattler]); - CreateZMoveTriggerSprite(gActiveBattler, gBattleStruct->zmove.viable); - gBattlerControllerFuncs[gActiveBattler] = HandleChooseMoveAfterDma3; + GetUsableZMoves(battler, moveInfo->moves); + gBattleStruct->zmove.viable = IsZMoveUsable(battler, gMoveSelectionCursor[battler]); + CreateZMoveTriggerSprite(battler, gBattleStruct->zmove.viable); + gBattlerControllerFuncs[battler] = HandleChooseMoveAfterDma3; } } -void InitMoveSelectionsVarsAndStrings(void) +void InitMoveSelectionsVarsAndStrings(u32 battler) { - MoveSelectionDisplayMoveNames(); + MoveSelectionDisplayMoveNames(battler); gMultiUsePlayerCursor = 0xFF; - MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0); - MoveSelectionDisplayPpString(); - MoveSelectionDisplayPpNumber(); - MoveSelectionDisplayMoveType(); + MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0); + MoveSelectionDisplayPpString(battler); + MoveSelectionDisplayPpNumber(battler); + MoveSelectionDisplayMoveType(battler); } -static void PlayerHandleChooseItem(void) +static void PlayerHandleChooseItem(u32 battler) { s32 i; BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); - gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem; - gBattlerInMenuId = gActiveBattler; + gBattlerControllerFuncs[battler] = OpenBagAndChooseItem; + gBattlerInMenuId = battler; for (i = 0; i < ARRAY_COUNT(gBattlePartyCurrentOrder); i++) - gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[gActiveBattler][1 + i]; + gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[battler][1 + i]; } -static void PlayerHandleChoosePokemon(void) +static void PlayerHandleChoosePokemon(u32 battler) { s32 i; for (i = 0; i < ARRAY_COUNT(gBattlePartyCurrentOrder); i++) - gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[gActiveBattler][4 + i]; + gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[battler][4 + i]; - if (gBattleTypeFlags & BATTLE_TYPE_ARENA && (gBattleResources->bufferA[gActiveBattler][1] & 0xF) != PARTY_ACTION_CANT_SWITCH - && (gBattleResources->bufferA[gActiveBattler][1] & 0xF) != PARTY_ACTION_CHOOSE_FAINTED_MON) + if (gBattleTypeFlags & BATTLE_TYPE_ARENA && (gBattleResources->bufferA[battler][1] & 0xF) != PARTY_ACTION_CANT_SWITCH + && (gBattleResources->bufferA[battler][1] & 0xF) != PARTY_ACTION_CHOOSE_FAINTED_MON) { - BtlController_EmitChosenMonReturnValue(BUFFER_B, gBattlerPartyIndexes[gActiveBattler] + 1, gBattlePartyCurrentOrder); - PlayerBufferExecCompleted(); + BtlController_EmitChosenMonReturnValue(BUFFER_B, gBattlerPartyIndexes[battler] + 1, gBattlePartyCurrentOrder); + PlayerBufferExecCompleted(battler); } else { - gBattleControllerData[gActiveBattler] = CreateTask(TaskDummy, 0xFF); - gTasks[gBattleControllerData[gActiveBattler]].data[0] = gBattleResources->bufferA[gActiveBattler][1] & 0xF; - *(&gBattleStruct->battlerPreventingSwitchout) = gBattleResources->bufferA[gActiveBattler][1] >> 4; - *(&gBattleStruct->prevSelectedPartySlot) = gBattleResources->bufferA[gActiveBattler][2]; - *(&gBattleStruct->abilityPreventingSwitchout) = (gBattleResources->bufferA[gActiveBattler][3] & 0xFF) | (gBattleResources->bufferA[gActiveBattler][7] << 8); + gBattleControllerData[battler] = CreateTask(TaskDummy, 0xFF); + gTasks[gBattleControllerData[battler]].data[0] = gBattleResources->bufferA[battler][1] & 0xF; + *(&gBattleStruct->battlerPreventingSwitchout) = gBattleResources->bufferA[battler][1] >> 4; + *(&gBattleStruct->prevSelectedPartySlot) = gBattleResources->bufferA[battler][2]; + *(&gBattleStruct->abilityPreventingSwitchout) = (gBattleResources->bufferA[battler][3] & 0xFF) | (gBattleResources->bufferA[battler][7] << 8); BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); - gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon; - gBattlerInMenuId = gActiveBattler; + gBattlerControllerFuncs[battler] = OpenPartyMenuToChooseMon; + gBattlerInMenuId = battler; } } -static void PlayerHandleCmd23(void) +static void PlayerHandleCmd23(u32 battler) { BattleStopLowHpSound(); BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleHealthBarUpdate(void) +static void PlayerHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, TRUE); + BtlController_HandleHealthBarUpdate(battler, TRUE); } -void PlayerHandleExpUpdate(void) +void PlayerHandleExpUpdate(u32 battler) { - u8 monId = gBattleResources->bufferA[gActiveBattler][1]; + u8 monId = gBattleResources->bufferA[battler][1]; s32 taskId, expPointsToGive; if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL) { - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } else { LoadBattleBarGfx(1); - expPointsToGive = T1_READ_32(&gBattleResources->bufferA[gActiveBattler][2]); + expPointsToGive = T1_READ_32(&gBattleResources->bufferA[battler][2]); taskId = CreateTask(Task_GiveExpToMon, 10); gTasks[taskId].tExpTask_monId = monId; gTasks[taskId].tExpTask_gainedExp_1 = expPointsToGive; gTasks[taskId].tExpTask_gainedExp_2 = expPointsToGive >> 16; - gTasks[taskId].tExpTask_battler = gActiveBattler; - gBattlerControllerFuncs[gActiveBattler] = BattleControllerDummy; + gTasks[taskId].tExpTask_battler = battler; + gBattlerControllerFuncs[battler] = BattleControllerDummy; } } @@ -1962,23 +1954,23 @@ void PlayerHandleExpUpdate(void) #undef tExpTask_gainedExp_2 #undef tExpTask_frames -static void PlayerHandleStatusXor(void) +static void PlayerHandleStatusXor(u32 battler) { - u8 val = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS) ^ gBattleResources->bufferA[gActiveBattler][1]; + u8 val = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS) ^ gBattleResources->bufferA[battler][1]; - SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS, &val); - PlayerBufferExecCompleted(); + SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS, &val); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleDMA3Transfer(void) +static void PlayerHandleDMA3Transfer(u32 battler) { - u32 dstArg = gBattleResources->bufferA[gActiveBattler][1] - | (gBattleResources->bufferA[gActiveBattler][2] << 8) - | (gBattleResources->bufferA[gActiveBattler][3] << 16) - | (gBattleResources->bufferA[gActiveBattler][4] << 24); - u16 sizeArg = gBattleResources->bufferA[gActiveBattler][5] | (gBattleResources->bufferA[gActiveBattler][6] << 8); + u32 dstArg = gBattleResources->bufferA[battler][1] + | (gBattleResources->bufferA[battler][2] << 8) + | (gBattleResources->bufferA[battler][3] << 16) + | (gBattleResources->bufferA[battler][4] << 24); + u16 sizeArg = gBattleResources->bufferA[battler][5] | (gBattleResources->bufferA[battler][6] << 8); - const u8 *src = &gBattleResources->bufferA[gActiveBattler][7]; + const u8 *src = &gBattleResources->bufferA[battler][7]; u8 *dst = (u8 *)(dstArg); u32 size = sizeArg; @@ -1994,121 +1986,121 @@ static void PlayerHandleDMA3Transfer(void) dst += 0x1000; size -= 0x1000; } - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandlePlayBGM(void) +static void PlayerHandlePlayBGM(u32 battler) { - PlayBGM(gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8)); - PlayerBufferExecCompleted(); + PlayBGM(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleTwoReturnValues(void) +static void PlayerHandleTwoReturnValues(u32 battler) { BtlController_EmitTwoReturnValues(BUFFER_B, 0, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleChosenMonReturnValue(void) +static void PlayerHandleChosenMonReturnValue(u32 battler) { BtlController_EmitChosenMonReturnValue(BUFFER_B, 0, NULL); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleOneReturnValue(void) +static void PlayerHandleOneReturnValue(u32 battler) { BtlController_EmitOneReturnValue(BUFFER_B, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleOneReturnValue_Duplicate(void) +static void PlayerHandleOneReturnValue_Duplicate(u32 battler) { BtlController_EmitOneReturnValue_Duplicate(BUFFER_B, 0); - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleIntroTrainerBallThrow(void) +static void PlayerHandleIntroTrainerBallThrow(u32 battler) { const u32 *trainerPal = gTrainerBackPicPaletteTable[gSaveBlock2Ptr->playerGender].data; - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); } -static void PlayerHandleDrawPartyStatusSummary(void) +static void PlayerHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_PLAYER, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void PlayerHandleEndBounceEffect(void) +static void PlayerHandleEndBounceEffect(u32 battler) { - EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX); - EndBounceEffect(gActiveBattler, BOUNCE_MON); - PlayerBufferExecCompleted(); + EndBounceEffect(battler, BOUNCE_HEALTHBOX); + EndBounceEffect(battler, BOUNCE_MON); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleBattleAnimation(void) +static void PlayerHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, TRUE); + BtlController_HandleBattleAnimation(battler, FALSE, TRUE); } -static void PlayerHandleLinkStandbyMsg(void) +static void PlayerHandleLinkStandbyMsg(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][2]); - switch (gBattleResources->bufferA[gActiveBattler][1]) + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); + switch (gBattleResources->bufferA[battler][1]) { case LINK_STANDBY_MSG_STOP_BOUNCE: PrintLinkStandbyMsg(); // fall through case LINK_STANDBY_STOP_BOUNCE_ONLY: - EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX); - EndBounceEffect(gActiveBattler, BOUNCE_MON); + EndBounceEffect(battler, BOUNCE_HEALTHBOX); + EndBounceEffect(battler, BOUNCE_MON); break; case LINK_STANDBY_MSG_ONLY: PrintLinkStandbyMsg(); break; } - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleResetActionMoveSelection(void) +static void PlayerHandleResetActionMoveSelection(u32 battler) { - switch (gBattleResources->bufferA[gActiveBattler][1]) + switch (gBattleResources->bufferA[battler][1]) { case RESET_ACTION_MOVE_SELECTION: - gActionSelectionCursor[gActiveBattler] = 0; - gMoveSelectionCursor[gActiveBattler] = 0; + gActionSelectionCursor[battler] = 0; + gMoveSelectionCursor[battler] = 0; break; case RESET_ACTION_SELECTION: - gActionSelectionCursor[gActiveBattler] = 0; + gActionSelectionCursor[battler] = 0; break; case RESET_MOVE_SELECTION: - gMoveSelectionCursor[gActiveBattler] = 0; + gMoveSelectionCursor[battler] = 0; break; } - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } -static void PlayerHandleEndLinkBattle(void) +static void PlayerHandleEndLinkBattle(u32 battler) { - RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[gActiveBattler][4]); - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; - gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[gActiveBattler][2]; + RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); + gBattleOutcome = gBattleResources->bufferA[battler][1]; + gSaveBlock2Ptr->frontier.disableRecordBattle = gBattleResources->bufferA[battler][2]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - PlayerBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + PlayerBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } -static void Controller_WaitForDebug(void) +static void Controller_WaitForDebug(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - PlayerBufferExecCompleted(); + PlayerBufferExecCompleted(battler); } } -static void PlayerHandleBattleDebug(void) +static void PlayerHandleBattleDebug(u32 battler) { BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); SetMainCallback2(CB2_BattleDebugMenu); - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForDebug; + gBattlerControllerFuncs[battler] = Controller_WaitForDebug; } diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index da7508cc4..3ad093909 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -31,31 +31,26 @@ #include "constants/party_menu.h" #include "constants/trainers.h" -static void PlayerPartnerHandleLoadMonSprite(void); -static void PlayerPartnerHandleSwitchInAnim(void); -static void PlayerPartnerHandleDrawTrainerPic(void); -static void PlayerPartnerHandleTrainerSlideBack(void); -static void PlayerPartnerHandleMoveAnimation(void); -static void PlayerPartnerHandlePrintString(void); -static void PlayerPartnerHandleChooseAction(void); -static void PlayerPartnerHandleChooseMove(void); -static void PlayerPartnerHandleChoosePokemon(void); -static void PlayerPartnerHandleHealthBarUpdate(void); -static void PlayerPartnerHandleIntroTrainerBallThrow(void); -static void PlayerPartnerHandleDrawPartyStatusSummary(void); -static void PlayerPartnerHandleBattleAnimation(void); -static void PlayerPartnerHandleEndLinkBattle(void); +static void PlayerPartnerHandleLoadMonSprite(u32 battler); +static void PlayerPartnerHandleSwitchInAnim(u32 battler); +static void PlayerPartnerHandleDrawTrainerPic(u32 battler); +static void PlayerPartnerHandleTrainerSlideBack(u32 battler); +static void PlayerPartnerHandleMoveAnimation(u32 battler); +static void PlayerPartnerHandlePrintString(u32 battler); +static void PlayerPartnerHandleChooseAction(u32 battler); +static void PlayerPartnerHandleChooseMove(u32 battler); +static void PlayerPartnerHandleChoosePokemon(u32 battler); +static void PlayerPartnerHandleHealthBarUpdate(u32 battler); +static void PlayerPartnerHandleIntroTrainerBallThrow(u32 battler); +static void PlayerPartnerHandleDrawPartyStatusSummary(u32 battler); +static void PlayerPartnerHandleBattleAnimation(u32 battler); +static void PlayerPartnerHandleEndLinkBattle(u32 battler); -static void PlayerPartnerBufferRunCommand(void); -static void PlayerPartnerBufferExecCompleted(void); -static void Task_LaunchLvlUpAnim(u8 taskId); -static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId); -static void Task_PrepareToGiveExpWithExpBar(u8 taskId); -static void Task_GiveExpWithExpBar(u8 taskId); -static void Task_UpdateLvlInHealthbox(u8 taskId); -static void SwitchIn_WaitAndEnd(void); +static void PlayerPartnerBufferRunCommand(u32 battler); +static void PlayerPartnerBufferExecCompleted(u32 battler); +static void SwitchIn_WaitAndEnd(u32 battler); -static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -117,45 +112,45 @@ static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToPlayerPartner(void) +void SetControllerToPlayerPartner(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = PlayerPartnerBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = PlayerPartnerBufferRunCommand; + gBattlerControllerEndFuncs[battler] = PlayerPartnerBufferExecCompleted; + gBattlerControllerFuncs[battler] = PlayerPartnerBufferRunCommand; } -static void PlayerPartnerBufferRunCommand(void) +static void PlayerPartnerBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sPlayerPartnerBufferCommands)) - sPlayerPartnerBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sPlayerPartnerBufferCommands)) + sPlayerPartnerBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - PlayerPartnerBufferExecCompleted(); + PlayerPartnerBufferExecCompleted(battler); } } -static void Intro_DelayAndEnd(void) +static void Intro_DelayAndEnd(u32 battler) { - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - BattleControllerComplete(gActiveBattler); + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + BattleControllerComplete(battler); } } -static void Intro_WaitForHealthbox(void) +static void Intro_WaitForHealthbox(u32 battler) { bool32 finished = FALSE; if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) finished = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { finished = TRUE; } @@ -166,135 +161,135 @@ static void Intro_WaitForHealthbox(void) if (finished) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } // Also used by the link partner. -void Controller_PlayerPartnerShowIntroHealthbox(void) +void Controller_PlayerPartnerShowIntroHealthbox(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive - && gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && ++gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay != 1) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive + && gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && ++gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay != 1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + DestroySprite(&gSprites[gBattleControllerData[battler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForHealthbox; } } -static void WaitForMonAnimAfterLoad(void) +static void WaitForMonAnimAfterLoad(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) - PlayerPartnerBufferExecCompleted(); + if (gSprites[gBattlerSpriteIds[battler]].animEnded && gSprites[gBattlerSpriteIds[battler]].x2 == 0) + PlayerPartnerBufferExecCompleted(battler); } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - CopyBattleSpriteInvisibility(gActiveBattler); - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + CopyBattleSpriteInvisibility(battler); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_WaitAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_WaitAndEnd; } } -static void SwitchIn_WaitAndEnd(void) +static void SwitchIn_WaitAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - PlayerPartnerBufferExecCompleted(); + PlayerPartnerBufferExecCompleted(battler); } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); CreateTask(Task_PlayerController_RestoreBgmAfterCry, 10); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); } - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void PlayerPartnerBufferExecCompleted(void) +static void PlayerPartnerBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = PlayerPartnerBufferRunCommand; + gBattlerControllerFuncs[battler] = PlayerPartnerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void PlayerPartnerHandleLoadMonSprite(void) +static void PlayerPartnerHandleLoadMonSprite(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gPlayerParty, WaitForMonAnimAfterLoad); + BtlController_HandleLoadMonSprite(battler, gPlayerParty, WaitForMonAnimAfterLoad); } -static void PlayerPartnerHandleSwitchInAnim(void) +static void PlayerPartnerHandleSwitchInAnim(u32 battler) { - BtlController_HandleSwitchInAnim(gActiveBattler, TRUE, SwitchIn_TryShinyAnim); + BtlController_HandleSwitchInAnim(battler, TRUE, SwitchIn_TryShinyAnim); } // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it -static void PlayerPartnerHandleDrawTrainerPic(void) +static void PlayerPartnerHandleDrawTrainerPic(u32 battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -325,40 +320,40 @@ static void PlayerPartnerHandleDrawTrainerPic(void) else isFrontPic = TRUE; - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, isFrontPic, xPos, yPos, -1); + BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void PlayerPartnerHandleTrainerSlideBack(void) +static void PlayerPartnerHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void PlayerPartnerHandleMoveAnimation(void) +static void PlayerPartnerHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, FALSE); + BtlController_HandleMoveAnimation(battler, FALSE); } -static void PlayerPartnerHandlePrintString(void) +static void PlayerPartnerHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, FALSE, FALSE); + BtlController_HandlePrintString(battler, FALSE, FALSE); } -static void PlayerPartnerHandleChooseAction(void) +static void PlayerPartnerHandleChooseAction(u32 battler) { AI_TrySwitchOrUseItem(); - PlayerPartnerBufferExecCompleted(); + PlayerPartnerBufferExecCompleted(battler); } -static void PlayerPartnerHandleChooseMove(void) +static void PlayerPartnerHandleChooseMove(u32 battler) { u8 chosenMoveId; - struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]); + struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); - chosenMoveId = gBattleStruct->aiMoveOrAction[gActiveBattler]; - gBattlerTarget = gBattleStruct->aiChosenTarget[gActiveBattler]; + chosenMoveId = gBattleStruct->aiMoveOrAction[battler]; + gBattlerTarget = gBattleStruct->aiChosenTarget[battler]; if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) - gBattlerTarget = gActiveBattler; + gBattlerTarget = battler; if (gBattleMoves[moveInfo->moves[chosenMoveId]].target & MOVE_TARGET_BOTH) { gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); @@ -366,25 +361,25 @@ static void PlayerPartnerHandleChooseMove(void) gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); } - if (ShouldUseZMove(gActiveBattler, gBattlerTarget, moveInfo->moves[chosenMoveId])) - QueueZMove(gActiveBattler, moveInfo->moves[chosenMoveId]); + if (ShouldUseZMove(battler, gBattlerTarget, moveInfo->moves[chosenMoveId])) + QueueZMove(battler, moveInfo->moves[chosenMoveId]); // If partner can mega evolve, do it. - if (CanMegaEvolve(gActiveBattler)) + if (CanMegaEvolve(battler)) BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (RET_MEGA_EVOLUTION) | (gBattlerTarget << 8)); else BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); - PlayerPartnerBufferExecCompleted(); + PlayerPartnerBufferExecCompleted(battler); } -static void PlayerPartnerHandleChoosePokemon(void) +static void PlayerPartnerHandleChoosePokemon(u32 battler) { s32 chosenMonId; // Choosing Revival Blessing target - if ((gBattleResources->bufferA[gActiveBattler][1] & 0xF) == PARTY_ACTION_CHOOSE_FAINTED_MON) + if ((gBattleResources->bufferA[battler][1] & 0xF) == PARTY_ACTION_CHOOSE_FAINTED_MON) { - chosenMonId = gSelectedMonPartyId = GetFirstFaintedPartyIndex(gActiveBattler); + chosenMonId = gSelectedMonPartyId = GetFirstFaintedPartyIndex(battler); } // Switching out else @@ -405,18 +400,18 @@ static void PlayerPartnerHandleChoosePokemon(void) } } } - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = chosenMonId; + *(gBattleStruct->monToSwitchIntoId + battler) = chosenMonId; } BtlController_EmitChosenMonReturnValue(BUFFER_B, chosenMonId, NULL); - PlayerPartnerBufferExecCompleted(); + PlayerPartnerBufferExecCompleted(battler); } -static void PlayerPartnerHandleHealthBarUpdate(void) +static void PlayerPartnerHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, FALSE); + BtlController_HandleHealthBarUpdate(battler, FALSE); } -static void PlayerPartnerHandleIntroTrainerBallThrow(void) +static void PlayerPartnerHandleIntroTrainerBallThrow(u32 battler) { const u32 *trainerPal; @@ -427,24 +422,24 @@ static void PlayerPartnerHandleIntroTrainerBallThrow(void) else trainerPal = gTrainerFrontPicPaletteTable[GetFrontierTrainerFrontSpriteId(gPartnerTrainerId)].data; // 2 vs 2 multi battle in Battle Frontier, load front sprite and pal. - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); } -static void PlayerPartnerHandleDrawPartyStatusSummary(void) +static void PlayerPartnerHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_PLAYER, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void PlayerPartnerHandleBattleAnimation(void) +static void PlayerPartnerHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, FALSE); + BtlController_HandleBattleAnimation(battler, FALSE, FALSE); } -static void PlayerPartnerHandleEndLinkBattle(void) +static void PlayerPartnerHandleEndLinkBattle(u32 battler) { - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - PlayerPartnerBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + PlayerPartnerBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 6dac18df0..611ca630f 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -32,29 +32,29 @@ #include "constants/songs.h" #include "constants/trainers.h" -static void RecordedOpponentHandleLoadMonSprite(void); -static void RecordedOpponentHandleSwitchInAnim(void); -static void RecordedOpponentHandleDrawTrainerPic(void); -static void RecordedOpponentHandleTrainerSlideBack(void); -static void RecordedOpponentHandleMoveAnimation(void); -static void RecordedOpponentHandlePrintString(void); -static void RecordedOpponentHandleChooseAction(void); -static void RecordedOpponentHandleChooseMove(void); -static void RecordedOpponentHandleChooseItem(void); -static void RecordedOpponentHandleChoosePokemon(void); -static void RecordedOpponentHandleHealthBarUpdate(void); -static void RecordedOpponentHandleStatusIconUpdate(void); -static void RecordedOpponentHandleStatusAnimation(void); -static void RecordedOpponentHandleIntroTrainerBallThrow(void); -static void RecordedOpponentHandleDrawPartyStatusSummary(void); -static void RecordedOpponentHandleBattleAnimation(void); -static void RecordedOpponentHandleEndLinkBattle(void); +static void RecordedOpponentHandleLoadMonSprite(u32 battler); +static void RecordedOpponentHandleSwitchInAnim(u32 battler); +static void RecordedOpponentHandleDrawTrainerPic(u32 battler); +static void RecordedOpponentHandleTrainerSlideBack(u32 battler); +static void RecordedOpponentHandleMoveAnimation(u32 battler); +static void RecordedOpponentHandlePrintString(u32 battler); +static void RecordedOpponentHandleChooseAction(u32 battler); +static void RecordedOpponentHandleChooseMove(u32 battler); +static void RecordedOpponentHandleChooseItem(u32 battler); +static void RecordedOpponentHandleChoosePokemon(u32 battler); +static void RecordedOpponentHandleHealthBarUpdate(u32 battler); +static void RecordedOpponentHandleStatusIconUpdate(u32 battler); +static void RecordedOpponentHandleStatusAnimation(u32 battler); +static void RecordedOpponentHandleIntroTrainerBallThrow(u32 battler); +static void RecordedOpponentHandleDrawPartyStatusSummary(u32 battler); +static void RecordedOpponentHandleBattleAnimation(u32 battler); +static void RecordedOpponentHandleEndLinkBattle(u32 battler); -static void RecordedOpponentBufferRunCommand(void); -static void RecordedOpponentBufferExecCompleted(void); -static void SwitchIn_HandleSoundAndEnd(void); +static void RecordedOpponentBufferRunCommand(u32 battler); +static void RecordedOpponentBufferExecCompleted(u32 battler); +static void SwitchIn_HandleSoundAndEnd(u32 battler); -static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -116,120 +116,130 @@ static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToRecordedOpponent(void) +void SetControllerToRecordedOpponent(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = RecordedOpponentBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = RecordedOpponentBufferRunCommand; + gBattlerControllerEndFuncs[battler] = RecordedOpponentBufferExecCompleted; + gBattlerControllerFuncs[battler] = RecordedOpponentBufferRunCommand; } -static void RecordedOpponentBufferRunCommand(void) +static void RecordedOpponentBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sRecordedOpponentBufferCommands)) - sRecordedOpponentBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sRecordedOpponentBufferCommands)) + sRecordedOpponentBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - RecordedOpponentBufferExecCompleted(); + RecordedOpponentBufferExecCompleted(battler); } } -static void CompleteOnBankSpriteCallbackDummy2(void) +static void RecordedOpponentBufferExecCompleted(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) - RecordedOpponentBufferExecCompleted(); -} - -static void Intro_DelayAndEnd(void) -{ - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + gBattlerControllerFuncs[battler] = RecordedOpponentBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - RecordedOpponentBufferExecCompleted(); + u8 playerId = GetMultiplayerId(); + + PrepareBufferDataTransferLink(2, 4, &playerId); + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; + } + else + { + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_DelayAndEnd(u32 battler) +{ + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) + { + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + RecordedOpponentBufferExecCompleted(battler); + } +} + +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool8 healthboxAnimDone = FALSE; if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].animEnded) healthboxAnimDone = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded - && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)]].animEnded) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].animEnded + && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].animEnded) healthboxAnimDone = TRUE; } if (healthboxAnimDone) { - if (GetBattlerPosition(gActiveBattler) == B_POSITION_OPPONENT_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) return; - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) return; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) + TryShinyAnimation(BATTLE_PARTNER(battler), &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = TRUE; } - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].waitForCry - && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].waitForCry + if (!gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry + && gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].waitForCry && !IsCryPlayingOrClearCrySongs()) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored) { if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK) { - if (GetBattlerPosition(gActiveBattler) == B_POSITION_OPPONENT_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) m4aMPlayContinue(&gMPlayInfo_BGM); } else @@ -237,24 +247,24 @@ static void Intro_TryShinyAnimShowHealthbox(void) m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); } } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = TRUE; bgmRestored = TRUE; } if (!IsDoubleBattle()) { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } } else { - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { battlerAnimsDone = TRUE; } @@ -264,146 +274,130 @@ static void Intro_TryShinyAnimShowHealthbox(void) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - SetBattlerShadowSpriteCallback(BATTLE_PARTNER(gActiveBattler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + SetBattlerShadowSpriteCallback(BATTLE_PARTNER(battler), GetMonData(&gEnemyParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], MON_DATA_SPECIES)); } - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } -static void TryShinyAnimAfterMonAnim(void) +static void TryShinyAnimAfterMonAnim(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].x2 == 0) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) { - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); } else { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - RecordedOpponentBufferExecCompleted(); + RecordedOpponentBufferExecCompleted(battler); } } } } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_HandleSoundAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_HandleSoundAndEnd; } } -static void SwitchIn_HandleSoundAndEnd(void) +static void SwitchIn_HandleSoundAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - || gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy_2) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy + || gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy_2) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); - RecordedOpponentBufferExecCompleted(); + RecordedOpponentBufferExecCompleted(battler); } } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); - CopyBattleSpriteInvisibility(gActiveBattler); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gEnemyParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + CopyBattleSpriteInvisibility(battler); + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim) - TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) + TryShinyAnimation(battler, &gEnemyParty[gBattlerPartyIndexes[battler]]); - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + SetBattlerShadowSpriteCallback(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void RecordedOpponentBufferExecCompleted(void) +static void RecordedOpponentHandleLoadMonSprite(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = RecordedOpponentBufferRunCommand; - if (gBattleTypeFlags & BATTLE_TYPE_LINK) - { - u8 playerId = GetMultiplayerId(); - - PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; - } - else - { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; - } + BtlController_HandleLoadMonSprite(battler, gEnemyParty, TryShinyAnimAfterMonAnim); } -static void RecordedOpponentHandleLoadMonSprite(void) +static void RecordedOpponentHandleSwitchInAnim(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gEnemyParty, TryShinyAnimAfterMonAnim); + BtlController_HandleSwitchInAnim(battler, FALSE, SwitchIn_TryShinyAnim); } -static void RecordedOpponentHandleSwitchInAnim(void) -{ - BtlController_HandleSwitchInAnim(gActiveBattler, FALSE, SwitchIn_TryShinyAnim); -} - -static void RecordedOpponentHandleDrawTrainerPic(void) +static void RecordedOpponentHandleDrawTrainerPic(u32 battler) { s16 xPos; u32 trainerPicId; if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != 0) // second mon + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 152; else // first mon xPos = 200; if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) { - if (gActiveBattler == 1) + if (battler == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_A); else trainerPicId = GetFrontierTrainerFrontSpriteId(gTrainerBattleOpponent_B); @@ -426,28 +420,28 @@ static void RecordedOpponentHandleDrawTrainerPic(void) } } - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, TRUE, + BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicId].size), -1); } -static void RecordedOpponentHandleTrainerSlideBack(void) +static void RecordedOpponentHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void RecordedOpponentHandleMoveAnimation(void) +static void RecordedOpponentHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, FALSE); + BtlController_HandleMoveAnimation(battler, FALSE); } -static void RecordedOpponentHandlePrintString(void) +static void RecordedOpponentHandlePrintString(u32 battler) { u16 *stringId; gBattle_BG0_X = 0; gBattle_BG0_Y = 0; - stringId = (u16 *)(&gBattleResources->bufferA[gActiveBattler][2]); + stringId = (u16 *)(&gBattleResources->bufferA[battler][2]); BufferStringBattle(*stringId); if (gTestRunnerEnabled) @@ -455,22 +449,22 @@ static void RecordedOpponentHandlePrintString(void) TestRunner_Battle_RecordMessage(gDisplayedStringBattle); if (gTestRunnerHeadless) { - RecordedOpponentBufferExecCompleted(); + RecordedOpponentBufferExecCompleted(battler); return; } } BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MSG); - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForString; + gBattlerControllerFuncs[battler] = Controller_WaitForString; } -static void RecordedOpponentHandleChooseAction(void) +static void RecordedOpponentHandleChooseAction(u32 battler) { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, gActiveBattler), 0); - RecordedOpponentBufferExecCompleted(); + BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); + RecordedOpponentBufferExecCompleted(battler); } -static void RecordedOpponentHandleChooseMove(void) +static void RecordedOpponentHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -478,97 +472,97 @@ static void RecordedOpponentHandleChooseMove(void) } else { - u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, gActiveBattler); - u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, gActiveBattler); + u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); + u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); BtlController_EmitTwoReturnValues(BUFFER_B, 10, moveId | (target << 8)); } - RecordedOpponentBufferExecCompleted(); + RecordedOpponentBufferExecCompleted(battler); } -static void RecordedOpponentHandleChooseItem(void) +static void RecordedOpponentHandleChooseItem(u32 battler) { - u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, gActiveBattler); - u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, gActiveBattler); - gBattleStruct->chosenItem[gActiveBattler] = (byte1 << 8) | byte2; - gBattleStruct->itemPartyIndex[gActiveBattler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, gActiveBattler); - gBattleStruct->itemMoveIndex[gActiveBattler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, gActiveBattler); - BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[gActiveBattler]); - RecordedOpponentBufferExecCompleted(); + u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); + u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); + gBattleStruct->chosenItem[battler] = (byte1 << 8) | byte2; + gBattleStruct->itemPartyIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, battler); + gBattleStruct->itemMoveIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, battler); + BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[battler]); + RecordedOpponentBufferExecCompleted(battler); } -static void RecordedOpponentHandleChoosePokemon(void) +static void RecordedOpponentHandleChoosePokemon(u32 battler) { - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, gActiveBattler); - gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[gActiveBattler]; // Revival Blessing - BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + gActiveBattler), NULL); - RecordedOpponentBufferExecCompleted(); + *(gBattleStruct->monToSwitchIntoId + battler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); + gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing + BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); + RecordedOpponentBufferExecCompleted(battler); } -static void RecordedOpponentHandleHealthBarUpdate(void) +static void RecordedOpponentHandleHealthBarUpdate(u32 battler) { s16 hpVal; s32 maxHP, curHP; LoadBattleBarGfx(0); - hpVal = gBattleResources->bufferA[gActiveBattler][2] | (gBattleResources->bufferA[gActiveBattler][3] << 8); + hpVal = gBattleResources->bufferA[battler][2] | (gBattleResources->bufferA[battler][3] << 8); - maxHP = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP); - curHP = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP); + maxHP = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_MAX_HP); + curHP = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_HP); if (hpVal != INSTANT_HP_BAR_DROP) { - SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, curHP, hpVal); - TestRunner_Battle_RecordHP(gActiveBattler, curHP, min(maxHP, max(0, curHP - hpVal))); + SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, curHP, hpVal); + TestRunner_Battle_RecordHP(battler, curHP, min(maxHP, max(0, curHP - hpVal))); } else { - SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, 0, hpVal); - TestRunner_Battle_RecordHP(gActiveBattler, curHP, 0); + SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, 0, hpVal); + TestRunner_Battle_RecordHP(battler, curHP, 0); } - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForHealthBar; + gBattlerControllerFuncs[battler] = Controller_WaitForHealthBar; } -static void RecordedOpponentHandleStatusIconUpdate(void) +static void RecordedOpponentHandleStatusIconUpdate(u32 battler) { - if (!IsBattleSEPlaying(gActiveBattler)) + if (!IsBattleSEPlaying(battler)) { - DoStatusIconUpdate(gActiveBattler); + DoStatusIconUpdate(battler); if (gTestRunnerEnabled) - TestRunner_Battle_RecordStatus1(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS)); + TestRunner_Battle_RecordStatus1(battler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS)); } } -static void RecordedOpponentHandleStatusAnimation(void) +static void RecordedOpponentHandleStatusAnimation(u32 battler) { - BtlController_HandleStatusAnimation(); + BtlController_HandleStatusAnimation(battler); } -static void RecordedOpponentHandleIntroTrainerBallThrow(void) +static void RecordedOpponentHandleIntroTrainerBallThrow(u32 battler) { - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void RecordedOpponentHandleDrawPartyStatusSummary(void) +static void RecordedOpponentHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_OPPONENT, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void RecordedOpponentHandleBattleAnimation(void) +static void RecordedOpponentHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, FALSE); + BtlController_HandleBattleAnimation(battler, FALSE, FALSE); } -static void RecordedOpponentHandleEndLinkBattle(void) +static void RecordedOpponentHandleEndLinkBattle(u32 battler) { - if (gBattleResources->bufferA[gActiveBattler][1] == B_OUTCOME_DREW) - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + if (gBattleResources->bufferA[battler][1] == B_OUTCOME_DREW) + gBattleOutcome = gBattleResources->bufferA[battler][1]; else - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1] ^ B_OUTCOME_DREW; + gBattleOutcome = gBattleResources->bufferA[battler][1] ^ B_OUTCOME_DREW; FadeOutMapMusic(5); BeginFastPaletteFade(3); - RecordedOpponentBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + RecordedOpponentBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index a3fb6891e..dd2abe87f 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -29,29 +29,29 @@ #include "constants/songs.h" #include "constants/trainers.h" -static void RecordedPlayerHandleLoadMonSprite(void); -static void RecordedPlayerHandleSwitchInAnim(void); -static void RecordedPlayerHandleDrawTrainerPic(void); -static void RecordedPlayerHandleTrainerSlideBack(void); -static void RecordedPlayerHandleMoveAnimation(void); -static void RecordedPlayerHandlePrintString(void); -static void RecordedPlayerHandleChooseAction(void); -static void RecordedPlayerHandleChooseMove(void); -static void RecordedPlayerHandleChooseItem(void); -static void RecordedPlayerHandleChoosePokemon(void); -static void RecordedPlayerHandleHealthBarUpdate(void); -static void RecordedPlayerHandleStatusIconUpdate(void); -static void RecordedPlayerHandleStatusAnimation(void); -static void RecordedPlayerHandleIntroTrainerBallThrow(void); -static void RecordedPlayerHandleDrawPartyStatusSummary(void); -static void RecordedPlayerHandleBattleAnimation(void); -static void RecordedPlayerHandleEndLinkBattle(void); +static void RecordedPlayerHandleLoadMonSprite(u32 battler); +static void RecordedPlayerHandleSwitchInAnim(u32 battler); +static void RecordedPlayerHandleDrawTrainerPic(u32 battler); +static void RecordedPlayerHandleTrainerSlideBack(u32 battler); +static void RecordedPlayerHandleMoveAnimation(u32 battler); +static void RecordedPlayerHandlePrintString(u32 battler); +static void RecordedPlayerHandleChooseAction(u32 battler); +static void RecordedPlayerHandleChooseMove(u32 battler); +static void RecordedPlayerHandleChooseItem(u32 battler); +static void RecordedPlayerHandleChoosePokemon(u32 battler); +static void RecordedPlayerHandleHealthBarUpdate(u32 battler); +static void RecordedPlayerHandleStatusIconUpdate(u32 battler); +static void RecordedPlayerHandleStatusAnimation(u32 battler); +static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler); +static void RecordedPlayerHandleDrawPartyStatusSummary(u32 battler); +static void RecordedPlayerHandleBattleAnimation(u32 battler); +static void RecordedPlayerHandleEndLinkBattle(u32 battler); -static void RecordedPlayerBufferRunCommand(void); -static void RecordedPlayerBufferExecCompleted(void); -static void SwitchIn_WaitAndEnd(void); +static void RecordedPlayerBufferRunCommand(u32 battler); +static void RecordedPlayerBufferExecCompleted(u32 battler); +static void SwitchIn_WaitAndEnd(u32 battler); -static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -113,83 +113,83 @@ static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(void) [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToRecordedPlayer(void) +void SetControllerToRecordedPlayer(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = RecordedPlayerBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = RecordedPlayerBufferRunCommand; + gBattlerControllerEndFuncs[battler] = RecordedPlayerBufferExecCompleted; + gBattlerControllerFuncs[battler] = RecordedPlayerBufferRunCommand; } -static void RecordedPlayerBufferRunCommand(void) +static void RecordedPlayerBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sRecordedPlayerBufferCommands)) - sRecordedPlayerBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sRecordedPlayerBufferCommands)) + sRecordedPlayerBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - RecordedPlayerBufferExecCompleted(); + RecordedPlayerBufferExecCompleted(battler); } } -static void Intro_DelayAndEnd(void) +static void Intro_DelayAndEnd(u32 battler) { - if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1) + if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0; - RecordedPlayerBufferExecCompleted(); + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0; + RecordedPlayerBufferExecCompleted(battler); } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool32 healthboxAnimDone = FALSE; - if (GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT) { if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { healthboxAnimDone = TRUE; } } - if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); if (IsDoubleBattle()) - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], BATTLE_PARTNER(gActiveBattler)); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], BATTLE_PARTNER(battler)); - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } else { if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; } else { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy + && gSprites[gHealthboxSpriteIds[BATTLE_PARTNER(battler)]].callback == SpriteCallbackDummy) { healthboxAnimDone = TRUE; } @@ -200,55 +200,55 @@ static void Intro_WaitForShinyAnimAndHealthbox(void) if (healthboxAnimDone) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3; - gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd; + gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3; + gBattlerControllerFuncs[battler] = Intro_DelayAndEnd; } } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { bool32 bgmRestored = FALSE; - if (GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) + TryShinyAnimation(BATTLE_PARTNER(battler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); } - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = TRUE; } - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].waitForCry - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].waitForCry + if (gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted + && !gBattleSpritesDataPtr->healthBoxesData[battler].waitForCry + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].waitForCry && !IsCryPlayingOrClearCrySongs()) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored) { if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && (gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - if (GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT) m4aMPlayContinue(&gMPlayInfo_BGM); } else @@ -257,115 +257,115 @@ static void Intro_TryShinyAnimShowHealthbox(void) } } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = TRUE; bgmRestored = TRUE; } - if (bgmRestored && gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (bgmRestored && gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); + DestroySprite(&gSprites[gBattleControllerData[battler]]); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].bgmRestored = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].healthboxSlideInStarted = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattleSpritesDataPtr->healthBoxesData[battler].bgmRestored = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].healthboxSlideInStarted = FALSE; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } -static void WaitForMonAnimAfterLoad(void) +static void WaitForMonAnimAfterLoad(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0) - RecordedPlayerBufferExecCompleted(); + if (gSprites[gBattlerSpriteIds[battler]].animEnded && gSprites[gBattlerSpriteIds[battler]].x2 == 0) + RecordedPlayerBufferExecCompleted(battler); } -static void SwitchIn_ShowSubstitute(void) +static void SwitchIn_ShowSubstitute(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { - CopyBattleSpriteInvisibility(gActiveBattler); - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); + CopyBattleSpriteInvisibility(battler); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_WaitAndEnd; + gBattlerControllerFuncs[battler] = SwitchIn_WaitAndEnd; } } -static void SwitchIn_WaitAndEnd(void) +static void SwitchIn_WaitAndEnd(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - RecordedPlayerBufferExecCompleted(); + RecordedPlayerBufferExecCompleted(battler); } } -static void SwitchIn_ShowHealthbox(void) +static void SwitchIn_ShowHealthbox(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim) + if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); CreateTask(Task_PlayerController_RestoreBgmAfterCry, 10); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 0); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowSubstitute; + gBattlerControllerFuncs[battler] = SwitchIn_ShowSubstitute; } } -static void SwitchIn_TryShinyAnim(void) +static void SwitchIn_TryShinyAnim(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); } - if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) + if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) { - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - gBattlerControllerFuncs[gActiveBattler] = SwitchIn_ShowHealthbox; + DestroySprite(&gSprites[gBattleControllerData[battler]]); + gBattlerControllerFuncs[battler] = SwitchIn_ShowHealthbox; } } -static void RecordedPlayerBufferExecCompleted(void) +static void RecordedPlayerBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = RecordedPlayerBufferRunCommand; + gBattlerControllerFuncs[battler] = RecordedPlayerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void RecordedPlayerHandleLoadMonSprite(void) +static void RecordedPlayerHandleLoadMonSprite(u32 battler) { - BtlController_HandleLoadMonSprite(gActiveBattler, gPlayerParty, WaitForMonAnimAfterLoad); + BtlController_HandleLoadMonSprite(battler, gPlayerParty, WaitForMonAnimAfterLoad); } -static void RecordedPlayerHandleSwitchInAnim(void) +static void RecordedPlayerHandleSwitchInAnim(u32 battler) { - BtlController_HandleSwitchInAnim(gActiveBattler, TRUE, SwitchIn_TryShinyAnim); + BtlController_HandleSwitchInAnim(battler, TRUE, SwitchIn_TryShinyAnim); } -static void RecordedPlayerHandleDrawTrainerPic(void) +static void RecordedPlayerHandleDrawTrainerPic(u32 battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -385,7 +385,7 @@ static void RecordedPlayerHandleDrawTrainerPic(void) if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != 0) // second mon + if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon xPos = 90; else // first mon xPos = 32; @@ -412,26 +412,26 @@ static void RecordedPlayerHandleDrawTrainerPic(void) else isFrontPic = FALSE; - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, isFrontPic, xPos, yPos, -1); + BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void RecordedPlayerHandleTrainerSlideBack(void) +static void RecordedPlayerHandleTrainerSlideBack(u32 battler) { - BtlController_HandleTrainerSlideBack(gActiveBattler, 35, FALSE); + BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void RecordedPlayerHandleMoveAnimation(void) +static void RecordedPlayerHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, FALSE); + BtlController_HandleMoveAnimation(battler, FALSE); } -static void RecordedPlayerHandlePrintString(void) +static void RecordedPlayerHandlePrintString(u32 battler) { u16 *stringId; gBattle_BG0_X = 0; gBattle_BG0_Y = 0; - stringId = (u16 *)(&gBattleResources->bufferA[gActiveBattler][2]); + stringId = (u16 *)(&gBattleResources->bufferA[battler][2]); BufferStringBattle(*stringId); if (gTestRunnerEnabled) @@ -439,38 +439,38 @@ static void RecordedPlayerHandlePrintString(void) TestRunner_Battle_RecordMessage(gDisplayedStringBattle); if (gTestRunnerHeadless) { - RecordedPlayerBufferExecCompleted(); + RecordedPlayerBufferExecCompleted(battler); return; } } BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MSG); - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForString; + gBattlerControllerFuncs[battler] = Controller_WaitForString; } -static void ChooseActionInBattlePalace(void) +static void ChooseActionInBattlePalace(u32 battler) { if (gBattleCommunication[4] >= gBattlersCount / 2) { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, gActiveBattler), 0); - RecordedPlayerBufferExecCompleted(); + BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, battler), 0); + RecordedPlayerBufferExecCompleted(battler); } } -static void RecordedPlayerHandleChooseAction(void) +static void RecordedPlayerHandleChooseAction(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { - gBattlerControllerFuncs[gActiveBattler] = ChooseActionInBattlePalace; + gBattlerControllerFuncs[battler] = ChooseActionInBattlePalace; } else { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, gActiveBattler), 0); - RecordedPlayerBufferExecCompleted(); + BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); + RecordedPlayerBufferExecCompleted(battler); } } -static void RecordedPlayerHandleChooseMove(void) +static void RecordedPlayerHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -478,103 +478,103 @@ static void RecordedPlayerHandleChooseMove(void) } else { - u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, gActiveBattler); - u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, gActiveBattler); + u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); + u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); BtlController_EmitTwoReturnValues(BUFFER_B, 10, moveId | (target << 8)); } - RecordedPlayerBufferExecCompleted(); + RecordedPlayerBufferExecCompleted(battler); } -static void RecordedPlayerHandleChooseItem(void) +static void RecordedPlayerHandleChooseItem(u32 battler) { - u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, gActiveBattler); - u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, gActiveBattler); - gBattleStruct->chosenItem[gActiveBattler] = (byte1 << 8) | byte2; - gBattleStruct->itemPartyIndex[gActiveBattler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, gActiveBattler); - gBattleStruct->itemMoveIndex[gActiveBattler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, gActiveBattler); - BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[gActiveBattler]); - RecordedPlayerBufferExecCompleted(); + u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); + u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); + gBattleStruct->chosenItem[battler] = (byte1 << 8) | byte2; + gBattleStruct->itemPartyIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_TARGET, battler); + gBattleStruct->itemMoveIndex[battler] = RecordedBattle_GetBattlerAction(RECORDED_ITEM_MOVE, battler); + BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[battler]); + RecordedPlayerBufferExecCompleted(battler); } -static void RecordedPlayerHandleChoosePokemon(void) +static void RecordedPlayerHandleChoosePokemon(u32 battler) { - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, gActiveBattler); - gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[gActiveBattler]; // Revival Blessing - BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + gActiveBattler), NULL); - RecordedPlayerBufferExecCompleted(); + *(gBattleStruct->monToSwitchIntoId + battler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); + gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing + BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); + RecordedPlayerBufferExecCompleted(battler); } -static void RecordedPlayerHandleHealthBarUpdate(void) +static void RecordedPlayerHandleHealthBarUpdate(u32 battler) { s16 hpVal; s32 maxHP, curHP; LoadBattleBarGfx(0); - hpVal = gBattleResources->bufferA[gActiveBattler][2] | (gBattleResources->bufferA[gActiveBattler][3] << 8); + hpVal = gBattleResources->bufferA[battler][2] | (gBattleResources->bufferA[battler][3] << 8); - maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP); - curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP); + maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MAX_HP); + curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_HP); if (hpVal != INSTANT_HP_BAR_DROP) { - SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, curHP, hpVal); - TestRunner_Battle_RecordHP(gActiveBattler, curHP, min(maxHP, max(0, curHP - hpVal))); + SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, curHP, hpVal); + TestRunner_Battle_RecordHP(battler, curHP, min(maxHP, max(0, curHP - hpVal))); } else { - SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, 0, hpVal); - UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], HP_CURRENT, 0, maxHP); - TestRunner_Battle_RecordHP(gActiveBattler, curHP, 0); + SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, 0, hpVal); + UpdateHpTextInHealthbox(gHealthboxSpriteIds[battler], HP_CURRENT, 0, maxHP); + TestRunner_Battle_RecordHP(battler, curHP, 0); } - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForHealthBar; + gBattlerControllerFuncs[battler] = Controller_WaitForHealthBar; } -static void RecordedPlayerHandleStatusIconUpdate(void) +static void RecordedPlayerHandleStatusIconUpdate(u32 battler) { - if (!IsBattleSEPlaying(gActiveBattler)) + if (!IsBattleSEPlaying(battler)) { - DoStatusIconUpdate(gActiveBattler); + DoStatusIconUpdate(battler); if (gTestRunnerEnabled) - TestRunner_Battle_RecordStatus1(gActiveBattler, GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS)); + TestRunner_Battle_RecordStatus1(battler, GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS)); } } -static void RecordedPlayerHandleStatusAnimation(void) +static void RecordedPlayerHandleStatusAnimation(u32 battler) { - BtlController_HandleStatusAnimation(); + BtlController_HandleStatusAnimation(battler); } -static void RecordedPlayerHandleIntroTrainerBallThrow(void) +static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler) { u32 trainerPicId; const u32 *trainerPal; if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK) - trainerPicId = gLinkPlayers[GetBattlerMultiplayerId(gActiveBattler)].gender + TRAINER_BACK_PIC_BRENDAN; + trainerPicId = gLinkPlayers[GetBattlerMultiplayerId(battler)].gender + TRAINER_BACK_PIC_BRENDAN; else trainerPicId = gSaveBlock2Ptr->playerGender + TRAINER_BACK_PIC_BRENDAN; trainerPal = gTrainerFrontPicPaletteTable[trainerPicId].data; - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0xD6F9, trainerPal, 24, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Intro_TryShinyAnimShowHealthbox); } -static void RecordedPlayerHandleDrawPartyStatusSummary(void) +static void RecordedPlayerHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_PLAYER, TRUE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void RecordedPlayerHandleBattleAnimation(void) +static void RecordedPlayerHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, FALSE, FALSE); + BtlController_HandleBattleAnimation(battler, FALSE, FALSE); } -static void RecordedPlayerHandleEndLinkBattle(void) +static void RecordedPlayerHandleEndLinkBattle(u32 battler) { - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - RecordedPlayerBufferExecCompleted(); - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + RecordedPlayerBufferExecCompleted(battler); + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 569ba81fb..5f9183f1b 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -25,24 +25,24 @@ #include "constants/trainers.h" #include "constants/rgb.h" -static void SafariHandleDrawTrainerPic(void); -static void SafariHandleSuccessBallThrowAnim(void); -static void SafariHandleBallThrowAnim(void); -static void SafariHandlePrintString(void); -static void SafariHandlePrintSelectionString(void); -static void SafariHandleChooseAction(void); -static void SafariHandleChooseItem(void); -static void SafariHandleStatusIconUpdate(void); -static void SafariHandleFaintingCry(void); -static void SafariHandleIntroTrainerBallThrow(void); -static void SafariHandleBattleAnimation(void); -static void SafariHandleEndLinkBattle(void); +static void SafariHandleDrawTrainerPic(u32 battler); +static void SafariHandleSuccessBallThrowAnim(u32 battler); +static void SafariHandleBallThrowAnim(u32 battler); +static void SafariHandlePrintString(u32 battler); +static void SafariHandlePrintSelectionString(u32 battler); +static void SafariHandleChooseAction(u32 battler); +static void SafariHandleChooseItem(u32 battler); +static void SafariHandleStatusIconUpdate(u32 battler); +static void SafariHandleFaintingCry(u32 battler); +static void SafariHandleIntroTrainerBallThrow(u32 battler); +static void SafariHandleBattleAnimation(u32 battler); +static void SafariHandleEndLinkBattle(u32 battler); -static void SafariBufferRunCommand(void); -static void SafariBufferExecCompleted(void); -static void CompleteWhenChosePokeblock(void); +static void SafariBufferRunCommand(u32 battler); +static void SafariBufferExecCompleted(u32 battler); +static void CompleteWhenChosePokeblock(u32 battler); -static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_Empty, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -104,30 +104,30 @@ static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToSafari(void) +void SetControllerToSafari(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = SafariBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand; + gBattlerControllerEndFuncs[battler] = SafariBufferExecCompleted; + gBattlerControllerFuncs[battler] = SafariBufferRunCommand; } -static void SafariBufferRunCommand(void) +static void SafariBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sSafariBufferCommands)) - sSafariBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sSafariBufferCommands)) + sSafariBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); } } -static void HandleInputChooseAction(void) +static void HandleInputChooseAction(u32 battler) { if (JOY_NEW(A_BUTTON)) { PlaySE(SE_SELECT); - switch (gActionSelectionCursor[gActiveBattler]) + switch (gActionSelectionCursor[battler]) { case 0: BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_BALL, 0); @@ -142,57 +142,57 @@ static void HandleInputChooseAction(void) BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_RUN, 0); break; } - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); } else if (JOY_NEW(DPAD_LEFT)) { - if (gActionSelectionCursor[gActiveBattler] & 1) + if (gActionSelectionCursor[battler] & 1) { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 1; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_RIGHT)) { - if (!(gActionSelectionCursor[gActiveBattler] & 1)) + if (!(gActionSelectionCursor[battler] & 1)) { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 1; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 1; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_UP)) { - if (gActionSelectionCursor[gActiveBattler] & 2) + if (gActionSelectionCursor[battler] & 2) { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 2; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } else if (JOY_NEW(DPAD_DOWN)) { - if (!(gActionSelectionCursor[gActiveBattler] & 2)) + if (!(gActionSelectionCursor[battler] & 2)) { PlaySE(SE_SELECT); - ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]); - gActionSelectionCursor[gActiveBattler] ^= 2; - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]); + gActionSelectionCursor[battler] ^= 2; + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); } } } -static void Controller_WaitForHealthbox(void) +static void Controller_WaitForHealthbox(u32 battler) { - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) - SafariBufferExecCompleted(); + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) + SafariBufferExecCompleted(battler); } -static void SafariSetBattleEndCallbacks(void) +static void SafariSetBattleEndCallbacks(u32 battler) { if (!gPaletteFade.active) { @@ -202,140 +202,141 @@ static void SafariSetBattleEndCallbacks(void) } } -static void SafariOpenPokeblockCase(void) +static void SafariOpenPokeblockCase(u32 battler) { if (!gPaletteFade.active) { - gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChosePokeblock; + gBattlerControllerFuncs[battler] = CompleteWhenChosePokeblock; FreeAllWindowBuffers(); OpenPokeblockCaseInBattle(); } } -static void CompleteWhenChosePokeblock(void) +static void CompleteWhenChosePokeblock(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); } } -static void SafariBufferExecCompleted(void) +static void SafariBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand; + gBattlerControllerFuncs[battler] = SafariBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } -static void SafariHandleDrawTrainerPic(void) +static void SafariHandleDrawTrainerPic(u32 battler) { u32 trainerPicId = gSaveBlock2Ptr->playerGender + TRAINER_BACK_PIC_BRENDAN; - BtlController_HandleDrawTrainerPic(gActiveBattler, trainerPicId, FALSE, + BtlController_HandleDrawTrainerPic(battler, trainerPicId, FALSE, 80, 80 + 4 * (8 - gTrainerBackPicCoords[trainerPicId].size), 30); } -static void SafariHandleSuccessBallThrowAnim(void) +static void SafariHandleSuccessBallThrowAnim(u32 battler) { - BtlController_HandleSuccessBallThrowAnim(gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); + BtlController_HandleSuccessBallThrowAnim(battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); } -static void SafariHandleBallThrowAnim(void) +static void SafariHandleBallThrowAnim(u32 battler) { - BtlController_HandleBallThrowAnim(gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); + BtlController_HandleBallThrowAnim(battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); } -static void SafariHandlePrintString(void) +static void SafariHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, FALSE, FALSE); + BtlController_HandlePrintString(battler, FALSE, FALSE); } -static void SafariHandlePrintSelectionString(void) +static void SafariHandlePrintSelectionString(u32 battler) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) - SafariHandlePrintString(); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + SafariHandlePrintString(battler); else - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); } -static void HandleChooseActionAfterDma3(void) +static void HandleChooseActionAfterDma3(u32 battler) { if (!IsDma3ManagerBusyWithBgCopy()) { gBattle_BG0_X = 0; gBattle_BG0_Y = DISPLAY_HEIGHT; - gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseAction; + gBattlerControllerFuncs[battler] = HandleInputChooseAction; } } -static void SafariHandleChooseAction(void) +static void SafariHandleChooseAction(u32 battler) { s32 i; - gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3; + gBattlerControllerFuncs[battler] = HandleChooseActionAfterDma3; BattlePutTextOnWindow(gText_SafariZoneMenu, B_WIN_ACTION_MENU); for (i = 0; i < 4; i++) ActionSelectionDestroyCursorAt(i); - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo2); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT); } -static void SafariHandleChooseItem(void) +static void SafariHandleChooseItem(u32 battler) { BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); - gBattlerControllerFuncs[gActiveBattler] = SafariOpenPokeblockCase; - gBattlerInMenuId = gActiveBattler; + gBattlerControllerFuncs[battler] = SafariOpenPokeblockCase; + gBattlerInMenuId = battler; } -static void SafariHandleStatusIconUpdate(void) +static void SafariHandleStatusIconUpdate(u32 battler) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_BALLS_TEXT); - SafariBufferExecCompleted(); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_SAFARI_BALLS_TEXT); + SafariBufferExecCompleted(battler); } // All of the other controllers(except Wally's) use CRY_MODE_FAINT. // Player is not a pokemon, so it can't really faint in the Safari anyway. -static void SafariHandleFaintingCry(void) +static void SafariHandleFaintingCry(u32 battler) { - u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES); + u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES); PlayCry_Normal(species, 25); - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); + SafariBufferExecCompleted(battler); } -static void SafariHandleIntroTrainerBallThrow(void) +static void SafariHandleIntroTrainerBallThrow(u32 battler) { - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_ALL_TEXT); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForHealthbox; + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_SAFARI_ALL_TEXT); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); + gBattlerControllerFuncs[battler] = Controller_WaitForHealthbox; } -static void SafariHandleBattleAnimation(void) +static void SafariHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, TRUE, FALSE); + BtlController_HandleBattleAnimation(battler, TRUE, FALSE); } -static void SafariHandleEndLinkBattle(void) +static void SafariHandleEndLinkBattle(u32 battler) { - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - SafariBufferExecCompleted(); + SafariBufferExecCompleted(battler); if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)) - gBattlerControllerFuncs[gActiveBattler] = SafariSetBattleEndCallbacks; + gBattlerControllerFuncs[battler] = SafariSetBattleEndCallbacks; } diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 103b8b18a..cff966567 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -32,30 +32,30 @@ #include "constants/trainers.h" #include "constants/rgb.h" -static void WallyHandleDrawTrainerPic(void); -static void WallyHandleTrainerSlide(void); -static void WallyHandleSuccessBallThrowAnim(void); -static void WallyHandleBallThrowAnim(void); -static void WallyHandleMoveAnimation(void); -static void WallyHandlePrintString(void); -static void WallyHandlePrintSelectionString(void); -static void WallyHandleChooseAction(void); -static void WallyHandleChooseMove(void); -static void WallyHandleChooseItem(void); -static void WallyHandleHealthBarUpdate(void); -static void WallyHandlePlaySE(void); -static void WallyHandleFaintingCry(void); -static void WallyHandleIntroTrainerBallThrow(void); -static void WallyHandleDrawPartyStatusSummary(void); -static void WallyHandleBattleAnimation(void); -static void WallyHandleEndLinkBattle(void); +static void WallyHandleDrawTrainerPic(u32 battler); +static void WallyHandleTrainerSlide(u32 battler); +static void WallyHandleSuccessBallThrowAnim(u32 battler); +static void WallyHandleBallThrowAnim(u32 battler); +static void WallyHandleMoveAnimation(u32 battler); +static void WallyHandlePrintString(u32 battler); +static void WallyHandlePrintSelectionString(u32 battler); +static void WallyHandleChooseAction(u32 battler); +static void WallyHandleChooseMove(u32 battler); +static void WallyHandleChooseItem(u32 battler); +static void WallyHandleHealthBarUpdate(u32 battler); +static void WallyHandlePlaySE(u32 battler); +static void WallyHandleFaintingCry(u32 battler); +static void WallyHandleIntroTrainerBallThrow(u32 battler); +static void WallyHandleDrawPartyStatusSummary(u32 battler); +static void WallyHandleBattleAnimation(u32 battler); +static void WallyHandleEndLinkBattle(u32 battler); -static void WallyBufferRunCommand(void); -static void WallyBufferExecCompleted(void); -static void CompleteOnChosenItem(void); -static void Intro_WaitForShinyAnimAndHealthbox(void); +static void WallyBufferRunCommand(u32 battler); +static void WallyBufferExecCompleted(u32 battler); +static void CompleteOnChosenItem(u32 battler); +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler); -static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(void) = +static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -117,28 +117,28 @@ static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(void) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToWally(void) +void SetControllerToWally(u32 battler) { - gBattlerControllerEndFuncs[gActiveBattler] = WallyBufferExecCompleted; - gBattlerControllerFuncs[gActiveBattler] = WallyBufferRunCommand; + gBattlerControllerEndFuncs[battler] = WallyBufferExecCompleted; + gBattlerControllerFuncs[battler] = WallyBufferRunCommand; gBattleStruct->wallyBattleState = 0; gBattleStruct->wallyMovesState = 0; gBattleStruct->wallyWaitFrames = 0; gBattleStruct->wallyMoveFrames = 0; } -static void WallyBufferRunCommand(void) +static void WallyBufferRunCommand(u32 battler) { - if (gBattleControllerExecFlags & gBitTable[gActiveBattler]) + if (gBattleControllerExecFlags & gBitTable[battler]) { - if (gBattleResources->bufferA[gActiveBattler][0] < ARRAY_COUNT(sWallyBufferCommands)) - sWallyBufferCommands[gBattleResources->bufferA[gActiveBattler][0]](); + if (gBattleResources->bufferA[battler][0] < ARRAY_COUNT(sWallyBufferCommands)) + sWallyBufferCommands[gBattleResources->bufferA[battler][0]](battler); else - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } } -static void WallyHandleActions(void) +static void WallyHandleActions(u32 battler) { switch (gBattleStruct->wallyBattleState) { @@ -150,7 +150,7 @@ static void WallyHandleActions(void) { PlaySE(SE_SELECT); BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; gBattleStruct->wallyWaitFrames = B_WAIT_TIME_LONG; @@ -161,7 +161,7 @@ static void WallyHandleActions(void) { PlaySE(SE_SELECT); BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; gBattleStruct->wallyWaitFrames = B_WAIT_TIME_LONG; @@ -171,7 +171,7 @@ static void WallyHandleActions(void) if (--gBattleStruct->wallyWaitFrames == 0) { BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_WALLY_THROW, 0); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; gBattleStruct->wallyWaitFrames = B_WAIT_TIME_LONG; @@ -192,187 +192,181 @@ static void WallyHandleActions(void) { PlaySE(SE_SELECT); BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_ITEM, 0); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } break; } } -static void CompleteOnBattlerSpriteCallbackDummy(void) -{ - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) - WallyBufferExecCompleted(); -} - -static void OpenBagAfterPaletteFade(void) +static void OpenBagAfterPaletteFade(u32 battler) { if (!gPaletteFade.active) { - gBattlerControllerFuncs[gActiveBattler] = CompleteOnChosenItem; + gBattlerControllerFuncs[battler] = CompleteOnChosenItem; ReshowBattleScreenDummy(); FreeAllWindowBuffers(); DoWallyTutorialBagMenu(); } } -static void CompleteOnChosenItem(void) +static void CompleteOnChosenItem(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } } -static void Intro_TryShinyAnimShowHealthbox(void) +static void Intro_TryShinyAnimShowHealthbox(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive) - TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) + TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]); - if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive) - TryShinyAnimation(BATTLE_PARTNER(gActiveBattler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]]); + if (!gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive) + TryShinyAnimation(BATTLE_PARTNER(battler), &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]); - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive - && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].ballAnimActive - && gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy - && gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive + && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive + && gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy + && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(gActiveBattler)]]); - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)]], HEALTHBOX_ALL); - StartHealthboxSlideIn(BATTLE_PARTNER(gActiveBattler)); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(gActiveBattler)]); + DestroySprite(&gSprites[gBattleControllerData[BATTLE_PARTNER(battler)]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]], HEALTHBOX_ALL); + StartHealthboxSlideIn(BATTLE_PARTNER(battler)); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[BATTLE_PARTNER(battler)]); } - DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]); - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_ALL); - StartHealthboxSlideIn(gActiveBattler); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + DestroySprite(&gSprites[gBattleControllerData[battler]]); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_ALL); + StartHealthboxSlideIn(battler); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); gBattleSpritesDataPtr->animationData->introAnimActive = FALSE; - gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox; + gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox; } } -static void Intro_WaitForShinyAnimAndHealthbox(void) +static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) { bool32 healthboxAnimDone = FALSE; - if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) healthboxAnimDone = TRUE; - if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim - && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim) + if (healthboxAnimDone && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim + && gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].triedShinyMonAnim = FALSE; - gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(gActiveBattler)].finishedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].triedShinyMonAnim = FALSE; + gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].finishedShinyMonAnim = FALSE; FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS); FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS); CreateTask(Task_PlayerController_RestoreBgmAfterCry, 10); - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } } -static void WallyBufferExecCompleted(void) +static void WallyBufferExecCompleted(u32 battler) { - gBattlerControllerFuncs[gActiveBattler] = WallyBufferRunCommand; + gBattlerControllerFuncs[battler] = WallyBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { u8 playerId = GetMultiplayerId(); PrepareBufferDataTransferLink(2, 4, &playerId); - gBattleResources->bufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP; + gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else { - gBattleControllerExecFlags &= ~gBitTable[gActiveBattler]; + gBattleControllerExecFlags &= ~gBitTable[battler]; } } #define sSpeedX data[0] -static void WallyHandleDrawTrainerPic(void) +static void WallyHandleDrawTrainerPic(u32 battler) { - BtlController_HandleDrawTrainerPic(gActiveBattler, TRAINER_BACK_PIC_WALLY, FALSE, + BtlController_HandleDrawTrainerPic(battler, TRAINER_BACK_PIC_WALLY, FALSE, 80, 80 + 4 * (8 - gTrainerBackPicCoords[TRAINER_BACK_PIC_WALLY].size), 30); } -static void WallyHandleTrainerSlide(void) +static void WallyHandleTrainerSlide(u32 battler) { - BtlController_HandleTrainerSlide(gActiveBattler, TRAINER_BACK_PIC_WALLY); + BtlController_HandleTrainerSlide(battler, TRAINER_BACK_PIC_WALLY); } #undef sSpeedX -static void WallyHandleSuccessBallThrowAnim(void) +static void WallyHandleSuccessBallThrowAnim(u32 battler) { - BtlController_HandleSuccessBallThrowAnim(gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); + BtlController_HandleSuccessBallThrowAnim(battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); } -static void WallyHandleBallThrowAnim(void) +static void WallyHandleBallThrowAnim(u32 battler) { - BtlController_HandleBallThrowAnim(gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); + BtlController_HandleBallThrowAnim(battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW_WITH_TRAINER, FALSE); } -static void WallyHandleMoveAnimation(void) +static void WallyHandleMoveAnimation(u32 battler) { - BtlController_HandleMoveAnimation(gActiveBattler, FALSE); + BtlController_HandleMoveAnimation(battler, FALSE); } -static void WallyHandlePrintString(void) +static void WallyHandlePrintString(u32 battler) { - BtlController_HandlePrintString(gActiveBattler, FALSE, FALSE); + BtlController_HandlePrintString(battler, FALSE, FALSE); } -static void WallyHandlePrintSelectionString(void) +static void WallyHandlePrintSelectionString(u32 battler) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) - WallyHandlePrintString(); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + WallyHandlePrintString(battler); else - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } -static void HandleChooseActionAfterDma3(void) +static void HandleChooseActionAfterDma3(u32 battler) { if (!IsDma3ManagerBusyWithBgCopy()) { gBattle_BG0_X = 0; gBattle_BG0_Y = DISPLAY_HEIGHT; - gBattlerControllerFuncs[gActiveBattler] = WallyHandleActions; + gBattlerControllerFuncs[battler] = WallyHandleActions; } } -static void WallyHandleChooseAction(void) +static void WallyHandleChooseAction(u32 battler) { s32 i; - gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3; + gBattlerControllerFuncs[battler] = HandleChooseActionAfterDma3; BattlePutTextOnWindow(gText_BattleMenu, B_WIN_ACTION_MENU); for (i = 0; i < 4; i++) ActionSelectionDestroyCursorAt(i); - ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0); + ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0); BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillWallyDo); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT); } -static void WallyHandleChooseMove(void) +static void WallyHandleChooseMove(u32 battler) { switch (gBattleStruct->wallyMovesState) { case 0: - InitMoveSelectionsVarsAndStrings(); + InitMoveSelectionsVarsAndStrings(battler); gBattleStruct->wallyMovesState++; gBattleStruct->wallyMoveFrames = 80; break; @@ -389,64 +383,64 @@ static void WallyHandleChooseMove(void) { PlaySE(SE_SELECT); BtlController_EmitTwoReturnValues(BUFFER_B, 10, 0x100); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } break; } } -static void WallyHandleChooseItem(void) +static void WallyHandleChooseItem(u32 battler) { BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); - gBattlerControllerFuncs[gActiveBattler] = OpenBagAfterPaletteFade; - gBattlerInMenuId = gActiveBattler; + gBattlerControllerFuncs[battler] = OpenBagAfterPaletteFade; + gBattlerInMenuId = battler; } -static void WallyHandleHealthBarUpdate(void) +static void WallyHandleHealthBarUpdate(u32 battler) { - BtlController_HandleHealthBarUpdate(gActiveBattler, TRUE); + BtlController_HandleHealthBarUpdate(battler, TRUE); } // For some reason Wally's SE don't take side into account and pan is always the same. Possibly a bug -static void WallyHandlePlaySE(void) +static void WallyHandlePlaySE(u32 battler) { - PlaySE(gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8)); - WallyBufferExecCompleted(); + PlaySE(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); + WallyBufferExecCompleted(battler); } // All of the other controllers use CRY_MODE_FAINT. // Wally's Pokémon during the tutorial is never intended to faint, so that's probably why it's different here. -static void WallyHandleFaintingCry(void) +static void WallyHandleFaintingCry(u32 battler) { - u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES); + u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES); PlayCry_Normal(species, 25); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); } -static void WallyHandleIntroTrainerBallThrow(void) +static void WallyHandleIntroTrainerBallThrow(u32 battler) { const u32 *trainerPal = gTrainerBackPicPaletteTable[TRAINER_BACK_PIC_WALLY].data; - BtlController_HandleIntroTrainerBallThrow(gActiveBattler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); + BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); } -static void WallyHandleDrawPartyStatusSummary(void) +static void WallyHandleDrawPartyStatusSummary(u32 battler) { - BtlController_HandleDrawPartyStatusSummary(gActiveBattler, B_SIDE_PLAYER, FALSE); + BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, FALSE); } -static void WallyHandleBattleAnimation(void) +static void WallyHandleBattleAnimation(u32 battler) { - BtlController_HandleBattleAnimation(gActiveBattler, TRUE, FALSE); + BtlController_HandleBattleAnimation(battler, TRUE, FALSE); } -static void WallyHandleEndLinkBattle(void) +static void WallyHandleEndLinkBattle(u32 battler) { - gBattleOutcome = gBattleResources->bufferA[gActiveBattler][1]; + gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); BeginFastPaletteFade(3); - WallyBufferExecCompleted(); + WallyBufferExecCompleted(battler); if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER) && gBattleTypeFlags & BATTLE_TYPE_LINK) - gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks; + gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 4c1eb5e0e..08308046f 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -25,10 +25,13 @@ static EWRAM_DATA u8 sLinkSendTaskId = 0; static EWRAM_DATA u8 sLinkReceiveTaskId = 0; -EWRAM_DATA void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(void) = {NULL}; // Controller's buffer complete function for each battler EWRAM_DATA struct UnusedControllerStruct gUnusedControllerStruct = {}; // Debug? Unused code that writes to it, never read static EWRAM_DATA u8 sBattleBuffersTransferData[0x100] = {}; +void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler); +u8 gBattleControllerData[MAX_BATTLERS_COUNT]; // Used by the battle controllers to store misc sprite/task IDs for each battler +void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(u32 battler); // Controller's buffer complete function for each battler + static void CreateTasksForSendRecvLinkBuffers(void); static void InitLinkBtlControllers(void); static void InitSinglePlayerBtlControllers(void); @@ -1562,7 +1565,7 @@ void BtlController_EmitDebugMenu(u8 bufferId) // Can be used for all the controllers. void BattleControllerComplete(u32 battler) { - gBattlerControllerEndFuncs[battler](); + gBattlerControllerEndFuncs[battler](battler); } static u32 GetBattlerMonData(u32 battler, struct Pokemon *party, u32 monId, u8 *dst) @@ -2133,186 +2136,186 @@ static void FreeMonSprite(u32 battler) SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); } -static void Controller_ReturnMonToBall2(void) +static void Controller_ReturnMonToBall2(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { - FreeMonSprite(gActiveBattler); - BattleControllerComplete(gActiveBattler); + FreeMonSprite(battler); + BattleControllerComplete(battler); } } -static void Controller_ReturnMonToBall(void) +static void Controller_ReturnMonToBall(u32 battler) { - switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState) + switch (gBattleSpritesDataPtr->healthBoxesData[battler].animationState) { case 0: - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute) - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON); + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SUBSTITUTE_TO_MON); - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 1; break; case 1: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT) ? B_ANIM_SWITCH_OUT_OPPONENT_MON : B_ANIM_SWITCH_OUT_PLAYER_MON); - gBattlerControllerFuncs[gActiveBattler] = Controller_ReturnMonToBall2; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0; + InitAndLaunchSpecialAnimation(battler, battler, battler, (GetBattlerSide(battler) == B_SIDE_OPPONENT) ? B_ANIM_SWITCH_OUT_OPPONENT_MON : B_ANIM_SWITCH_OUT_PLAYER_MON); + gBattlerControllerFuncs[battler] = Controller_ReturnMonToBall2; } break; } } -static void Controller_FaintPlayerMon(void) +static void Controller_FaintPlayerMon(u32 battler) { - u32 spriteId = gBattlerSpriteIds[gActiveBattler]; + u32 spriteId = gBattlerSpriteIds[battler]; if (gSprites[spriteId].y + gSprites[spriteId].y2 > DISPLAY_HEIGHT) { - BattleGfxSfxDummy2(GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES)); + BattleGfxSfxDummy2(GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES)); FreeOamMatrix(gSprites[spriteId].oam.matrixNum); DestroySprite(&gSprites[spriteId]); - SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); - BattleControllerComplete(gActiveBattler); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); + BattleControllerComplete(battler); } } -static void Controller_FaintOpponentMon(void) +static void Controller_FaintOpponentMon(u32 battler) { - if (!gSprites[gBattlerSpriteIds[gActiveBattler]].inUse) + if (!gSprites[gBattlerSpriteIds[battler]].inUse) { - SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); - BattleControllerComplete(gActiveBattler); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); + BattleControllerComplete(battler); } } -static void Controller_DoMoveAnimation(void) +static void Controller_DoMoveAnimation(u32 battler) { - u16 move = gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8); + u16 move = gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8); - switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState) + switch (gBattleSpritesDataPtr->healthBoxesData[battler].animationState) { case 0: - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute - && !gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8) + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute + && !gBattleSpritesDataPtr->battlerData[battler].flag_x8) { - gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 1; - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON); + gBattleSpritesDataPtr->battlerData[battler].flag_x8 = 1; + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SUBSTITUTE_TO_MON); } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 1; break; case 1: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { SetBattlerSpriteAffineMode(ST_OAM_AFFINE_OFF); DoMoveAnim(move); - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 2; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 2; } break; case 2: gAnimScriptCallback(); if (!gAnimScriptActive) { - u8 multihit = gBattleResources->bufferA[gActiveBattler][11]; + u8 multihit = gBattleResources->bufferA[battler][11]; SetBattlerSpriteAffineMode(ST_OAM_AFFINE_NORMAL); - if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute && multihit < 2) + if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute && multihit < 2) { - InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE); - gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 0; + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE); + gBattleSpritesDataPtr->battlerData[battler].flag_x8 = 0; } - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 3; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 3; } break; case 3: - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { CopyAllBattleSpritesInvisibilities(); - TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8)); - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; - BattleControllerComplete(gActiveBattler); + TrySetBehindSubstituteSpriteBit(battler, gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0; + BattleControllerComplete(battler); } break; } } -static void Controller_HandleTrainerSlideBack(void) +static void Controller_HandleTrainerSlideBack(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT) - FreeTrainerFrontPicPalette(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.affineParam); - FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]); - DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]); - BattleControllerComplete(gActiveBattler); + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + FreeTrainerFrontPicPalette(gSprites[gBattlerSpriteIds[battler]].oam.affineParam); + FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[battler]]); + DestroySprite(&gSprites[gBattlerSpriteIds[battler]]); + BattleControllerComplete(battler); } } -void Controller_WaitForHealthBar(void) +void Controller_WaitForHealthBar(u32 battler) { - s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0); + s16 hpValue = MoveBattleBar(battler, gHealthboxSpriteIds[battler], HEALTH_BAR, 0); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); if (hpValue != -1) { - UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], HP_CURRENT, hpValue, gBattleMons[gActiveBattler].maxHP); + UpdateHpTextInHealthbox(gHealthboxSpriteIds[battler], HP_CURRENT, hpValue, gBattleMons[battler].maxHP); } else { - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) - HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - BattleControllerComplete(gActiveBattler); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); + BattleControllerComplete(battler); } } -static void Controller_WaitForBallThrow(void) +static void Controller_WaitForBallThrow(u32 battler) { - if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive) - BattleControllerComplete(gActiveBattler); + if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) + BattleControllerComplete(battler); } -static void Controller_WaitForBattleAnimation(void) +static void Controller_WaitForBattleAnimation(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive) - BattleControllerComplete(gActiveBattler); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].animFromTableActive) + BattleControllerComplete(battler); } -static void Controller_WaitForStatusAnimation(void) +static void Controller_WaitForStatusAnimation(u32 battler) { - if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive) - BattleControllerComplete(gActiveBattler); + if (!gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive) + BattleControllerComplete(battler); } -static void Controller_WaitForTrainerPic(void) +static void Controller_WaitForTrainerPic(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy) - BattleControllerComplete(gActiveBattler); + if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) + BattleControllerComplete(battler); } -void Controller_WaitForString(void) +void Controller_WaitForString(u32 battler) { if (!IsTextPrinterActive(B_WIN_MSG)) - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -static void Controller_WaitForPartyStatusSummary(void) +static void Controller_WaitForPartyStatusSummary(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer++ > 92) + if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer++ > 92) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0; - BattleControllerComplete(gActiveBattler); + gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer = 0; + BattleControllerComplete(battler); } } -static void Controller_HitAnimation(void) +static void Controller_HitAnimation(u32 battler) { - u32 spriteId = gBattlerSpriteIds[gActiveBattler]; + u32 spriteId = gBattlerSpriteIds[battler]; if (gSprites[spriteId].data[1] == 32) { gSprites[spriteId].data[1] = 0; gSprites[spriteId].invisible = FALSE; gDoingBattleAnim = FALSE; - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } else { @@ -2323,21 +2326,24 @@ static void Controller_HitAnimation(void) } // Used for all the commands which do nothing. -void BtlController_Empty(void) +void BtlController_Empty(u32 battler) { - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } // Dummy function at the end of the table. -void BtlController_TerminatorNop(void) +void BtlController_TerminatorNop(u32 battler) +{ +} + +void BattleControllerDummy(u32 battler) { } // Handlers of the controller commands -void BtlController_HandleGetMonData(void) +void BtlController_HandleGetMonData(u32 battler) { 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 battler = gActiveBattler; struct Pokemon *party = GetBattlerParty(battler); u32 size = 0; u8 monToCheck; @@ -2361,10 +2367,9 @@ void BtlController_HandleGetMonData(void) BattleControllerComplete(battler); } -void BtlController_HandleGetRawMonData(void) +void BtlController_HandleGetRawMonData(u32 battler) { struct BattlePokemon battleMon; - u32 battler = gActiveBattler; struct Pokemon *party = GetBattlerParty(battler); u8 *src = (u8 *)&party[gBattlerPartyIndexes[battler]] + gBattleResources->bufferA[battler][1]; @@ -2378,9 +2383,8 @@ void BtlController_HandleGetRawMonData(void) BattleControllerComplete(battler); } -void BtlController_HandleSetMonData(void) +void BtlController_HandleSetMonData(u32 battler) { - u32 battler = gActiveBattler; struct Pokemon *party = GetBattlerParty(battler); u32 i, monToCheck; @@ -2401,10 +2405,9 @@ void BtlController_HandleSetMonData(void) BattleControllerComplete(battler); } -void BtlController_HandleSetRawMonData(void) +void BtlController_HandleSetRawMonData(u32 battler) { u32 i; - u32 battler = gActiveBattler; struct Pokemon *party = GetBattlerParty(battler); u8 *dst = (u8 *)&party[gBattlerPartyIndexes[battler]] + gBattleResources->bufferA[battler][1]; @@ -2414,7 +2417,7 @@ void BtlController_HandleSetRawMonData(void) BattleControllerComplete(battler); } -void BtlController_HandleLoadMonSprite(u32 battler, struct Pokemon *party, void (*controllerCallback)(void)) +void BtlController_HandleLoadMonSprite(u32 battler, struct Pokemon *party, void (*controllerCallback)(u32 battler)) { u16 species = GetMonData(&party[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES); @@ -2437,7 +2440,7 @@ void BtlController_HandleLoadMonSprite(u32 battler, struct Pokemon *party, void gBattlerControllerFuncs[battler] = controllerCallback; } -void BtlController_HandleSwitchInAnim(u32 battler, bool32 isPlayerSide, void (*controllerCallback)(void)) +void BtlController_HandleSwitchInAnim(u32 battler, bool32 isPlayerSide, void (*controllerCallback)(u32 battler)) { if (isPlayerSide) ClearTemporarySpeciesSpriteData(battler, gBattleResources->bufferA[battler][2]); @@ -2448,17 +2451,17 @@ void BtlController_HandleSwitchInAnim(u32 battler, bool32 isPlayerSide, void (*c gBattlerControllerFuncs[battler] = controllerCallback; } -void BtlController_HandleReturnMonToBall(void) +void BtlController_HandleReturnMonToBall(u32 battler) { - if (gBattleResources->bufferA[gActiveBattler][1] == 0) + if (gBattleResources->bufferA[battler][1] == 0) { - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0; - gBattlerControllerFuncs[gActiveBattler] = Controller_ReturnMonToBall; + gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0; + gBattlerControllerFuncs[battler] = Controller_ReturnMonToBall; } else { - FreeMonSprite(gActiveBattler); - BattleControllerComplete(gActiveBattler); + FreeMonSprite(battler); + BattleControllerComplete(battler); } } @@ -2578,9 +2581,8 @@ void BtlController_HandleTrainerSlideBack(u32 battlerId, s16 data0, bool32 start #define sSpeedX data[1] #define sSpeedY data[2] -void BtlController_HandleFaintAnimation(void) +void BtlController_HandleFaintAnimation(u32 battler) { - u32 battler = gActiveBattler; if (gBattleSpritesDataPtr->healthBoxesData[battler].animationState == 0) { if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) @@ -2711,92 +2713,92 @@ void DoStatusIconUpdate(u32 battler) gBattlerControllerFuncs[battler] = Controller_WaitForStatusAnimation; } -void BtlController_HandleStatusIconUpdate(void) +void BtlController_HandleStatusIconUpdate(u32 battler) { - if (!IsBattleSEPlaying(gActiveBattler)) + if (!IsBattleSEPlaying(battler)) { - DoStatusIconUpdate(gActiveBattler); + DoStatusIconUpdate(battler); } } -void BtlController_HandleStatusAnimation(void) +void BtlController_HandleStatusAnimation(u32 battler) { - if (!IsBattleSEPlaying(gActiveBattler)) + if (!IsBattleSEPlaying(battler)) { - InitAndLaunchChosenStatusAnimation(gBattleResources->bufferA[gActiveBattler][1], - gBattleResources->bufferA[gActiveBattler][2] | (gBattleResources->bufferA[gActiveBattler][3] << 8) | (gBattleResources->bufferA[gActiveBattler][4] << 16) | (gBattleResources->bufferA[gActiveBattler][5] << 24)); - gBattlerControllerFuncs[gActiveBattler] = Controller_WaitForStatusAnimation; + InitAndLaunchChosenStatusAnimation(gBattleResources->bufferA[battler][1], + gBattleResources->bufferA[battler][2] | (gBattleResources->bufferA[battler][3] << 8) | (gBattleResources->bufferA[battler][4] << 16) | (gBattleResources->bufferA[battler][5] << 24)); + gBattlerControllerFuncs[battler] = Controller_WaitForStatusAnimation; } } -void BtlController_HandleClearUnkVar(void) +void BtlController_HandleClearUnkVar(u32 battler) { gUnusedControllerStruct.unk = 0; - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -void BtlController_HandleSetUnkVar(void) +void BtlController_HandleSetUnkVar(u32 battler) { - gUnusedControllerStruct.unk = gBattleResources->bufferA[gActiveBattler][1]; - BattleControllerComplete(gActiveBattler); + gUnusedControllerStruct.unk = gBattleResources->bufferA[battler][1]; + BattleControllerComplete(battler); } -void BtlController_HandleClearUnkFlag(void) +void BtlController_HandleClearUnkFlag(u32 battler) { gUnusedControllerStruct.flag = 0; - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -void BtlController_HandleToggleUnkFlag(void) +void BtlController_HandleToggleUnkFlag(u32 battler) { gUnusedControllerStruct.flag ^= 1; - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -void BtlController_HandleHitAnimation(void) +void BtlController_HandleHitAnimation(u32 battler) { - if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE) + if (gSprites[gBattlerSpriteIds[battler]].invisible == TRUE) { - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } else { gDoingBattleAnim = TRUE; - gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0; - DoHitAnimHealthboxEffect(gActiveBattler); - gBattlerControllerFuncs[gActiveBattler] = Controller_HitAnimation; + gSprites[gBattlerSpriteIds[battler]].data[1] = 0; + DoHitAnimHealthboxEffect(battler); + gBattlerControllerFuncs[battler] = Controller_HitAnimation; } } -void BtlController_HandlePlaySE(void) +void BtlController_HandlePlaySE(u32 battler) { - s8 pan = (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) ? SOUND_PAN_ATTACKER : SOUND_PAN_TARGET; + s8 pan = (GetBattlerSide(battler) == B_SIDE_PLAYER) ? SOUND_PAN_ATTACKER : SOUND_PAN_TARGET; - PlaySE12WithPanning(gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8), pan); - BattleControllerComplete(gActiveBattler); + PlaySE12WithPanning(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8), pan); + BattleControllerComplete(battler); } -void BtlController_HandlePlayFanfareOrBGM(void) +void BtlController_HandlePlayFanfareOrBGM(u32 battler) { - if (gBattleResources->bufferA[gActiveBattler][3]) + if (gBattleResources->bufferA[battler][3]) { BattleStopLowHpSound(); - PlayBGM(gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8)); + PlayBGM(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); } else { - PlayFanfare(gBattleResources->bufferA[gActiveBattler][1] | (gBattleResources->bufferA[gActiveBattler][2] << 8)); + PlayFanfare(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); } - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -void BtlController_HandleFaintingCry(void) +void BtlController_HandleFaintingCry(u32 battler) { struct Pokemon *party; s8 pan; - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) { party = gPlayerParty; pan = -25; @@ -2807,25 +2809,25 @@ void BtlController_HandleFaintingCry(void) pan = 25; } - PlayCry_ByMode(GetMonData(&party[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES), pan, CRY_MODE_FAINT); - BattleControllerComplete(gActiveBattler); + PlayCry_ByMode(GetMonData(&party[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES), pan, CRY_MODE_FAINT); + BattleControllerComplete(battler); } -void BtlController_HandleIntroSlide(void) +void BtlController_HandleIntroSlide(u32 battler) { - HandleIntroSlide(gBattleResources->bufferA[gActiveBattler][1]); + HandleIntroSlide(gBattleResources->bufferA[battler][1]); gIntroSlideFlags |= 1; - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } -void BtlController_HandleSpriteInvisibility(void) +void BtlController_HandleSpriteInvisibility(u32 battler) { - if (IsBattlerSpritePresent(gActiveBattler)) + if (IsBattlerSpritePresent(battler)) { - gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleResources->bufferA[gActiveBattler][1]; - CopyBattleSpriteInvisibility(gActiveBattler); + gSprites[gBattlerSpriteIds[battler]].invisible = gBattleResources->bufferA[battler][1]; + CopyBattleSpriteInvisibility(battler); } - BattleControllerComplete(gActiveBattler); + BattleControllerComplete(battler); } bool32 TwoPlayerIntroMons(u32 battler) // Double battle with both player pokemon active. @@ -2850,7 +2852,7 @@ bool32 TwoOpponentIntroMons(u32 battler) // Double battle with both opponent pok // Sprite data for SpriteCB_FreePlayerSpriteLoadMonSprite #define sBattlerId data[5] -void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u32 *trainerPal, s16 framesToWait, void (*controllerCallback)(void)) +void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u32 *trainerPal, s16 framesToWait, void (*controllerCallback)(u32 battler)) { u8 paletteNum, taskId; u32 side = GetBattlerSide(battler); @@ -2863,8 +2865,8 @@ void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, c } else { - gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 35; - gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 280; + gSprites[gBattlerSpriteIds[battler]].data[0] = 35; + gSprites[gBattlerSpriteIds[battler]].data[2] = 280; } gSprites[gBattlerSpriteIds[battler]].data[4] = gSprites[gBattlerSpriteIds[battler]].y; @@ -3014,11 +3016,11 @@ void BtlController_HandleDrawPartyStatusSummary(u32 battler, u32 side, bool32 co } } -void BtlController_HandleHidePartyStatusSummary(void) +void BtlController_HandleHidePartyStatusSummary(u32 battler) { - if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown) - gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary; - BattleControllerComplete(gActiveBattler); + if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown) + gTasks[gBattlerStatusSummaryTaskId[battler]].func = Task_HidePartyStatusSummary; + BattleControllerComplete(battler); } void BtlController_HandleBattleAnimation(u32 battler, bool32 ignoreSE, bool32 updateTvData) diff --git a/src/battle_main.c b/src/battle_main.c index 77499d6e0..2f2d3fffa 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -249,11 +249,9 @@ void (*gPreBattleCallback1)(void); void (*gBattleMainFunc)(void); struct BattleResults gBattleResults; u8 gLeveledUpInBattle; -void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void); u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT]; u8 gMultiUsePlayerCursor; u8 gNumberOfMovesToChoose; -u8 gBattleControllerData[MAX_BATTLERS_COUNT]; // Used by the battle controllers to store misc sprite/task IDs for each battler static const struct ScanlineEffectParams sIntroScanlineParams16Bit = { @@ -3076,7 +3074,7 @@ static void BattleMainCB1(void) gBattleMainFunc(); for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) - gBattlerControllerFuncs[gActiveBattler](); + gBattlerControllerFuncs[gActiveBattler](gActiveBattler); } static void BattleStartClearSetData(void) diff --git a/sym_common.txt b/sym_common.txt index 7eebcac74..170aee2f4 100644 --- a/sym_common.txt +++ b/sym_common.txt @@ -37,6 +37,7 @@ gReservedSpritePaletteCount: .include "link_rfu_2.o" .include "rtc.o" .include "battle_main.o" + .include "battle_controllers.o" .include "random.o" .include "load_save.o" .include "berry_blender.o"