From 156aa59f18db673cae2381eb2c1d039cbe386e65 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 29 Aug 2023 15:21:31 +0200 Subject: [PATCH] start removing gActiveBattler in controller emitters --- include/battle.h | 1 + include/battle_ai_switch_items.h | 6 +- include/battle_controllers.h | 88 +- include/pokeball.h | 2 +- src/battle_ai_main.c | 6 +- src/battle_ai_switch_items.c | 490 +++--- src/battle_ai_util.c | 2 +- src/battle_controller_link_opponent.c | 2 +- src/battle_controller_link_partner.c | 2 +- src/battle_controller_opponent.c | 34 +- src/battle_controller_player.c | 121 +- src/battle_controller_player_partner.c | 12 +- src/battle_controller_recorded_opponent.c | 12 +- src/battle_controller_recorded_player.c | 14 +- src/battle_controller_safari.c | 12 +- src/battle_controller_wally.c | 14 +- src/battle_controllers.c | 771 +++++----- src/battle_main.c | 159 +- src/battle_script_commands.c | 1665 ++++++++++----------- src/battle_util.c | 1609 ++++++++++---------- src/battle_util2.c | 49 +- src/pokeball.c | 6 +- 22 files changed, 2484 insertions(+), 2593 deletions(-) diff --git a/include/battle.h b/include/battle.h index 1fe0ed4ef7..d7ab162a41 100644 --- a/include/battle.h +++ b/include/battle.h @@ -352,6 +352,7 @@ struct BattleResources struct BattleHistory *battleHistory; u8 bufferA[MAX_BATTLERS_COUNT][0x200]; u8 bufferB[MAX_BATTLERS_COUNT][0x200]; + u8 transferBuffer[0x100]; }; #define AI_THINKING_STRUCT ((struct AI_ThinkingStruct *)(gBattleResources->ai)) diff --git a/include/battle_ai_switch_items.h b/include/battle_ai_switch_items.h index 622593b6dd..9a7e5f7e74 100644 --- a/include/battle_ai_switch_items.h +++ b/include/battle_ai_switch_items.h @@ -2,8 +2,8 @@ #define GUARD_BATTLE_AI_SWITCH_ITEMS_H void GetAIPartyIndexes(u32 battlerId, s32 *firstId, s32 *lastId); -void AI_TrySwitchOrUseItem(void); -u8 GetMostSuitableMonToSwitchInto(void); -bool32 ShouldSwitch(void); +void AI_TrySwitchOrUseItem(u32 battler); +u8 GetMostSuitableMonToSwitchInto(u32 battler); +bool32 ShouldSwitch(u32 battler); #endif // GUARD_BATTLE_AI_SWITCH_ITEMS_H diff --git a/include/battle_controllers.h b/include/battle_controllers.h index ff4a8c6e59..3440a73dc0 100644 --- a/include/battle_controllers.h +++ b/include/battle_controllers.h @@ -207,52 +207,52 @@ void SetUpBattleVarsAndBirchZigzagoon(void); void InitBattleControllers(void); bool32 IsValidForBattle(struct Pokemon *mon); void TryReceiveLinkBattleData(void); -void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data); +void PrepareBufferDataTransferLink(u32 battler, u32 bufferId, u16 size, u8 *data); // emitters -void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck); -void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data); -void BtlController_EmitLoadMonSprite(u8 bufferId); -void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit); -void BtlController_EmitReturnMonToBall(u8 bufferId, bool8 skipAnim); -void BtlController_EmitDrawTrainerPic(u8 bufferId); -void BtlController_EmitTrainerSlide(u8 bufferId); -void BtlController_EmitTrainerSlideBack(u8 bufferId); -void BtlController_EmitFaintAnimation(u8 bufferId); -void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId); -void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit); -void BtlController_EmitPrintString(u8 bufferId, u16 stringId); -void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringId); -void BtlController_EmitChooseAction(u8 bufferId, u8 action, u16 itemId); -void BtlController_EmitYesNoBox(u8 bufferId); -void BtlController_EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData); -void BtlController_EmitChooseItem(u8 bufferId, u8 *battlePartyOrder); -void BtlController_EmitChoosePokemon(u8 bufferId, u8 caseId, u8 slotId, u16 abilityId, u8 *data); -void BtlController_EmitHealthBarUpdate(u8 bufferId, u16 hpValue); -void BtlController_EmitExpUpdate(u8 bufferId, u8 partyId, s32 expPoints); -void BtlController_EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2); -void BtlController_EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status); -void BtlController_EmitDataTransfer(u8 bufferId, u16 size, void *data); -void BtlController_EmitTwoReturnValues(u8 bufferId, u8 ret8, u32 ret32); -void BtlController_EmitChosenMonReturnValue(u8 bufferId, u8 partyId, u8 *battlePartyOrder); -void BtlController_EmitOneReturnValue(u8 bufferId, u16 ret); -void BtlController_EmitOneReturnValue_Duplicate(u8 bufferId, u16 ret); -void BtlController_EmitHitAnimation(u8 bufferId); -void BtlController_EmitCantSwitch(u8 bufferId); -void BtlController_EmitPlaySE(u8 bufferId, u16 songId); -void BtlController_EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM); -void BtlController_EmitFaintingCry(u8 bufferId); -void BtlController_EmitIntroSlide(u8 bufferId, u8 terrainId); -void BtlController_EmitIntroTrainerBallThrow(u8 bufferId); -void BtlController_EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 flags); -void BtlController_EmitHidePartyStatusSummary(u8 bufferId); -void BtlController_EmitEndBounceEffect(u8 bufferId); -void BtlController_EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible); -void BtlController_EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument); -void BtlController_EmitLinkStandbyMsg(u8 bufferId, u8 mode, bool32 record); -void BtlController_EmitResetActionMoveSelection(u8 bufferId, u8 caseId); -void BtlController_EmitEndLinkBattle(u8 bufferId, u8 battleOutcome); -void BtlController_EmitDebugMenu(u8 bufferId); +void BtlController_EmitGetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck); +void BtlController_EmitSetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data); +void BtlController_EmitLoadMonSprite(u32 battler, u32 bufferId); +void BtlController_EmitSwitchInAnim(u32 battler, u32 bufferId, u8 partyId, bool8 dontClearSubstituteBit); +void BtlController_EmitReturnMonToBall(u32 battler, u32 bufferId, bool8 skipAnim); +void BtlController_EmitDrawTrainerPic(u32 battler, u32 bufferId); +void BtlController_EmitTrainerSlide(u32 battler, u32 bufferId); +void BtlController_EmitTrainerSlideBack(u32 battler, u32 bufferId); +void BtlController_EmitFaintAnimation(u32 battler, u32 bufferId); +void BtlController_EmitBallThrowAnim(u32 battler, u32 bufferId, u8 caseId); +void BtlController_EmitMoveAnimation(u32 battler, u32 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit); +void BtlController_EmitPrintString(u32 battler, u32 bufferId, u16 stringId); +void BtlController_EmitPrintSelectionString(u32 battler, u32 bufferId, u16 stringId); +void BtlController_EmitChooseAction(u32 battler, u32 bufferId, u8 action, u16 itemId); +void BtlController_EmitYesNoBox(u32 battler, u32 bufferId); +void BtlController_EmitChooseMove(u32 battler, u32 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData); +void BtlController_EmitChooseItem(u32 battler, u32 bufferId, u8 *battlePartyOrder); +void BtlController_EmitChoosePokemon(u32 battler, u32 bufferId, u8 caseId, u8 slotId, u16 abilityId, u8 *data); +void BtlController_EmitHealthBarUpdate(u32 battler, u32 bufferId, u16 hpValue); +void BtlController_EmitExpUpdate(u32 battler, u32 bufferId, u8 partyId, s32 expPoints); +void BtlController_EmitStatusIconUpdate(u32 battler, u32 bufferId, u32 status1, u32 status2); +void BtlController_EmitStatusAnimation(u32 battler, u32 bufferId, bool8 status2, u32 status); +void BtlController_EmitDataTransfer(u32 battler, u32 bufferId, u16 size, void *data); +void BtlController_EmitTwoReturnValues(u32 battler, u32 bufferId, u8 ret8, u32 ret32); +void BtlController_EmitChosenMonReturnValue(u32 battler, u32 bufferId, u8 partyId, u8 *battlePartyOrder); +void BtlController_EmitOneReturnValue(u32 battler, u32 bufferId, u16 ret); +void BtlController_EmitOneReturnValue_Duplicate(u32 battler, u32 bufferId, u16 ret); +void BtlController_EmitHitAnimation(u32 battler, u32 bufferId); +void BtlController_EmitCantSwitch(u32 battler, u32 bufferId); +void BtlController_EmitPlaySE(u32 battler, u32 bufferId, u16 songId); +void BtlController_EmitPlayFanfareOrBGM(u32 battler, u32 bufferId, u16 songId, bool8 playBGM); +void BtlController_EmitFaintingCry(u32 battler, u32 bufferId); +void BtlController_EmitIntroSlide(u32 battler, u32 bufferId, u8 terrainId); +void BtlController_EmitIntroTrainerBallThrow(u32 battler, u32 bufferId); +void BtlController_EmitDrawPartyStatusSummary(u32 battler, u32 bufferId, struct HpAndStatus* hpAndStatus, u8 flags); +void BtlController_EmitHidePartyStatusSummary(u32 battler, u32 bufferId); +void BtlController_EmitEndBounceEffect(u32 battler, u32 bufferId); +void BtlController_EmitSpriteInvisibility(u32 battler, u32 bufferId, bool8 isInvisible); +void BtlController_EmitBattleAnimation(u32 battler, u32 bufferId, u8 animationId, u16 argument); +void BtlController_EmitLinkStandbyMsg(u32 battler, u32 bufferId, u8 mode, bool32 record); +void BtlController_EmitResetActionMoveSelection(u32 battler, u32 bufferId, u8 caseId); +void BtlController_EmitEndLinkBattle(u32 battler, u32 bufferId, u8 battleOutcome); +void BtlController_EmitDebugMenu(u32 battler, u32 bufferId); void BattleControllerComplete(u32 battler); // Can be used for all the controllers. void BtlController_Empty(u32 battler); // Empty command, does nothing, only completes the execution. diff --git a/include/pokeball.h b/include/pokeball.h index 602e9f9736..498fa4dd1c 100644 --- a/include/pokeball.h +++ b/include/pokeball.h @@ -48,7 +48,7 @@ extern const struct SpriteTemplate gBallSpriteTemplates[]; #define POKEBALL_PLAYER_SENDOUT 0xFF #define POKEBALL_OPPONENT_SENDOUT 0xFE -u8 DoPokeballSendOutAnimation(s16 pan, u8 kindOfThrow); +u8 DoPokeballSendOutAnimation(u32 battler, s16 pan, u8 kindOfThrow); void CreatePokeballSpriteToReleaseMon(u8 monSpriteId, u8 monPalNum, u8 x, u8 y, u8 oamPriority, u8 subpriority, u8 delay, u32 fadePalettes, u16 species); u8 CreateTradePokeballSprite(u8 monSpriteId, u8 monPalNum, u8 x, u8 y, u8 oamPriority, u8 subPriority, u8 delay, u32 fadePalettes); void StartHealthboxSlideIn(u8 battler); diff --git a/src/battle_ai_main.c b/src/battle_ai_main.c index 672f24351b..8caacb0194 100644 --- a/src/battle_ai_main.c +++ b/src/battle_ai_main.c @@ -455,7 +455,7 @@ static u8 ChooseMoveOrAction_Singles(void) break; } - if (i == MAX_MON_MOVES && GetMostSuitableMonToSwitchInto() != PARTY_SIZE) + if (i == MAX_MON_MOVES && GetMostSuitableMonToSwitchInto(sBattler_AI) != PARTY_SIZE) { AI_THINKING_STRUCT->switchMon = TRUE; return AI_CHOICE_SWITCH; @@ -469,7 +469,7 @@ static u8 ChooseMoveOrAction_Singles(void) && gDisableStructs[sBattler_AI].truantCounter && gBattleMons[sBattler_AI].hp >= gBattleMons[sBattler_AI].maxHP / 2) { - if (GetMostSuitableMonToSwitchInto() != PARTY_SIZE) + if (GetMostSuitableMonToSwitchInto(sBattler_AI) != PARTY_SIZE) { AI_THINKING_STRUCT->switchMon = TRUE; return AI_CHOICE_SWITCH; @@ -3727,7 +3727,7 @@ static s16 AI_CheckViability(u8 battlerAtk, u8 battlerDef, u16 move, s16 score) } break; case EFFECT_BATON_PASS: - if (ShouldSwitch() && (gBattleMons[battlerAtk].status2 & STATUS2_SUBSTITUTE + if (ShouldSwitch(battlerAtk) && (gBattleMons[battlerAtk].status2 & STATUS2_SUBSTITUTE || (gStatuses3[battlerAtk] & (STATUS3_ROOTED | STATUS3_AQUA_RING | STATUS3_MAGNET_RISE | STATUS3_POWER_TRICK)) || AnyStatIsRaised(battlerAtk))) score += 5; diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index 0045608b08..ff878aecfe 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -22,32 +22,32 @@ #include "constants/moves.h" // this file's functions -static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng); -static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent); -static bool8 ShouldUseItem(void); -static bool32 AiExpectsToFaintPlayer(void); -static bool32 AI_ShouldHeal(u32 healAmount); -static bool32 AI_OpponentCanFaintAiWithMod(u32 healAmount); -static bool32 IsAiPartyMonOHKOBy(u32 battlerAtk, struct Pokemon *aiMon); +static bool8 HasSuperEffectiveMoveAgainstOpponents(u32 battler, bool8 noRng); +static bool8 FindMonWithFlagsAndSuperEffective(u32 battler, u16 flags, u8 moduloPercent); +static bool8 ShouldUseItem(u32 battler); +static bool32 AiExpectsToFaintPlayer(u32 battler); +static bool32 AI_ShouldHeal(u32 battler, u32 healAmount); +static bool32 AI_OpponentCanFaintAiWithMod(u32 battler, u32 healAmount); +static bool32 IsAiPartyMonOHKOBy(u32 battlerAi, u32 battlerAtk, struct Pokemon *aiMon); -static bool32 IsAceMon(u32 battlerId, u32 monPartyId) +static bool32 IsAceMon(u32 battler, u32 monPartyId) { if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_ACE_POKEMON - && !(gBattleStruct->forcedSwitch & gBitTable[battlerId]) + && !(gBattleStruct->forcedSwitch & gBitTable[battler]) && monPartyId == CalculateEnemyPartyCount()-1) return TRUE; return FALSE; } -void GetAIPartyIndexes(u32 battlerId, s32 *firstId, s32 *lastId) +void GetAIPartyIndexes(u32 battler, s32 *firstId, s32 *lastId) { - if (BATTLE_TWO_VS_ONE_OPPONENT && (battlerId & BIT_SIDE) == B_SIDE_OPPONENT) + if (BATTLE_TWO_VS_ONE_OPPONENT && (battler & BIT_SIDE) == B_SIDE_OPPONENT) { *firstId = 0, *lastId = PARTY_SIZE; } else if (gBattleTypeFlags & (BATTLE_TYPE_TWO_OPPONENTS | BATTLE_TYPE_INGAME_PARTNER | BATTLE_TYPE_TOWER_LINK_MULTI)) { - if ((battlerId & BIT_FLANK) == B_FLANK_LEFT) + if ((battler & BIT_FLANK) == B_FLANK_LEFT) *firstId = 0, *lastId = PARTY_SIZE / 2; else *firstId = PARTY_SIZE / 2, *lastId = PARTY_SIZE; @@ -58,13 +58,13 @@ void GetAIPartyIndexes(u32 battlerId, s32 *firstId, s32 *lastId) } } -static bool8 ShouldSwitchIfAllBadMoves(void) +static bool8 ShouldSwitchIfAllBadMoves(u32 battler) { if (gBattleResources->ai->switchMon) { gBattleResources->ai->switchMon = 0; - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = PARTY_SIZE; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); return TRUE; } else @@ -73,7 +73,7 @@ static bool8 ShouldSwitchIfAllBadMoves(void) } } -static bool8 ShouldSwitchIfWonderGuard(void) +static bool8 ShouldSwitchIfWonderGuard(u32 battler) { u8 opposingPosition; u8 opposingBattler; @@ -86,7 +86,7 @@ static bool8 ShouldSwitchIfWonderGuard(void) if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) return FALSE; - opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler)); + opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); if (GetBattlerAbility(GetBattlerAtPosition(opposingPosition)) != ABILITY_WONDER_GUARD) return FALSE; @@ -94,18 +94,18 @@ static bool8 ShouldSwitchIfWonderGuard(void) // Check if Pokemon has a super effective move. for (opposingBattler = GetBattlerAtPosition(opposingPosition), i = 0; i < MAX_MON_MOVES; i++) { - move = gBattleMons[gActiveBattler].moves[i]; + move = gBattleMons[battler].moves[i]; if (move != MOVE_NONE) { - if (AI_GetTypeEffectiveness(move, gActiveBattler, opposingBattler) >= UQ_4_12(2.0)) + if (AI_GetTypeEffectiveness(move, battler, opposingBattler) >= UQ_4_12(2.0)) return FALSE; } } // Get party information. - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -115,9 +115,9 @@ static bool8 ShouldSwitchIfWonderGuard(void) { if (!IsValidForBattle(&party[i])) continue; - if (i == gBattlerPartyIndexes[gActiveBattler]) + if (i == gBattlerPartyIndexes[battler]) continue; - if (IsAceMon(gActiveBattler, i)) + if (IsAceMon(battler, i)) continue; for (opposingBattler = GetBattlerAtPosition(opposingPosition), j = 0; j < MAX_MON_MOVES; j++) @@ -125,11 +125,11 @@ static bool8 ShouldSwitchIfWonderGuard(void) move = GetMonData(&party[i], MON_DATA_MOVE1 + j); if (move != MOVE_NONE) { - if (AI_GetTypeEffectiveness(move, gActiveBattler, opposingBattler) >= UQ_4_12(2.0) && Random() % 3 < 2) + if (AI_GetTypeEffectiveness(move, battler, opposingBattler) >= UQ_4_12(2.0) && Random() % 3 < 2) { // We found a mon. - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = i; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); return TRUE; } } @@ -139,60 +139,60 @@ static bool8 ShouldSwitchIfWonderGuard(void) return FALSE; // There is not a single Pokemon in the party that has a super effective move against a mon with Wonder Guard. } -static bool8 FindMonThatAbsorbsOpponentsMove(void) +static bool8 FindMonThatAbsorbsOpponentsMove(u32 battler) { u8 battlerIn1, battlerIn2; - u8 numAbsorbingAbilities = 0; + u8 numAbsorbingAbilities = 0; u16 absorbingTypeAbilities[3]; // Array size is maximum number of absorbing abilities for a single type s32 firstId; s32 lastId; // + 1 struct Pokemon *party; s32 i, j; - if (HasSuperEffectiveMoveAgainstOpponents(TRUE) && Random() % 3 != 0) + if (HasSuperEffectiveMoveAgainstOpponents(battler, TRUE) && Random() % 3 != 0) return FALSE; - if (gLastLandedMoves[gActiveBattler] == MOVE_NONE) + if (gLastLandedMoves[battler] == MOVE_NONE) return FALSE; - if (gLastLandedMoves[gActiveBattler] == MOVE_UNAVAILABLE) + if (gLastLandedMoves[battler] == MOVE_UNAVAILABLE) return FALSE; - if (IS_MOVE_STATUS(gLastLandedMoves[gActiveBattler])) + if (IS_MOVE_STATUS(gLastLandedMoves[battler])) return FALSE; if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { - battlerIn1 = gActiveBattler; - if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))]) - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler)))]) + battlerIn2 = battler; else - battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))); + battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler))); } else { - battlerIn1 = gActiveBattler; - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + battlerIn2 = battler; } // Create an array of possible absorb abilities so the AI considers all of them - if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_FIRE) + if (gBattleMoves[gLastLandedMoves[battler]].type == TYPE_FIRE) { absorbingTypeAbilities[0] = ABILITY_FLASH_FIRE; numAbsorbingAbilities = 1; } - else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_WATER) + else if (gBattleMoves[gLastLandedMoves[battler]].type == TYPE_WATER) { absorbingTypeAbilities[0] = ABILITY_WATER_ABSORB; absorbingTypeAbilities[1] = ABILITY_STORM_DRAIN; absorbingTypeAbilities[2] = ABILITY_DRY_SKIN; numAbsorbingAbilities = 3; } - else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_ELECTRIC) + else if (gBattleMoves[gLastLandedMoves[battler]].type == TYPE_ELECTRIC) { absorbingTypeAbilities[0] = ABILITY_VOLT_ABSORB; absorbingTypeAbilities[1] = ABILITY_MOTOR_DRIVE; absorbingTypeAbilities[2] = ABILITY_LIGHTNING_ROD; numAbsorbingAbilities = 3; } - else if (gBattleMoves[gLastLandedMoves[gActiveBattler]].type == TYPE_GRASS) + else if (gBattleMoves[gLastLandedMoves[battler]].type == TYPE_GRASS) { absorbingTypeAbilities[0] = ABILITY_SAP_SIPPER; numAbsorbingAbilities = 1; @@ -205,13 +205,13 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) // Check current mon for all absorbing abilities for (i = 0; i < numAbsorbingAbilities; i++) { - if (AI_DATA->abilities[gActiveBattler] == absorbingTypeAbilities[i]) + if (AI_DATA->abilities[battler] == absorbingTypeAbilities[i]) return FALSE; } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -230,7 +230,7 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) continue; if (i == *(gBattleStruct->monToSwitchIntoId + battlerIn2)) continue; - if (IsAceMon(gActiveBattler, i)) + if (IsAceMon(battler, i)) continue; monAbility = GetMonAbility(&party[i]); @@ -240,8 +240,8 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) if (absorbingTypeAbilities[j] == monAbility && Random() & 1) { // we found a mon. - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i; - BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = i; + BtlController_EmitTwoReturnValues(battler, 1, B_ACTION_SWITCH, 0); return TRUE; } } @@ -249,12 +249,12 @@ static bool8 FindMonThatAbsorbsOpponentsMove(void) return FALSE; } -static bool8 ShouldSwitchIfGameStatePrompt(void) +static bool8 ShouldSwitchIfGameStatePrompt(u32 battler) { bool8 switchMon = FALSE; - u16 monAbility = AI_DATA->abilities[gActiveBattler]; - u16 holdEffect = AI_DATA->holdEffects[gActiveBattler]; - u8 opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler)); + u16 monAbility = AI_DATA->abilities[battler]; + u16 holdEffect = AI_DATA->holdEffects[battler]; + u8 opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); u8 opposingBattler = GetBattlerAtPosition(opposingPosition); s32 moduloChance = 4; //25% Chance Default s32 chanceReducer = 1; //No Reduce default. Increase to reduce @@ -263,22 +263,21 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) s32 i; struct Pokemon *party; - - if (AnyStatIsRaised(gActiveBattler)) + if (AnyStatIsRaised(battler)) chanceReducer = 5; // Reduce switchout probability by factor of 5 if setup //Perish Song - if (gStatuses3[gActiveBattler] & STATUS3_PERISH_SONG - && gDisableStructs[gActiveBattler].perishSongTimer == 0 + if (gStatuses3[battler] & STATUS3_PERISH_SONG + && gDisableStructs[battler].perishSongTimer == 0 && monAbility != ABILITY_SOUNDPROOF) switchMon = TRUE; if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING) { //Yawn - if (gStatuses3[gActiveBattler] & STATUS3_YAWN - && AI_CanSleep(gActiveBattler, monAbility) - && gBattleMons[gActiveBattler].hp > gBattleMons[gActiveBattler].maxHP / 3) + if (gStatuses3[battler] & STATUS3_YAWN + && AI_CanSleep(battler, monAbility) + && gBattleMons[battler].hp > gBattleMons[battler].maxHP / 3) { switchMon = TRUE; @@ -286,40 +285,40 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) //Check if partner can prevent sleep if (IsDoubleBattle()) { - if (IsBattlerAlive(BATTLE_PARTNER(gActiveBattler)) - && (GetAIChosenMove(BATTLE_PARTNER(gActiveBattler)) == MOVE_UPROAR) + if (IsBattlerAlive(BATTLE_PARTNER(battler)) + && (GetAIChosenMove(BATTLE_PARTNER(battler)) == MOVE_UPROAR) ) switchMon = FALSE; - if (IsBattlerAlive(BATTLE_PARTNER(gActiveBattler)) + if (IsBattlerAlive(BATTLE_PARTNER(battler)) && (gBattleMoves[AI_DATA->partnerMove].effect == EFFECT_MISTY_TERRAIN || gBattleMoves[AI_DATA->partnerMove].effect == EFFECT_ELECTRIC_TERRAIN) - && IsBattlerGrounded(gActiveBattler) + && IsBattlerGrounded(battler) ) switchMon = FALSE; - if (*(gBattleStruct->AI_monToSwitchIntoId + BATTLE_PARTNER(gActiveBattler)) != PARTY_SIZE) //Partner is switching + if (*(gBattleStruct->AI_monToSwitchIntoId + BATTLE_PARTNER(battler)) != PARTY_SIZE) //Partner is switching { - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; for (i = firstId; i < lastId; i++) { - if (IsAceMon(gActiveBattler, i)) + if (IsAceMon(battler, i)) continue; //Look for mon in party that is able to be switched into and has ability that sets terrain if (IsValidForBattle(&party[i]) - && i != gBattlerPartyIndexes[gActiveBattler] - && i != gBattlerPartyIndexes[BATTLE_PARTNER(gActiveBattler)] - && IsBattlerGrounded(gActiveBattler) + && i != gBattlerPartyIndexes[battler] + && i != gBattlerPartyIndexes[BATTLE_PARTNER(battler)] + && IsBattlerGrounded(battler) && (GetMonAbility(&party[i]) == ABILITY_MISTY_SURGE || GetMonAbility(&party[i]) == ABILITY_ELECTRIC_SURGE)) //Ally has Misty or Electric Surge { - *(gBattleStruct->AI_monToSwitchIntoId + BATTLE_PARTNER(gActiveBattler)) = i; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + BATTLE_PARTNER(battler)) = i; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); switchMon = FALSE; break; } @@ -329,7 +328,7 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) //Check if Active Pokemon can KO opponent instead of switching //Will still fall asleep, but take out opposing Pokemon first - if (AiExpectsToFaintPlayer()) + if (AiExpectsToFaintPlayer(battler)) switchMon = FALSE; //Checks to see if active Pokemon can do something against sleep @@ -337,56 +336,56 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) || monAbility == ABILITY_SHED_SKIN || monAbility == ABILITY_EARLY_BIRD) || holdEffect == (HOLD_EFFECT_CURE_SLP | HOLD_EFFECT_CURE_STATUS) - || HasMove(gActiveBattler, MOVE_SLEEP_TALK) - || (HasMoveEffect(gActiveBattler, MOVE_SNORE) && AI_GetTypeEffectiveness(MOVE_SNORE, gActiveBattler, opposingBattler) >= UQ_4_12(1.0)) - || (IsBattlerGrounded(gActiveBattler) - && (HasMove(gActiveBattler, MOVE_MISTY_TERRAIN) || HasMove(gActiveBattler, MOVE_ELECTRIC_TERRAIN))) + || HasMove(battler, MOVE_SLEEP_TALK) + || (HasMoveEffect(battler, MOVE_SNORE) && AI_GetTypeEffectiveness(MOVE_SNORE, battler, opposingBattler) >= UQ_4_12(1.0)) + || (IsBattlerGrounded(battler) + && (HasMove(battler, MOVE_MISTY_TERRAIN) || HasMove(battler, MOVE_ELECTRIC_TERRAIN))) ) switchMon = FALSE; //Check if Active Pokemon evasion boosted and might be able to dodge until awake - if (gBattleMons[gActiveBattler].statStages[STAT_EVASION] > (DEFAULT_STAT_STAGE + 3) + if (gBattleMons[battler].statStages[STAT_EVASION] > (DEFAULT_STAT_STAGE + 3) && AI_DATA->abilities[opposingBattler] != ABILITY_UNAWARE && AI_DATA->abilities[opposingBattler] != ABILITY_KEEN_EYE - && !(gBattleMons[gActiveBattler].status2 & STATUS2_FORESIGHT) - && !(gStatuses3[gActiveBattler] & STATUS3_MIRACLE_EYED)) + && !(gBattleMons[battler].status2 & STATUS2_FORESIGHT) + && !(gStatuses3[battler] & STATUS3_MIRACLE_EYED)) switchMon = FALSE; } //Secondary Damage if (monAbility != ABILITY_MAGIC_GUARD - && !AiExpectsToFaintPlayer()) + && !AiExpectsToFaintPlayer(battler)) { //Toxic moduloChance = 2; //50% - if (((gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_COUNTER) >= STATUS1_TOXIC_TURN(2)) - && gBattleMons[gActiveBattler].hp >= (gBattleMons[gActiveBattler].maxHP / 3) + if (((gBattleMons[battler].status1 & STATUS1_TOXIC_COUNTER) >= STATUS1_TOXIC_TURN(2)) + && gBattleMons[battler].hp >= (gBattleMons[battler].maxHP / 3) && (Random() % (moduloChance*chanceReducer)) == 0) switchMon = TRUE; //Cursed moduloChance = 2; //50% - if (gBattleMons[gActiveBattler].status2 & STATUS2_CURSED + if (gBattleMons[battler].status2 & STATUS2_CURSED && (Random() % (moduloChance*chanceReducer)) == 0) switchMon = TRUE; //Nightmare moduloChance = 3; //33.3% - if (gBattleMons[gActiveBattler].status2 & STATUS2_NIGHTMARE + if (gBattleMons[battler].status2 & STATUS2_NIGHTMARE && (Random() % (moduloChance*chanceReducer)) == 0) switchMon = TRUE; //Leech Seed moduloChance = 4; //25% - if (gStatuses3[gActiveBattler] & STATUS3_LEECHSEED + if (gStatuses3[battler] & STATUS3_LEECHSEED && (Random() % (moduloChance*chanceReducer)) == 0) switchMon = TRUE; } //Infatuation - if (gBattleMons[gActiveBattler].status2 & STATUS2_INFATUATION - && !AiExpectsToFaintPlayer()) + if (gBattleMons[battler].status2 & STATUS2_INFATUATION + && !AiExpectsToFaintPlayer(battler)) switchMon = TRUE; //Todo @@ -395,22 +394,22 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) //Semi-Invulnerable if (gStatuses3[opposingBattler] & STATUS3_SEMI_INVULNERABLE) { - if (FindMonThatAbsorbsOpponentsMove()) //If find absorber default to switch + if (FindMonThatAbsorbsOpponentsMove(battler)) //If find absorber default to switch switchMon = TRUE; - if (!AI_OpponentCanFaintAiWithMod(0) - && AnyStatIsRaised(gActiveBattler)) + if (!AI_OpponentCanFaintAiWithMod(battler, 0) + && AnyStatIsRaised(battler)) switchMon = FALSE; - if (AiExpectsToFaintPlayer() + if (AiExpectsToFaintPlayer(battler) && !WillAIStrikeFirst() - && !AI_OpponentCanFaintAiWithMod(0)) + && !AI_OpponentCanFaintAiWithMod(battler, 0)) switchMon = FALSE; } } if (switchMon) { - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = PARTY_SIZE; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); return TRUE; } else @@ -419,32 +418,31 @@ static bool8 ShouldSwitchIfGameStatePrompt(void) } } -static bool8 ShouldSwitchIfAbilityBenefit(void) +static bool8 ShouldSwitchIfAbilityBenefit(u32 battler) { s32 monToSwitchId; s32 moduloChance = 4; //25% Chance Default s32 chanceReducer = 1; //No Reduce default. Increase to reduce - u8 battlerId = GetBattlerPosition(gActiveBattler); - if (AnyStatIsRaised(battlerId)) + if (AnyStatIsRaised(battler)) chanceReducer = 5; // Reduce switchout probability by factor of 5 if setup //Check if ability is blocked - if (gStatuses3[gActiveBattler] & STATUS3_GASTRO_ACID + if (gStatuses3[battler] & STATUS3_GASTRO_ACID ||IsNeutralizingGasOnField()) return FALSE; - switch(AI_DATA->abilities[gActiveBattler]) { + switch(AI_DATA->abilities[battler]) { case ABILITY_NATURAL_CURE: moduloChance = 4; //25% //Attempt to cure bad ailment - if (gBattleMons[gActiveBattler].status1 & (STATUS1_SLEEP | STATUS1_FREEZE | STATUS1_TOXIC_POISON) - && GetMostSuitableMonToSwitchInto() != PARTY_SIZE) + if (gBattleMons[battler].status1 & (STATUS1_SLEEP | STATUS1_FREEZE | STATUS1_TOXIC_POISON) + && GetMostSuitableMonToSwitchInto(battler) != PARTY_SIZE) break; //Attempt to cure lesser ailment - if ((gBattleMons[gActiveBattler].status1 & STATUS1_ANY) - && (gBattleMons[gActiveBattler].hp >= gBattleMons[gActiveBattler].maxHP / 2) - && GetMostSuitableMonToSwitchInto() != PARTY_SIZE + if ((gBattleMons[battler].status1 & STATUS1_ANY) + && (gBattleMons[battler].hp >= gBattleMons[battler].maxHP / 2) + && GetMostSuitableMonToSwitchInto(battler) != PARTY_SIZE && Random() % (moduloChance*chanceReducer) == 0) break; @@ -453,10 +451,10 @@ static bool8 ShouldSwitchIfAbilityBenefit(void) case ABILITY_REGENERATOR: moduloChance = 2; //50% //Don't switch if ailment - if (gBattleMons[gActiveBattler].status1 & STATUS1_ANY) + if (gBattleMons[battler].status1 & STATUS1_ANY) return FALSE; - if ((gBattleMons[gActiveBattler].hp <= ((gBattleMons[gActiveBattler].maxHP * 2) / 3)) - && GetMostSuitableMonToSwitchInto() != PARTY_SIZE + if ((gBattleMons[battler].hp <= ((gBattleMons[battler].maxHP * 2) / 3)) + && GetMostSuitableMonToSwitchInto(battler) != PARTY_SIZE && Random() % (moduloChance*chanceReducer) == 0) break; @@ -466,31 +464,31 @@ static bool8 ShouldSwitchIfAbilityBenefit(void) return FALSE; } - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = PARTY_SIZE; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); return TRUE; } -static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng) +static bool8 HasSuperEffectiveMoveAgainstOpponents(u32 battler, bool8 noRng) { u8 opposingPosition; u8 opposingBattler; s32 i; u16 move; - opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler)); + opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); opposingBattler = GetBattlerAtPosition(opposingPosition); if (!(gAbsentBattlerFlags & gBitTable[opposingBattler])) { for (i = 0; i < MAX_MON_MOVES; i++) { - move = gBattleMons[gActiveBattler].moves[i]; + move = gBattleMons[battler].moves[i]; if (move == MOVE_NONE) continue; - if (AI_GetTypeEffectiveness(move, gActiveBattler, opposingBattler) >= UQ_4_12(2.0)) + if (AI_GetTypeEffectiveness(move, battler, opposingBattler) >= UQ_4_12(2.0)) { if (noRng) return TRUE; @@ -508,11 +506,11 @@ static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng) { for (i = 0; i < MAX_MON_MOVES; i++) { - move = gBattleMons[gActiveBattler].moves[i]; + move = gBattleMons[battler].moves[i]; if (move == MOVE_NONE) continue; - if (AI_GetTypeEffectiveness(move, gActiveBattler, opposingBattler) >= UQ_4_12(2.0)) + if (AI_GetTypeEffectiveness(move, battler, opposingBattler) >= UQ_4_12(2.0)) { if (noRng) return TRUE; @@ -525,21 +523,21 @@ static bool8 HasSuperEffectiveMoveAgainstOpponents(bool8 noRng) return FALSE; } -static bool8 AreStatsRaised(void) +static bool8 AreStatsRaised(u32 battler) { u8 buffedStatsValue = 0; s32 i; for (i = 0; i < NUM_BATTLE_STATS; i++) { - if (gBattleMons[gActiveBattler].statStages[i] > DEFAULT_STAT_STAGE) - buffedStatsValue += gBattleMons[gActiveBattler].statStages[i] - DEFAULT_STAT_STAGE; + if (gBattleMons[battler].statStages[i] > DEFAULT_STAT_STAGE) + buffedStatsValue += gBattleMons[battler].statStages[i] - DEFAULT_STAT_STAGE; } return (buffedStatsValue > 3); } -static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent) +static bool8 FindMonWithFlagsAndSuperEffective(u32 battler, u16 flags, u8 moduloPercent) { u8 battlerIn1, battlerIn2; s32 firstId; @@ -548,32 +546,32 @@ static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent) s32 i, j; u16 move; - if (gLastLandedMoves[gActiveBattler] == MOVE_NONE) + if (gLastLandedMoves[battler] == MOVE_NONE) return FALSE; - if (gLastLandedMoves[gActiveBattler] == MOVE_UNAVAILABLE) + if (gLastLandedMoves[battler] == MOVE_UNAVAILABLE) return FALSE; - if (gLastHitBy[gActiveBattler] == 0xFF) + if (gLastHitBy[battler] == 0xFF) return FALSE; - if (IS_MOVE_STATUS(gLastLandedMoves[gActiveBattler])) + if (IS_MOVE_STATUS(gLastLandedMoves[battler])) return FALSE; if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { - battlerIn1 = gActiveBattler; - if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))]) - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler)))]) + battlerIn2 = battler; else - battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))); + battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler))); } else { - battlerIn1 = gActiveBattler; - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + battlerIn2 = battler; } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -592,15 +590,15 @@ static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent) continue; if (i == *(gBattleStruct->monToSwitchIntoId + battlerIn2)) continue; - if (IsAceMon(gActiveBattler, i)) + if (IsAceMon(battler, i)) continue; species = GetMonData(&party[i], MON_DATA_SPECIES_OR_EGG); monAbility = GetMonAbility(&party[i]); - CalcPartyMonTypeEffectivenessMultiplier(gLastLandedMoves[gActiveBattler], species, monAbility); + CalcPartyMonTypeEffectivenessMultiplier(gLastLandedMoves[battler], species, monAbility); if (gMoveResultFlags & flags) { - battlerIn1 = gLastHitBy[gActiveBattler]; + battlerIn1 = gLastHitBy[battler]; for (j = 0; j < MAX_MON_MOVES; j++) { @@ -608,10 +606,10 @@ static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent) if (move == 0) continue; - if (AI_GetTypeEffectiveness(move, gActiveBattler, battlerIn1) >= UQ_4_12(2.0) && Random() % moduloPercent == 0) + if (AI_GetTypeEffectiveness(move, battler, battlerIn1) >= UQ_4_12(2.0) && Random() % moduloPercent == 0) { - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = i; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + *(gBattleStruct->AI_monToSwitchIntoId + battler) = i; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); return TRUE; } } @@ -621,7 +619,7 @@ static bool8 FindMonWithFlagsAndSuperEffective(u16 flags, u8 moduloPercent) return FALSE; } -bool32 ShouldSwitch(void) +bool32 ShouldSwitch(u32 battler) { u8 battlerIn1, battlerIn2; s32 firstId; @@ -631,11 +629,11 @@ bool32 ShouldSwitch(void) s32 availableToSwitch; bool32 hasAceMon = FALSE; - if (gBattleMons[gActiveBattler].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION)) + if (gBattleMons[battler].status2 & (STATUS2_WRAPPED | STATUS2_ESCAPE_PREVENTION)) return FALSE; - if (gStatuses3[gActiveBattler] & STATUS3_ROOTED) + if (gStatuses3[battler] & STATUS3_ROOTED) return FALSE; - if (IsAbilityPreventingEscape(gActiveBattler)) + if (IsAbilityPreventingEscape(battler)) return FALSE; if (gBattleTypeFlags & BATTLE_TYPE_ARENA) return FALSE; @@ -644,21 +642,21 @@ bool32 ShouldSwitch(void) if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { - battlerIn1 = gActiveBattler; - if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))]) - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler)))]) + battlerIn2 = battler; else - battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))); + battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler))); } else { - battlerIn1 = gActiveBattler; - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + battlerIn2 = battler; } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -675,7 +673,7 @@ bool32 ShouldSwitch(void) continue; if (i == *(gBattleStruct->monToSwitchIntoId + battlerIn2)) continue; - if (IsAceMon(gActiveBattler, i)) + if (IsAceMon(battler, i)) { hasAceMon = TRUE; continue; @@ -696,69 +694,69 @@ bool32 ShouldSwitch(void) //Since the order is sequencial, and some of these functions prompt switch to specific party members. //These Functions can prompt switch to specific party members - if (ShouldSwitchIfWonderGuard()) + if (ShouldSwitchIfWonderGuard(battler)) return TRUE; - if (ShouldSwitchIfGameStatePrompt()) + if (ShouldSwitchIfGameStatePrompt(battler)) return TRUE; - if (FindMonThatAbsorbsOpponentsMove()) + if (FindMonThatAbsorbsOpponentsMove(battler)) return TRUE; //These Functions can prompt switch to generic pary members - if (ShouldSwitchIfAllBadMoves()) + if (ShouldSwitchIfAllBadMoves(battler)) return TRUE; - if (ShouldSwitchIfAbilityBenefit()) + if (ShouldSwitchIfAbilityBenefit(battler)) return TRUE; //Removing switch capabilites under specific conditions //These Functions prevent the "FindMonWithFlagsAndSuperEffective" from getting out of hand. - if (HasSuperEffectiveMoveAgainstOpponents(FALSE)) + if (HasSuperEffectiveMoveAgainstOpponents(battler, FALSE)) return FALSE; - if (AreStatsRaised()) + if (AreStatsRaised(battler)) return FALSE; //Default Function //Can prompt switch if AI has a pokemon in party that resists current opponent & has super effective move - if (FindMonWithFlagsAndSuperEffective(MOVE_RESULT_DOESNT_AFFECT_FOE, 2) - || FindMonWithFlagsAndSuperEffective(MOVE_RESULT_NOT_VERY_EFFECTIVE, 3)) + if (FindMonWithFlagsAndSuperEffective(battler, MOVE_RESULT_DOESNT_AFFECT_FOE, 2) + || FindMonWithFlagsAndSuperEffective(battler, MOVE_RESULT_NOT_VERY_EFFECTIVE, 3)) return TRUE; return FALSE; } -void AI_TrySwitchOrUseItem(void) +void AI_TrySwitchOrUseItem(u32 battler) { struct Pokemon *party; u8 battlerIn1, battlerIn2; s32 firstId; s32 lastId; // + 1 - u8 battlerIdentity = GetBattlerPosition(gActiveBattler); + u8 battlerPosition = GetBattlerPosition(battler); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) { - if (ShouldSwitch()) + if (ShouldSwitch(battler)) { - if (*(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) == PARTY_SIZE) + if (*(gBattleStruct->AI_monToSwitchIntoId + battler) == PARTY_SIZE) { - s32 monToSwitchId = GetMostSuitableMonToSwitchInto(); + s32 monToSwitchId = GetMostSuitableMonToSwitchInto(battler); if (monToSwitchId == PARTY_SIZE) { if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) { - battlerIn1 = GetBattlerAtPosition(battlerIdentity); + battlerIn1 = GetBattlerAtPosition(battlerPosition); battlerIn2 = battlerIn1; } else { - battlerIn1 = GetBattlerAtPosition(battlerIdentity); - battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(battlerIdentity)); + battlerIn1 = GetBattlerAtPosition(battlerPosition); + battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(battlerPosition)); } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); for (monToSwitchId = (lastId-1); monToSwitchId >= firstId; monToSwitchId--) { @@ -772,31 +770,31 @@ void AI_TrySwitchOrUseItem(void) continue; if (monToSwitchId == *(gBattleStruct->monToSwitchIntoId + battlerIn2)) continue; - if (IsAceMon(gActiveBattler, monToSwitchId)) + if (IsAceMon(battler, monToSwitchId)) continue; break; } } - *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = monToSwitchId; + *(gBattleStruct->AI_monToSwitchIntoId + battler) = monToSwitchId; } - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler); + *(gBattleStruct->monToSwitchIntoId + battler) = *(gBattleStruct->AI_monToSwitchIntoId + battler); return; } - else if (ShouldUseItem()) + else if (ShouldUseItem(battler)) { return; } } - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, BATTLE_OPPOSITE(gActiveBattler) << 8); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, BATTLE_OPPOSITE(battler) << 8); } // If there are two(or more) mons to choose from, always choose one that has baton pass // as most often it can't do much on its own. -static u32 GetBestMonBatonPass(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, int aliveCount, u32 opposingBattler) +static u32 GetBestMonBatonPass(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, int aliveCount, u32 battler, u32 opposingBattler) { int i, j, bits = 0; @@ -804,7 +802,7 @@ static u32 GetBestMonBatonPass(struct Pokemon *party, int firstId, int lastId, u { if (invalidMons & gBitTable[i]) continue; - if (IsAiPartyMonOHKOBy(opposingBattler, &party[i])) + if (IsAiPartyMonOHKOBy(battler, opposingBattler, &party[i])) continue; for (j = 0; j < MAX_MON_MOVES; j++) @@ -829,7 +827,7 @@ static u32 GetBestMonBatonPass(struct Pokemon *party, int firstId, int lastId, u return PARTY_SIZE; } -static u32 GetBestMonTypeMatchup(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, u32 opposingBattler) +static u32 GetBestMonTypeMatchup(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, u32 battler, u32 opposingBattler) { int i, bits = 0; @@ -850,7 +848,7 @@ static u32 GetBestMonTypeMatchup(struct Pokemon *party, int firstId, int lastId, u8 defType1 = gSpeciesInfo[species].types[0]; u8 defType2 = gSpeciesInfo[species].types[1]; - if (IsAiPartyMonOHKOBy(opposingBattler, &party[i])) + if (IsAiPartyMonOHKOBy(battler, opposingBattler, &party[i])) continue; typeEffectiveness = uq4_12_multiply(typeEffectiveness, (GetTypeModifier(atkType1, defType1))); @@ -876,7 +874,7 @@ static u32 GetBestMonTypeMatchup(struct Pokemon *party, int firstId, int lastId, for (i = 0; i < MAX_MON_MOVES; i++) { u32 move = GetMonData(&party[bestMonId], MON_DATA_MOVE1 + i); - if (move != MOVE_NONE && AI_GetTypeEffectiveness(move, gActiveBattler, opposingBattler) >= UQ_4_12(2.0)) + if (move != MOVE_NONE && AI_GetTypeEffectiveness(move, battler, opposingBattler) >= UQ_4_12(2.0)) break; } @@ -894,7 +892,7 @@ static u32 GetBestMonTypeMatchup(struct Pokemon *party, int firstId, int lastId, return PARTY_SIZE; } -static u32 GetBestMonDmg(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, u32 opposingBattler) +static u32 GetBestMonDmg(struct Pokemon *party, int firstId, int lastId, u8 invalidMons, u32 battler, u32 opposingBattler) { int i, j; int dmg, bestDmg = 0; @@ -906,10 +904,10 @@ static u32 GetBestMonDmg(struct Pokemon *party, int firstId, int lastId, u8 inva { if (gBitTable[i] & invalidMons) continue; - if (IsAiPartyMonOHKOBy(opposingBattler, &party[i])) + if (IsAiPartyMonOHKOBy(battler, opposingBattler, &party[i])) continue; - dmg = AI_CalcPartyMonBestMoveDamage(gActiveBattler, opposingBattler, &party[i], NULL); + dmg = AI_CalcPartyMonBestMoveDamage(battler, opposingBattler, &party[i], NULL); if (bestDmg < dmg) { bestDmg = dmg; @@ -920,7 +918,7 @@ static u32 GetBestMonDmg(struct Pokemon *party, int firstId, int lastId, u8 inva return bestMonId; } -u8 GetMostSuitableMonToSwitchInto(void) +u8 GetMostSuitableMonToSwitchInto(u32 battler) { u32 opposingBattler = 0; u32 bestMonId = PARTY_SIZE; @@ -931,18 +929,18 @@ u8 GetMostSuitableMonToSwitchInto(void) s32 i, j, aliveCount = 0; u32 invalidMons = 0, aceMonId = PARTY_SIZE; - if (*(gBattleStruct->monToSwitchIntoId + gActiveBattler) != PARTY_SIZE) - return *(gBattleStruct->monToSwitchIntoId + gActiveBattler); + if (*(gBattleStruct->monToSwitchIntoId + battler) != PARTY_SIZE) + return *(gBattleStruct->monToSwitchIntoId + battler); if (gBattleTypeFlags & BATTLE_TYPE_ARENA) - return gBattlerPartyIndexes[gActiveBattler] + 1; + return gBattlerPartyIndexes[battler] + 1; if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { - battlerIn1 = gActiveBattler; - if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))]) - battlerIn2 = gActiveBattler; + battlerIn1 = battler; + if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler)))]) + battlerIn2 = battler; else - battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))); + battlerIn2 = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler))); opposingBattler = BATTLE_OPPOSITE(battlerIn1); if (gAbsentBattlerFlags & gBitTable[opposingBattler]) @@ -950,14 +948,14 @@ u8 GetMostSuitableMonToSwitchInto(void) } else { - opposingBattler = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(gActiveBattler))); - battlerIn1 = gActiveBattler; - battlerIn2 = gActiveBattler; + opposingBattler = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler))); + battlerIn1 = battler; + battlerIn2 = battler; } - GetAIPartyIndexes(gActiveBattler, &firstId, &lastId); + GetAIPartyIndexes(battler, &firstId, &lastId); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -970,11 +968,11 @@ u8 GetMostSuitableMonToSwitchInto(void) || gBattlerPartyIndexes[battlerIn2] == i || i == *(gBattleStruct->monToSwitchIntoId + battlerIn1) || i == *(gBattleStruct->monToSwitchIntoId + battlerIn2) - || (GetMonAbility(&party[i]) == ABILITY_TRUANT && IsTruantMonVulnerable(gActiveBattler, opposingBattler))) // While not really invalid per say, not really wise to switch into this mon.) + || (GetMonAbility(&party[i]) == ABILITY_TRUANT && IsTruantMonVulnerable(battler, opposingBattler))) // While not really invalid per say, not really wise to switch into this mon.) { invalidMons |= gBitTable[i]; } - else if (IsAceMon(gActiveBattler, i))// Save Ace Pokemon for last. + else if (IsAceMon(battler, i))// Save Ace Pokemon for last. { aceMonId = i; invalidMons |= gBitTable[i]; @@ -985,15 +983,15 @@ u8 GetMostSuitableMonToSwitchInto(void) } } - bestMonId = GetBestMonBatonPass(party, firstId, lastId, invalidMons, aliveCount, opposingBattler); + bestMonId = GetBestMonBatonPass(party, firstId, lastId, invalidMons, aliveCount, battler, opposingBattler); if (bestMonId != PARTY_SIZE) return bestMonId; - bestMonId = GetBestMonTypeMatchup(party, firstId, lastId, invalidMons, opposingBattler); + bestMonId = GetBestMonTypeMatchup(party, firstId, lastId, invalidMons, battler, opposingBattler); if (bestMonId != PARTY_SIZE) return bestMonId; - bestMonId = GetBestMonDmg(party, firstId, lastId, invalidMons, opposingBattler); + bestMonId = GetBestMonDmg(party, firstId, lastId, invalidMons, battler, opposingBattler); if (bestMonId != PARTY_SIZE) return bestMonId; @@ -1004,18 +1002,18 @@ u8 GetMostSuitableMonToSwitchInto(void) return PARTY_SIZE; } -static bool32 AiExpectsToFaintPlayer(void) +static bool32 AiExpectsToFaintPlayer(u32 battler) { bool32 canFaintPlayer; u32 i; - u8 target = gBattleStruct->aiChosenTarget[gActiveBattler]; + u8 target = gBattleStruct->aiChosenTarget[battler]; - if (gBattleStruct->aiMoveOrAction[gActiveBattler] > 3) + if (gBattleStruct->aiMoveOrAction[battler] > 3) return FALSE; // AI not planning to use move - if (GetBattlerSide(target) != GetBattlerSide(gActiveBattler) - && CanIndexMoveFaintTarget(gActiveBattler, target, gBattleStruct->aiMoveOrAction[gActiveBattler], 0) - && AI_WhoStrikesFirst(gActiveBattler, target, GetAIChosenMove(gActiveBattler)) == AI_IS_FASTER) { + if (GetBattlerSide(target) != GetBattlerSide(battler) + && CanIndexMoveFaintTarget(battler, target, gBattleStruct->aiMoveOrAction[battler], 0) + && AI_WhoStrikesFirst(battler, target, GetAIChosenMove(battler)) == AI_IS_FASTER) { // We expect to faint the target and move first -> dont use an item return TRUE; } @@ -1023,7 +1021,7 @@ static bool32 AiExpectsToFaintPlayer(void) return FALSE; } -static bool8 ShouldUseItem(void) +static bool8 ShouldUseItem(u32 battler) { struct Pokemon *party; s32 i; @@ -1031,17 +1029,17 @@ static bool8 ShouldUseItem(void) bool8 shouldUse = FALSE; // If teaming up with player and Pokemon is on the right, or Pokemon is currently held by Sky Drop - if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_RIGHT) - || gStatuses3[gActiveBattler] & STATUS3_SKY_DROPPED) + if ((gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT) + || gStatuses3[battler] & STATUS3_SKY_DROPPED) return FALSE; - if (gStatuses3[gActiveBattler] & STATUS3_EMBARGO) + if (gStatuses3[battler] & STATUS3_EMBARGO) return FALSE; - if (AiExpectsToFaintPlayer()) + if (AiExpectsToFaintPlayer(battler)) return FALSE; - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if (GetBattlerSide(battler) == B_SIDE_PLAYER) party = gPlayerParty; else party = gEnemyParty; @@ -1071,48 +1069,48 @@ static bool8 ShouldUseItem(void) switch (ItemId_GetBattleUsage(item)) { case EFFECT_ITEM_HEAL_AND_CURE_STATUS: - shouldUse = AI_ShouldHeal(0); + shouldUse = AI_ShouldHeal(battler, 0); break; case EFFECT_ITEM_RESTORE_HP: - shouldUse = AI_ShouldHeal(itemEffects[GetItemEffectParamOffset(item, 4, 4)]); + shouldUse = AI_ShouldHeal(battler, itemEffects[GetItemEffectParamOffset(item, 4, 4)]); break; case EFFECT_ITEM_CURE_STATUS: - if (itemEffects[3] & ITEM3_SLEEP && gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP) + if (itemEffects[3] & ITEM3_SLEEP && gBattleMons[battler].status1 & STATUS1_SLEEP) shouldUse = TRUE; - if (itemEffects[3] & ITEM3_POISON && (gBattleMons[gActiveBattler].status1 & STATUS1_POISON - || gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_POISON)) + if (itemEffects[3] & ITEM3_POISON && (gBattleMons[battler].status1 & STATUS1_POISON + || gBattleMons[battler].status1 & STATUS1_TOXIC_POISON)) shouldUse = TRUE; - if (itemEffects[3] & ITEM3_BURN && gBattleMons[gActiveBattler].status1 & STATUS1_BURN) + if (itemEffects[3] & ITEM3_BURN && gBattleMons[battler].status1 & STATUS1_BURN) shouldUse = TRUE; - if (itemEffects[3] & ITEM3_FREEZE && (gBattleMons[gActiveBattler].status1 & STATUS1_FREEZE || gBattleMons[gActiveBattler].status1 & STATUS1_FROSTBITE)) + if (itemEffects[3] & ITEM3_FREEZE && (gBattleMons[battler].status1 & STATUS1_FREEZE || gBattleMons[battler].status1 & STATUS1_FROSTBITE)) shouldUse = TRUE; - if (itemEffects[3] & ITEM3_PARALYSIS && gBattleMons[gActiveBattler].status1 & STATUS1_PARALYSIS) + if (itemEffects[3] & ITEM3_PARALYSIS && gBattleMons[battler].status1 & STATUS1_PARALYSIS) shouldUse = TRUE; - if (itemEffects[3] & ITEM3_CONFUSION && gBattleMons[gActiveBattler].status2 & STATUS2_CONFUSION) + if (itemEffects[3] & ITEM3_CONFUSION && gBattleMons[battler].status2 & STATUS2_CONFUSION) shouldUse = TRUE; break; case EFFECT_ITEM_INCREASE_STAT: case EFFECT_ITEM_INCREASE_ALL_STATS: - if (!gDisableStructs[gActiveBattler].isFirstTurn - || AI_OpponentCanFaintAiWithMod(0)) + if (!gDisableStructs[battler].isFirstTurn + || AI_OpponentCanFaintAiWithMod(battler, 0)) break; shouldUse = TRUE; break; case EFFECT_ITEM_SET_FOCUS_ENERGY: - if (!gDisableStructs[gActiveBattler].isFirstTurn - || gBattleMons[gActiveBattler].status2 & STATUS2_FOCUS_ENERGY - || AI_OpponentCanFaintAiWithMod(0)) + if (!gDisableStructs[battler].isFirstTurn + || gBattleMons[battler].status2 & STATUS2_FOCUS_ENERGY + || AI_OpponentCanFaintAiWithMod(battler, 0)) break; shouldUse = TRUE; break; case EFFECT_ITEM_SET_MIST: - battlerSide = GetBattlerSide(gActiveBattler); - if (gDisableStructs[gActiveBattler].isFirstTurn && gSideTimers[battlerSide].mistTimer == 0) + battlerSide = GetBattlerSide(battler); + if (gDisableStructs[battler].isFirstTurn && gSideTimers[battlerSide].mistTimer == 0) shouldUse = TRUE; break; case EFFECT_ITEM_REVIVE: - gBattleStruct->itemPartyIndex[gActiveBattler] = GetFirstFaintedPartyIndex(gActiveBattler); - if (gBattleStruct->itemPartyIndex[gActiveBattler] != PARTY_SIZE) // Revive if possible. + gBattleStruct->itemPartyIndex[battler] = GetFirstFaintedPartyIndex(battler); + if (gBattleStruct->itemPartyIndex[battler] != PARTY_SIZE) // Revive if possible. shouldUse = TRUE; break; default: @@ -1121,10 +1119,10 @@ static bool8 ShouldUseItem(void) if (shouldUse) { // Set selected party ID to current battler if none chosen. - if (gBattleStruct->itemPartyIndex[gActiveBattler] == PARTY_SIZE) - gBattleStruct->itemPartyIndex[gActiveBattler] = gBattlerPartyIndexes[gActiveBattler]; - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_ITEM, 0); - gBattleStruct->chosenItem[gActiveBattler] = item; + if (gBattleStruct->itemPartyIndex[battler] == PARTY_SIZE) + gBattleStruct->itemPartyIndex[battler] = gBattlerPartyIndexes[battler]; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0); + gBattleStruct->chosenItem[battler] = item; gBattleResources->battleHistory->trainerItems[i] = 0; return shouldUse; } @@ -1133,27 +1131,27 @@ static bool8 ShouldUseItem(void) return FALSE; } -static bool32 AI_ShouldHeal(u32 healAmount) +static bool32 AI_ShouldHeal(u32 battler, u32 healAmount) { bool32 shouldHeal = FALSE; - if (gBattleMons[gActiveBattler].hp < gBattleMons[gActiveBattler].maxHP / 4 - || gBattleMons[gActiveBattler].hp == 0 - || (healAmount != 0 && gBattleMons[gActiveBattler].maxHP - gBattleMons[gActiveBattler].hp > healAmount)) { + if (gBattleMons[battler].hp < gBattleMons[battler].maxHP / 4 + || gBattleMons[battler].hp == 0 + || (healAmount != 0 && gBattleMons[battler].maxHP - gBattleMons[battler].hp > healAmount)) { // We have low enough HP to consider healing - shouldHeal = !AI_OpponentCanFaintAiWithMod(healAmount); // if target can kill us even after we heal, why bother + shouldHeal = !AI_OpponentCanFaintAiWithMod(battler, healAmount); // if target can kill us even after we heal, why bother } return shouldHeal; } -static bool32 AI_OpponentCanFaintAiWithMod(u32 healAmount) +static bool32 AI_OpponentCanFaintAiWithMod(u32 battler, u32 healAmount) { u32 i; // Check special cases to NOT heal for (i = 0; i < gBattlersCount; i++) { if (GetBattlerSide(i) == B_SIDE_PLAYER) { - if (CanTargetFaintAiWithMod(i, gActiveBattler, healAmount, 0)) { + if (CanTargetFaintAiWithMod(i, battler, healAmount, 0)) { // Target is expected to faint us return TRUE; } @@ -1162,12 +1160,12 @@ static bool32 AI_OpponentCanFaintAiWithMod(u32 healAmount) return FALSE; } -static bool32 IsAiPartyMonOHKOBy(u32 battlerAtk, struct Pokemon *aiMon) +static bool32 IsAiPartyMonOHKOBy(u32 battlerAi, u32 battlerAtk, struct Pokemon *aiMon) { bool32 ret = FALSE; struct BattlePokemon *savedBattleMons; s32 hp = GetMonData(aiMon, MON_DATA_HP); - s32 bestDmg = AI_CalcPartyMonBestMoveDamage(battlerAtk, gActiveBattler, NULL, aiMon); + s32 bestDmg = AI_CalcPartyMonBestMoveDamage(battlerAtk, battlerAi, NULL, aiMon); switch (GetNoOfHitsToKO(bestDmg, hp)) { @@ -1176,8 +1174,8 @@ static bool32 IsAiPartyMonOHKOBy(u32 battlerAtk, struct Pokemon *aiMon) break; case 2: // if AI mon is faster allow 2 turns savedBattleMons = AllocSaveBattleMons(); - PokemonToBattleMon(aiMon, &gBattleMons[gActiveBattler]); - if (AI_WhoStrikesFirst(gActiveBattler, battlerAtk, 0) == AI_IS_SLOWER) + PokemonToBattleMon(aiMon, &gBattleMons[battlerAi]); + if (AI_WhoStrikesFirst(battlerAi, battlerAtk, 0) == AI_IS_SLOWER) ret = TRUE; else ret = FALSE; diff --git a/src/battle_ai_util.c b/src/battle_ai_util.c index c6788cf8d7..1aa7da5eaf 100644 --- a/src/battle_ai_util.c +++ b/src/battle_ai_util.c @@ -2557,7 +2557,7 @@ bool32 ShouldPivot(u8 battlerAtk, u8 battlerDef, u16 defAbility, u16 move, u8 mo u8 battlerToSwitch; gActiveBattler = battlerAtk; - shouldSwitch = ShouldSwitch(); + shouldSwitch = ShouldSwitch(battlerAtk); battlerToSwitch = *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler); gActiveBattler = backupBattler; diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 4f1c3da976..3a3cb7e8ce 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -370,7 +370,7 @@ static void LinkOpponentBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index c4b4e2112c..4b8daeb1e1 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -196,7 +196,7 @@ static void LinkPartnerBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 93e6a2bab9..85bc009c70 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -387,7 +387,7 @@ static void OpponentBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -511,7 +511,7 @@ static void OpponentHandlePrintString(u32 battler) static void OpponentHandleChooseAction(u32 battler) { - AI_TrySwitchOrUseItem(); + AI_TrySwitchOrUseItem(battler); OpponentBufferExecCompleted(battler); } @@ -525,7 +525,7 @@ static void OpponentHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { - BtlController_EmitTwoReturnValues(BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); } else { @@ -534,16 +534,16 @@ static void OpponentHandleChooseMove(u32 battler) switch (chosenMoveId) { case AI_CHOICE_WATCH: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_WATCH_CAREFULLY, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_WATCH_CAREFULLY, 0); break; case AI_CHOICE_FLEE: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_RUN, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_RUN, 0); break; case AI_CHOICE_SWITCH: - BtlController_EmitTwoReturnValues(BUFFER_B, 10, 0xFFFF); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, 0xFFFF); break; case 6: - BtlController_EmitTwoReturnValues(BUFFER_B, 15, gBattlerTarget); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 15, gBattlerTarget); break; default: { @@ -560,9 +560,9 @@ static void OpponentHandleChooseMove(u32 battler) 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)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (RET_MEGA_EVOLUTION) | (gBattlerTarget << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); } break; } @@ -580,7 +580,7 @@ static void OpponentHandleChooseMove(u32 battler) } while (move == MOVE_NONE); if (GetBattlerMoveTargetType(battler, move) & (MOVE_TARGET_USER_OR_SELECTED | MOVE_TARGET_USER)) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (battler << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (battler << 8)); else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { do { @@ -614,16 +614,16 @@ static void OpponentHandleChooseMove(u32 battler) } } if (isPartnerEnemy && CanTargetBattler(battler, target, move)) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (target << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (target << 8)); } else #endif - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (target << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (target << 8)); } else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8)); OpponentBufferExecCompleted(battler); } @@ -631,7 +631,7 @@ static void OpponentHandleChooseMove(u32 battler) static void OpponentHandleChooseItem(u32 battler) { - BtlController_EmitOneReturnValue(BUFFER_B, gBattleStruct->chosenItem[battler]); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]); OpponentBufferExecCompleted(battler); } @@ -648,7 +648,7 @@ static void OpponentHandleChoosePokemon(u32 battler) // Switching out else if (*(gBattleStruct->AI_monToSwitchIntoId + battler) == PARTY_SIZE) { - chosenMonId = GetMostSuitableMonToSwitchInto(); + chosenMonId = GetMostSuitableMonToSwitchInto(battler); if (chosenMonId == PARTY_SIZE) { s32 battler1, battler2, firstId, lastId; @@ -687,7 +687,7 @@ static void OpponentHandleChoosePokemon(u32 battler) *(gBattleStruct->AI_monToSwitchIntoId + battler) = PARTY_SIZE; *(gBattleStruct->monToSwitchIntoId + battler) = chosenMonId; } - BtlController_EmitChosenMonReturnValue(BUFFER_B, chosenMonId, NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, chosenMonId, NULL); OpponentBufferExecCompleted(battler); } diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index b6c47369e5..a86d40f3c2 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -173,7 +173,7 @@ static void PlayerBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -303,7 +303,7 @@ static void HandleInputChooseAction(u32 battler) PlaySE(SE_SELECT); ArrowsChangeColorLastBallCycle(FALSE); TryHideLastUsedBall(); - BtlController_EmitTwoReturnValues(1, B_ACTION_THROW_BALL, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_THROW_BALL, 0); PlayerBufferExecCompleted(battler); } return; @@ -318,16 +318,16 @@ static void HandleInputChooseAction(u32 battler) switch (gActionSelectionCursor[battler]) { case 0: // Top left - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0); break; case 1: // Top right - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_ITEM, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0); break; case 2: // Bottom left - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SWITCH, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SWITCH, 0); break; case 3: // Bottom right - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_RUN, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_RUN, 0); break; } PlayerBufferExecCompleted(battler); @@ -385,7 +385,7 @@ static void HandleInputChooseAction(u32 battler) AddBagItem(itemId, 1); } PlaySE(SE_SELECT); - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_CANCEL_PARTNER, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_CANCEL_PARTNER, 0); PlayerBufferExecCompleted(battler); } } @@ -396,7 +396,7 @@ static void HandleInputChooseAction(u32 battler) #if DEBUG_BATTLE_MENU == TRUE else if (JOY_NEW(SELECT_BUTTON)) { - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_DEBUG, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_DEBUG, 0); PlayerBufferExecCompleted(battler); } #endif @@ -405,7 +405,7 @@ static void HandleInputChooseAction(u32 battler) { PlaySE(SE_SELECT); TryHideLastUsedBall(); - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_THROW_BALL, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_THROW_BALL, 0); PlayerBufferExecCompleted(battler); } #endif @@ -435,9 +435,9 @@ static void HandleInputChooseTarget(u32 battler) PlaySE(SE_SELECT); gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget; if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX); TryHideLastUsedBall(); HideTriggerSprites(); @@ -593,9 +593,9 @@ static void HandleInputShowEntireFieldTargets(u32 battler) PlaySE(SE_SELECT); HideAllTargets(); if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideMegaTriggerSprite(); PlayerBufferExecCompleted(battler); } @@ -621,9 +621,9 @@ static void HandleInputShowTargets(u32 battler) PlaySE(SE_SELECT); HideShownTargets(battler); if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideTriggerSprites(); TryHideLastUsedBall(); PlayerBufferExecCompleted(battler); @@ -638,12 +638,12 @@ static void HandleInputShowTargets(u32 battler) } } -static void TryShowAsTarget(u32 battlerId) +static void TryShowAsTarget(u32 battler) { - if (IsBattlerAlive(battlerId)) + if (IsBattlerAlive(battler)) { - DoBounceEffect(battlerId, BOUNCE_HEALTHBOX, 15, 1); - gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCB_ShowAsMoveTarget; + DoBounceEffect(battler, BOUNCE_HEALTHBOX, 15, 1); + gSprites[gBattlerSpriteIds[battler]].callback = SpriteCB_ShowAsMoveTarget; } } @@ -736,9 +736,9 @@ static void HandleInputChooseMove(u32 battler) case 0: default: if (gBattleStruct->mega.playerSelect) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | RET_MEGA_EVOLUTION | (gMultiUsePlayerCursor << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8)); HideTriggerSprites(); TryHideLastUsedBall(); PlayerBufferExecCompleted(battler); @@ -774,7 +774,7 @@ static void HandleInputChooseMove(u32 battler) { gBattleStruct->mega.playerSelect = FALSE; gBattleStruct->zmove.viable = FALSE; - BtlController_EmitTwoReturnValues(BUFFER_B, 10, 0xFFFF); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, 0xFFFF); HideTriggerSprites(); PlayerBufferExecCompleted(battler); } @@ -1382,12 +1382,11 @@ static s32 GetTaskExpValue(u8 taskId) static void Task_GiveExpToMon(u8 taskId) { - u32 savedActiveBattler; u32 monId = (u8)(gTasks[taskId].tExpTask_monId); - u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 battler = gTasks[taskId].tExpTask_battler; s32 gainedExp = GetTaskExpValue(taskId); - if (WhichBattleCoords(battlerId) == 1 || monId != gBattlerPartyIndexes[battlerId]) // Give exp without moving the expbar. + if (WhichBattleCoords(battler) == 1 || monId != gBattlerPartyIndexes[battler]) // Give exp without moving the expbar. { struct Pokemon *mon = &gPlayerParty[monId]; u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1400,13 +1399,10 @@ static void Task_GiveExpToMon(u8 taskId) SetMonData(mon, MON_DATA_EXP, &nextLvlExp); CalculateMonStats(mon); gainedExp -= nextLvlExp - currExp; - savedActiveBattler = gActiveBattler; - gActiveBattler = battlerId; - BtlController_EmitTwoReturnValues(BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp); - gActiveBattler = savedActiveBattler; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp); if (IsDoubleBattle() == TRUE - && (monId == gBattlerPartyIndexes[battlerId] || monId == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)])) + && (monId == gBattlerPartyIndexes[battler] || monId == gBattlerPartyIndexes[BATTLE_PARTNER(battler)])) gTasks[taskId].func = Task_LaunchLvlUpAnim; else gTasks[taskId].func = Task_SetControllerToWaitForString; @@ -1415,7 +1411,7 @@ static void Task_GiveExpToMon(u8 taskId) { currExp += gainedExp; SetMonData(mon, MON_DATA_EXP, &currExp); - gBattlerControllerFuncs[battlerId] = Controller_WaitForString; + gBattlerControllerFuncs[battler] = Controller_WaitForString; DestroyTask(taskId); } } @@ -1429,7 +1425,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId) { u8 monIndex = gTasks[taskId].tExpTask_monId; s32 gainedExp = GetTaskExpValue(taskId); - u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 battler = gTasks[taskId].tExpTask_battler; struct Pokemon *mon = &gPlayerParty[monIndex]; u8 level = GetMonData(mon, MON_DATA_LEVEL); u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1439,7 +1435,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId) exp -= currLvlExp; expToNextLvl = gExperienceTables[gSpeciesInfo[species].growthRate][level + 1] - currLvlExp; - SetBattleBarStruct(battlerId, gHealthboxSpriteIds[battlerId], expToNextLvl, exp, -gainedExp); + SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], expToNextLvl, exp, -gainedExp); PlaySE(SE_EXP); gTasks[taskId].func = Task_GiveExpWithExpBar; } @@ -1458,10 +1454,10 @@ static void Task_GiveExpWithExpBar(u8 taskId) { u8 monId = gTasks[taskId].tExpTask_monId; s32 gainedExp = GetTaskExpValue(taskId); - u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 battler = gTasks[taskId].tExpTask_battler; - newExpPoints = MoveBattleBar(battlerId, gHealthboxSpriteIds[battlerId], EXP_BAR, 0); - SetHealthboxSpriteVisible(gHealthboxSpriteIds[battlerId]); + newExpPoints = MoveBattleBar(battler, gHealthboxSpriteIds[battler], EXP_BAR, 0); + SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]); if (newExpPoints == -1) // The bar has been filled with given exp points. { m4aSongNumStop(SE_EXP); @@ -1472,22 +1468,17 @@ static void Task_GiveExpWithExpBar(u8 taskId) if (currExp + gainedExp >= expOnNextLvl) { - u8 savedActiveBattler; - SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &expOnNextLvl); CalculateMonStats(&gPlayerParty[monId]); gainedExp -= expOnNextLvl - currExp; - savedActiveBattler = gActiveBattler; - gActiveBattler = battlerId; - BtlController_EmitTwoReturnValues(BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp); - gActiveBattler = savedActiveBattler; + BtlController_EmitTwoReturnValues(battler, BUFFER_B, RET_VALUE_LEVELED_UP, gainedExp); gTasks[taskId].func = Task_LaunchLvlUpAnim; } else { currExp += gainedExp; SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp); - gBattlerControllerFuncs[battlerId] = Controller_WaitForString; + gBattlerControllerFuncs[battler] = Controller_WaitForString; DestroyTask(taskId); } } @@ -1496,28 +1487,28 @@ static void Task_GiveExpWithExpBar(u8 taskId) static void Task_LaunchLvlUpAnim(u8 taskId) { - u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 battler = gTasks[taskId].tExpTask_battler; u8 monIndex = gTasks[taskId].tExpTask_monId; - if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)]) - battlerId ^= BIT_FLANK; + if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]) + battler ^= BIT_FLANK; - InitAndLaunchSpecialAnimation(battlerId, battlerId, battlerId, B_ANIM_LVL_UP); + InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_LVL_UP); gTasks[taskId].func = Task_UpdateLvlInHealthbox; } static void Task_UpdateLvlInHealthbox(u8 taskId) { - u8 battlerId = gTasks[taskId].tExpTask_battler; + u8 battler = gTasks[taskId].tExpTask_battler; - if (!gBattleSpritesDataPtr->healthBoxesData[battlerId].specialAnimActive) + if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { u8 monIndex = gTasks[taskId].tExpTask_monId; - if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)]) - UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battlerId)], &gPlayerParty[monIndex], HEALTHBOX_ALL); + if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]) + UpdateHealthboxAttribute(gHealthboxSpriteIds[BATTLE_PARTNER(battler)], &gPlayerParty[monIndex], HEALTHBOX_ALL); else - UpdateHealthboxAttribute(gHealthboxSpriteIds[battlerId], &gPlayerParty[monIndex], HEALTHBOX_ALL); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[monIndex], HEALTHBOX_ALL); gTasks[taskId].func = Task_SetControllerToWaitForString; } @@ -1525,8 +1516,8 @@ static void Task_UpdateLvlInHealthbox(u8 taskId) static void Task_SetControllerToWaitForString(u8 taskId) { - u8 battlerId = gTasks[taskId].tExpTask_battler; - gBattlerControllerFuncs[battlerId] = Controller_WaitForString; + u8 battler = gTasks[taskId].tExpTask_battler; + gBattlerControllerFuncs[battler] = Controller_WaitForString; DestroyTask(taskId); } @@ -1549,9 +1540,9 @@ static void WaitForMonSelection(u32 battler) if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { if (gPartyMenuUseExitCallback == TRUE) - BtlController_EmitChosenMonReturnValue(BUFFER_B, gSelectedMonPartyId, gBattlePartyCurrentOrder); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gSelectedMonPartyId, gBattlePartyCurrentOrder); else - BtlController_EmitChosenMonReturnValue(BUFFER_B, PARTY_SIZE, NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, PARTY_SIZE, NULL); if ((gBattleResources->bufferA[battler][1] & 0xF) == 1) PrintLinkStandbyMsg(); @@ -1575,7 +1566,7 @@ static void CompleteWhenChoseItem(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId); PlayerBufferExecCompleted(battler); } } @@ -1602,9 +1593,9 @@ static void PlayerHandleYesNoInput(u32 battler) PlaySE(SE_SELECT); if (gMultiUsePlayerCursor != 0) - BtlController_EmitTwoReturnValues(BUFFER_B, 0xE, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0xE, 0); else - BtlController_EmitTwoReturnValues(BUFFER_B, 0xD, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0xD, 0); PlayerBufferExecCompleted(battler); } @@ -1936,7 +1927,7 @@ static void PlayerChooseMoveInBattlePalace(u32 battler) if (--*(gBattleStruct->arenaMindPoints + battler) == 0) { gBattlePalaceMoveSelectionRngValue = gRngValue; - BtlController_EmitTwoReturnValues(BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); PlayerBufferExecCompleted(battler); } } @@ -2000,7 +1991,7 @@ static void PlayerHandleChoosePokemon(u32 battler) 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[battler] + 1, gBattlePartyCurrentOrder); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, gBattlerPartyIndexes[battler] + 1, gBattlePartyCurrentOrder); PlayerBufferExecCompleted(battler); } else @@ -2099,25 +2090,25 @@ static void PlayerHandlePlayBGM(u32 battler) static void PlayerHandleTwoReturnValues(u32 battler) { - BtlController_EmitTwoReturnValues(BUFFER_B, 0, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 0, 0); PlayerBufferExecCompleted(battler); } static void PlayerHandleChosenMonReturnValue(u32 battler) { - BtlController_EmitChosenMonReturnValue(BUFFER_B, 0, NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, 0, NULL); PlayerBufferExecCompleted(battler); } static void PlayerHandleOneReturnValue(u32 battler) { - BtlController_EmitOneReturnValue(BUFFER_B, 0); + BtlController_EmitOneReturnValue(battler, BUFFER_B, 0); PlayerBufferExecCompleted(battler); } static void PlayerHandleOneReturnValue_Duplicate(u32 battler) { - BtlController_EmitOneReturnValue_Duplicate(BUFFER_B, 0); + BtlController_EmitOneReturnValue_Duplicate(battler, BUFFER_B, 0); PlayerBufferExecCompleted(battler); } diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index 3f6014302b..2fc505d235 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -267,7 +267,7 @@ static void PlayerPartnerBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -340,7 +340,7 @@ static void PlayerPartnerHandlePrintString(u32 battler) static void PlayerPartnerHandleChooseAction(u32 battler) { - AI_TrySwitchOrUseItem(); + AI_TrySwitchOrUseItem(battler); PlayerPartnerBufferExecCompleted(battler); } @@ -366,9 +366,9 @@ static void PlayerPartnerHandleChooseMove(u32 battler) // If partner can mega evolve, do it. if (CanMegaEvolve(battler)) - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (RET_MEGA_EVOLUTION) | (gBattlerTarget << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (RET_MEGA_EVOLUTION) | (gBattlerTarget << 8)); else - BtlController_EmitTwoReturnValues(BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, (chosenMoveId) | (gBattlerTarget << 8)); PlayerPartnerBufferExecCompleted(battler); } @@ -384,7 +384,7 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler) // Switching out else { - chosenMonId = GetMostSuitableMonToSwitchInto(); + chosenMonId = GetMostSuitableMonToSwitchInto(battler); if (chosenMonId == PARTY_SIZE) // just switch to the next mon { u8 playerMonIdentity = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); @@ -402,7 +402,7 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler) } *(gBattleStruct->monToSwitchIntoId + battler) = chosenMonId; } - BtlController_EmitChosenMonReturnValue(BUFFER_B, chosenMonId, NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, chosenMonId, NULL); PlayerPartnerBufferExecCompleted(battler); } diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index 4789708887..b2ee880006 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -140,7 +140,7 @@ static void RecordedOpponentBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -460,7 +460,7 @@ static void RecordedOpponentHandlePrintString(u32 battler) static void RecordedOpponentHandleChooseAction(u32 battler) { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); RecordedOpponentBufferExecCompleted(battler); } @@ -468,13 +468,13 @@ static void RecordedOpponentHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { - BtlController_EmitTwoReturnValues(BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); } else { u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); - BtlController_EmitTwoReturnValues(BUFFER_B, 10, moveId | (target << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, moveId | (target << 8)); } RecordedOpponentBufferExecCompleted(battler); @@ -487,7 +487,7 @@ static void RecordedOpponentHandleChooseItem(u32 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]); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]); RecordedOpponentBufferExecCompleted(battler); } @@ -495,7 +495,7 @@ static void RecordedOpponentHandleChoosePokemon(u32 battler) { *(gBattleStruct->monToSwitchIntoId + battler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing - BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); RecordedOpponentBufferExecCompleted(battler); } diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index aac42824c7..9bd5b8baa3 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -346,7 +346,7 @@ static void RecordedPlayerBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -452,7 +452,7 @@ static void ChooseActionInBattlePalace(u32 battler) { if (gBattleCommunication[4] >= gBattlersCount / 2) { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, battler), 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_BATTLE_PALACE_ACTION, battler), 0); RecordedPlayerBufferExecCompleted(battler); } } @@ -465,7 +465,7 @@ static void RecordedPlayerHandleChooseAction(u32 battler) } else { - BtlController_EmitTwoReturnValues(BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); RecordedPlayerBufferExecCompleted(battler); } } @@ -474,13 +474,13 @@ static void RecordedPlayerHandleChooseMove(u32 battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { - BtlController_EmitTwoReturnValues(BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, ChooseMoveAndTargetInBattlePalace()); } else { u8 moveId = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); - BtlController_EmitTwoReturnValues(BUFFER_B, 10, moveId | (target << 8)); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, moveId | (target << 8)); } RecordedPlayerBufferExecCompleted(battler); @@ -493,7 +493,7 @@ static void RecordedPlayerHandleChooseItem(u32 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]); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gBattleStruct->chosenItem[battler]); RecordedPlayerBufferExecCompleted(battler); } @@ -501,7 +501,7 @@ static void RecordedPlayerHandleChoosePokemon(u32 battler) { *(gBattleStruct->monToSwitchIntoId + battler) = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing - BtlController_EmitChosenMonReturnValue(BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); + BtlController_EmitChosenMonReturnValue(battler, BUFFER_B, *(gBattleStruct->monToSwitchIntoId + battler), NULL); RecordedPlayerBufferExecCompleted(battler); } diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 5f9183f1bd..2069082d8c 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -130,16 +130,16 @@ static void HandleInputChooseAction(u32 battler) switch (gActionSelectionCursor[battler]) { case 0: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_BALL, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_BALL, 0); break; case 1: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_POKEBLOCK, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_POKEBLOCK, 0); break; case 2: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_GO_NEAR, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_GO_NEAR, 0); break; case 3: - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_SAFARI_RUN, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_SAFARI_RUN, 0); break; } SafariBufferExecCompleted(battler); @@ -216,7 +216,7 @@ static void CompleteWhenChosePokeblock(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId); SafariBufferExecCompleted(battler); } } @@ -228,7 +228,7 @@ static void SafariBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index cff9665678..a262886f46 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -149,7 +149,7 @@ static void WallyHandleActions(u32 battler) if (--gBattleStruct->wallyWaitFrames == 0) { PlaySE(SE_SELECT); - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0); WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; @@ -160,7 +160,7 @@ static void WallyHandleActions(u32 battler) if (--gBattleStruct->wallyWaitFrames == 0) { PlaySE(SE_SELECT); - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_MOVE, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_MOVE, 0); WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; @@ -170,7 +170,7 @@ static void WallyHandleActions(u32 battler) case 3: if (--gBattleStruct->wallyWaitFrames == 0) { - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_WALLY_THROW, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_WALLY_THROW, 0); WallyBufferExecCompleted(battler); gBattleStruct->wallyBattleState++; gBattleStruct->wallyMovesState = 0; @@ -191,7 +191,7 @@ static void WallyHandleActions(u32 battler) if (--gBattleStruct->wallyWaitFrames == 0) { PlaySE(SE_SELECT); - BtlController_EmitTwoReturnValues(BUFFER_B, B_ACTION_USE_ITEM, 0); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, B_ACTION_USE_ITEM, 0); WallyBufferExecCompleted(battler); } break; @@ -213,7 +213,7 @@ static void CompleteOnChosenItem(u32 battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { - BtlController_EmitOneReturnValue(BUFFER_B, gSpecialVar_ItemId); + BtlController_EmitOneReturnValue(battler, BUFFER_B, gSpecialVar_ItemId); WallyBufferExecCompleted(battler); } } @@ -283,7 +283,7 @@ static void WallyBufferExecCompleted(u32 battler) { u8 playerId = GetMultiplayerId(); - PrepareBufferDataTransferLink(2, 4, &playerId); + PrepareBufferDataTransferLink(battler, 2, 4, &playerId); gBattleResources->bufferA[battler][0] = CONTROLLER_TERMINATOR_NOP; } else @@ -382,7 +382,7 @@ static void WallyHandleChooseMove(u32 battler) if (--gBattleStruct->wallyMoveFrames == 0) { PlaySE(SE_SELECT); - BtlController_EmitTwoReturnValues(BUFFER_B, 10, 0x100); + BtlController_EmitTwoReturnValues(battler, BUFFER_B, 10, 0x100); WallyBufferExecCompleted(battler); } break; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 1518e46345..0119b332bb 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -26,7 +26,6 @@ static EWRAM_DATA u8 sLinkSendTaskId = 0; static EWRAM_DATA u8 sLinkReceiveTaskId = 0; 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 @@ -671,13 +670,13 @@ static void SetBattlePartyIds(void) } } -static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size) +static void PrepareBufferDataTransfer(u32 battlerId, u32 bufferId, u8 *data, u16 size) { s32 i; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { - PrepareBufferDataTransferLink(bufferId, size, data); + PrepareBufferDataTransferLink(battlerId, bufferId, size, data); } else { @@ -685,11 +684,11 @@ static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size) { case BUFFER_A: for (i = 0; i < size; data++, i++) - gBattleResources->bufferA[gActiveBattler][i] = *data; + gBattleResources->bufferA[battlerId][i] = *data; break; case BUFFER_B: for (i = 0; i < size; data++, i++) - gBattleResources->bufferB[gActiveBattler][i] = *data; + gBattleResources->bufferB[battlerId][i] = *data; break; } } @@ -724,7 +723,7 @@ enum LINK_BUFF_DATA, }; -void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data) +void PrepareBufferDataTransferLink(u32 battlerId, u32 bufferId, u16 size, u8 *data) { s32 alignedSize; s32 i; @@ -736,7 +735,7 @@ void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data) gTasks[sLinkSendTaskId].data[14] = 0; } gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_BUFFER_ID] = bufferId; - gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ACTIVE_BATTLER] = gActiveBattler; + gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ACTIVE_BATTLER] = battlerId; gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ATTACKER] = gBattlerAttacker; gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_TARGET] = gBattlerTarget; gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_SIZE_LO] = alignedSize; @@ -918,191 +917,191 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId) } } -void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck) +void BtlController_EmitGetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck) { - sBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA; - sBattleBuffersTransferData[1] = requestId; - sBattleBuffersTransferData[2] = monToCheck; - sBattleBuffersTransferData[3] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_GETMONDATA; + gBattleResources->transferBuffer[1] = requestId; + gBattleResources->transferBuffer[2] = monToCheck; + gBattleResources->transferBuffer[3] = 0; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes) +static void BtlController_EmitGetRawMonData(u32 battler, u32 bufferId, u8 monId, u8 bytes) { - sBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA; - sBattleBuffersTransferData[1] = monId; - sBattleBuffersTransferData[2] = bytes; - sBattleBuffersTransferData[3] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_GETRAWMONDATA; + gBattleResources->transferBuffer[1] = monId; + gBattleResources->transferBuffer[2] = bytes; + gBattleResources->transferBuffer[3] = 0; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data) +void BtlController_EmitSetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA; - sBattleBuffersTransferData[1] = requestId; - sBattleBuffersTransferData[2] = monToCheck; + gBattleResources->transferBuffer[0] = CONTROLLER_SETMONDATA; + gBattleResources->transferBuffer[1] = requestId; + gBattleResources->transferBuffer[2] = monToCheck; for (i = 0; i < bytes; i++) - sBattleBuffersTransferData[3 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 3 + bytes); + gBattleResources->transferBuffer[3 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 3 + bytes); } // Unused -static void BtlController_EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data) +static void BtlController_EmitSetRawMonData(u32 battler, u32 bufferId, u8 monId, u8 bytes, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_SETRAWMONDATA; - sBattleBuffersTransferData[1] = monId; - sBattleBuffersTransferData[2] = bytes; + gBattleResources->transferBuffer[0] = CONTROLLER_SETRAWMONDATA; + gBattleResources->transferBuffer[1] = monId; + gBattleResources->transferBuffer[2] = bytes; for (i = 0; i < bytes; i++) - sBattleBuffersTransferData[3 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, bytes + 3); + gBattleResources->transferBuffer[3 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, bytes + 3); } -void BtlController_EmitLoadMonSprite(u8 bufferId) +void BtlController_EmitLoadMonSprite(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE; - sBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE; - sBattleBuffersTransferData[2] = CONTROLLER_LOADMONSPRITE; - sBattleBuffersTransferData[3] = CONTROLLER_LOADMONSPRITE; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_LOADMONSPRITE; + gBattleResources->transferBuffer[1] = CONTROLLER_LOADMONSPRITE; + gBattleResources->transferBuffer[2] = CONTROLLER_LOADMONSPRITE; + gBattleResources->transferBuffer[3] = CONTROLLER_LOADMONSPRITE; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit) +void BtlController_EmitSwitchInAnim(u32 battler, u32 bufferId, u8 partyId, bool8 dontClearSubstituteBit) { - sBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM; - sBattleBuffersTransferData[1] = partyId; - sBattleBuffersTransferData[2] = dontClearSubstituteBit; - sBattleBuffersTransferData[3] = 5; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_SWITCHINANIM; + gBattleResources->transferBuffer[1] = partyId; + gBattleResources->transferBuffer[2] = dontClearSubstituteBit; + gBattleResources->transferBuffer[3] = 5; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitReturnMonToBall(u8 bufferId, bool8 skipAnim) +void BtlController_EmitReturnMonToBall(u32 battler, u32 bufferId, bool8 skipAnim) { - sBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL; - sBattleBuffersTransferData[1] = skipAnim; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_RETURNMONTOBALL; + gBattleResources->transferBuffer[1] = skipAnim; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitDrawTrainerPic(u8 bufferId) +void BtlController_EmitDrawTrainerPic(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC; - sBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC; - sBattleBuffersTransferData[2] = CONTROLLER_DRAWTRAINERPIC; - sBattleBuffersTransferData[3] = CONTROLLER_DRAWTRAINERPIC; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_DRAWTRAINERPIC; + gBattleResources->transferBuffer[1] = CONTROLLER_DRAWTRAINERPIC; + gBattleResources->transferBuffer[2] = CONTROLLER_DRAWTRAINERPIC; + gBattleResources->transferBuffer[3] = CONTROLLER_DRAWTRAINERPIC; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitTrainerSlide(u8 bufferId) +void BtlController_EmitTrainerSlide(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE; - sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE; - sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDE; - sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDE; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_TRAINERSLIDE; + gBattleResources->transferBuffer[1] = CONTROLLER_TRAINERSLIDE; + gBattleResources->transferBuffer[2] = CONTROLLER_TRAINERSLIDE; + gBattleResources->transferBuffer[3] = CONTROLLER_TRAINERSLIDE; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitTrainerSlideBack(u8 bufferId) +void BtlController_EmitTrainerSlideBack(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK; - sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK; - sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDEBACK; - sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDEBACK; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_TRAINERSLIDEBACK; + gBattleResources->transferBuffer[1] = CONTROLLER_TRAINERSLIDEBACK; + gBattleResources->transferBuffer[2] = CONTROLLER_TRAINERSLIDEBACK; + gBattleResources->transferBuffer[3] = CONTROLLER_TRAINERSLIDEBACK; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitFaintAnimation(u8 bufferId) +void BtlController_EmitFaintAnimation(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION; - sBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION; - sBattleBuffersTransferData[2] = CONTROLLER_FAINTANIMATION; - sBattleBuffersTransferData[3] = CONTROLLER_FAINTANIMATION; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_FAINTANIMATION; + gBattleResources->transferBuffer[1] = CONTROLLER_FAINTANIMATION; + gBattleResources->transferBuffer[2] = CONTROLLER_FAINTANIMATION; + gBattleResources->transferBuffer[3] = CONTROLLER_FAINTANIMATION; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitPaletteFade(u8 bufferId) +static void BtlController_EmitPaletteFade(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE; - sBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE; - sBattleBuffersTransferData[2] = CONTROLLER_PALETTEFADE; - sBattleBuffersTransferData[3] = CONTROLLER_PALETTEFADE; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_PALETTEFADE; + gBattleResources->transferBuffer[1] = CONTROLLER_PALETTEFADE; + gBattleResources->transferBuffer[2] = CONTROLLER_PALETTEFADE; + gBattleResources->transferBuffer[3] = CONTROLLER_PALETTEFADE; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitSuccessBallThrowAnim(u8 bufferId) +static void BtlController_EmitSuccessBallThrowAnim(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM; - sBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM; - sBattleBuffersTransferData[2] = CONTROLLER_SUCCESSBALLTHROWANIM; - sBattleBuffersTransferData[3] = CONTROLLER_SUCCESSBALLTHROWANIM; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleResources->transferBuffer[1] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleResources->transferBuffer[2] = CONTROLLER_SUCCESSBALLTHROWANIM; + gBattleResources->transferBuffer[3] = CONTROLLER_SUCCESSBALLTHROWANIM; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId) +void BtlController_EmitBallThrowAnim(u32 battler, u32 bufferId, u8 caseId) { - sBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM; - sBattleBuffersTransferData[1] = caseId; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_BALLTHROWANIM; + gBattleResources->transferBuffer[1] = caseId; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } // Unused -static void BtlController_EmitPause(u8 bufferId, u8 toWait, void *data) +static void BtlController_EmitPause(u32 battler, u32 bufferId, u8 toWait, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_PAUSE; - sBattleBuffersTransferData[1] = toWait; + gBattleResources->transferBuffer[0] = CONTROLLER_PAUSE; + gBattleResources->transferBuffer[1] = toWait; for (i = 0; i < toWait * 3; i++) - sBattleBuffersTransferData[2 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, toWait * 3 + 2); + gBattleResources->transferBuffer[2 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, toWait * 3 + 2); } -void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit) +void BtlController_EmitMoveAnimation(u32 battler, u32 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit) { - sBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION; - sBattleBuffersTransferData[1] = move; - sBattleBuffersTransferData[2] = (move & 0xFF00) >> 8; - sBattleBuffersTransferData[3] = turnOfMove; - sBattleBuffersTransferData[4] = movePower; - sBattleBuffersTransferData[5] = (movePower & 0xFF00) >> 8; - sBattleBuffersTransferData[6] = dmg; - sBattleBuffersTransferData[7] = (dmg & 0x0000FF00) >> 8; - sBattleBuffersTransferData[8] = (dmg & 0x00FF0000) >> 16; - sBattleBuffersTransferData[9] = (dmg & 0xFF000000) >> 24; - sBattleBuffersTransferData[10] = friendship; - sBattleBuffersTransferData[11] = multihit; + gBattleResources->transferBuffer[0] = CONTROLLER_MOVEANIMATION; + gBattleResources->transferBuffer[1] = move; + gBattleResources->transferBuffer[2] = (move & 0xFF00) >> 8; + gBattleResources->transferBuffer[3] = turnOfMove; + gBattleResources->transferBuffer[4] = movePower; + gBattleResources->transferBuffer[5] = (movePower & 0xFF00) >> 8; + gBattleResources->transferBuffer[6] = dmg; + gBattleResources->transferBuffer[7] = (dmg & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[8] = (dmg & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[9] = (dmg & 0xFF000000) >> 24; + gBattleResources->transferBuffer[10] = friendship; + gBattleResources->transferBuffer[11] = multihit; if (WEATHER_HAS_EFFECT) { - sBattleBuffersTransferData[12] = gBattleWeather; - sBattleBuffersTransferData[13] = (gBattleWeather & 0xFF00) >> 8; + gBattleResources->transferBuffer[12] = gBattleWeather; + gBattleResources->transferBuffer[13] = (gBattleWeather & 0xFF00) >> 8; } else { - sBattleBuffersTransferData[12] = 0; - sBattleBuffersTransferData[13] = 0; + gBattleResources->transferBuffer[12] = 0; + gBattleResources->transferBuffer[13] = 0; } - sBattleBuffersTransferData[14] = 0; - sBattleBuffersTransferData[15] = 0; - memcpy(&sBattleBuffersTransferData[16], disableStructPtr, sizeof(struct DisableStruct)); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 16 + sizeof(struct DisableStruct)); + gBattleResources->transferBuffer[14] = 0; + gBattleResources->transferBuffer[15] = 0; + memcpy(&gBattleResources->transferBuffer[16], disableStructPtr, sizeof(struct DisableStruct)); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 16 + sizeof(struct DisableStruct)); } -void BtlController_EmitPrintString(u8 bufferId, u16 stringID) +void BtlController_EmitPrintString(u32 battler, u32 bufferId, u16 stringID) { s32 i; struct BattleMsgData *stringInfo; - sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRING; - sBattleBuffersTransferData[1] = gBattleOutcome; - sBattleBuffersTransferData[2] = stringID; - sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_PRINTSTRING; + gBattleResources->transferBuffer[1] = gBattleOutcome; + gBattleResources->transferBuffer[2] = stringID; + gBattleResources->transferBuffer[3] = (stringID & 0xFF00) >> 8; - stringInfo = (struct BattleMsgData *)(&sBattleBuffersTransferData[4]); + stringInfo = (struct BattleMsgData *)(&gBattleResources->transferBuffer[4]); stringInfo->currentMove = gCurrentMove; stringInfo->originallyUsedMove = gChosenMove; stringInfo->lastItem = gLastUsedItem; @@ -1121,20 +1120,20 @@ void BtlController_EmitPrintString(u8 bufferId, u16 stringID) stringInfo->textBuffs[1][i] = gBattleTextBuff2[i]; stringInfo->textBuffs[2][i] = gBattleTextBuff3[i]; } - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(struct BattleMsgData) + 4); } -void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringID) +void BtlController_EmitPrintSelectionString(u32 battler, u32 bufferId, u16 stringID) { s32 i; struct BattleMsgData *stringInfo; - sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRINGPLAYERONLY; - sBattleBuffersTransferData[1] = CONTROLLER_PRINTSTRINGPLAYERONLY; - sBattleBuffersTransferData[2] = stringID; - sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_PRINTSTRINGPLAYERONLY; + gBattleResources->transferBuffer[1] = CONTROLLER_PRINTSTRINGPLAYERONLY; + gBattleResources->transferBuffer[2] = stringID; + gBattleResources->transferBuffer[3] = (stringID & 0xFF00) >> 8; - stringInfo = (struct BattleMsgData *)(&sBattleBuffersTransferData[4]); + stringInfo = (struct BattleMsgData *)(&gBattleResources->transferBuffer[4]); stringInfo->currentMove = gCurrentMove; stringInfo->originallyUsedMove = gChosenMove; stringInfo->lastItem = gLastUsedItem; @@ -1150,414 +1149,413 @@ void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringID) stringInfo->textBuffs[1][i] = gBattleTextBuff2[i]; stringInfo->textBuffs[2][i] = gBattleTextBuff3[i]; } - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(struct BattleMsgData) + 4); } // itemId only relevant for B_ACTION_USE_ITEM -void BtlController_EmitChooseAction(u8 bufferId, u8 action, u16 itemId) +void BtlController_EmitChooseAction(u32 battler, u32 bufferId, u8 action, u16 itemId) { - sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEACTION; - sBattleBuffersTransferData[1] = action; - sBattleBuffersTransferData[2] = itemId; - sBattleBuffersTransferData[3] = (itemId & 0xFF00) >> 8; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_CHOOSEACTION; + gBattleResources->transferBuffer[1] = action; + gBattleResources->transferBuffer[2] = itemId; + gBattleResources->transferBuffer[3] = (itemId & 0xFF00) >> 8; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Only used by the forfeit prompt in the Battle Frontier // For other Yes/No boxes in battle, see Cmd_yesnobox -void BtlController_EmitYesNoBox(u8 bufferId) +void BtlController_EmitYesNoBox(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_YESNOBOX; - sBattleBuffersTransferData[1] = CONTROLLER_YESNOBOX; - sBattleBuffersTransferData[2] = CONTROLLER_YESNOBOX; - sBattleBuffersTransferData[3] = CONTROLLER_YESNOBOX; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_YESNOBOX; + gBattleResources->transferBuffer[1] = CONTROLLER_YESNOBOX; + gBattleResources->transferBuffer[2] = CONTROLLER_YESNOBOX; + gBattleResources->transferBuffer[3] = CONTROLLER_YESNOBOX; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData) +void BtlController_EmitChooseMove(u32 battler, u32 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEMOVE; - sBattleBuffersTransferData[1] = isDoubleBattle; - sBattleBuffersTransferData[2] = NoPpNumber; - sBattleBuffersTransferData[3] = 0; + gBattleResources->transferBuffer[0] = CONTROLLER_CHOOSEMOVE; + gBattleResources->transferBuffer[1] = isDoubleBattle; + gBattleResources->transferBuffer[2] = NoPpNumber; + gBattleResources->transferBuffer[3] = 0; for (i = 0; i < sizeof(*movePpData); i++) - sBattleBuffersTransferData[4 + i] = *((u8 *)(movePpData) + i); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(*movePpData) + 4); + gBattleResources->transferBuffer[4 + i] = *((u8 *)(movePpData) + i); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(*movePpData) + 4); } -void BtlController_EmitChooseItem(u8 bufferId, u8 *battlePartyOrder) +void BtlController_EmitChooseItem(u32 battler, u32 bufferId, u8 *battlePartyOrder) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_OPENBAG; + gBattleResources->transferBuffer[0] = CONTROLLER_OPENBAG; for (i = 0; i < PARTY_SIZE / 2; i++) - sBattleBuffersTransferData[1 + i] = battlePartyOrder[i]; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[1 + i] = battlePartyOrder[i]; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitChoosePokemon(u8 bufferId, u8 caseId, u8 slotId, u16 abilityId, u8 *data) +void BtlController_EmitChoosePokemon(u32 battler, u32 bufferId, u8 caseId, u8 slotId, u16 abilityId, u8 *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEPOKEMON; - sBattleBuffersTransferData[1] = caseId; - sBattleBuffersTransferData[2] = slotId; - sBattleBuffersTransferData[3] = abilityId & 0xFF; - sBattleBuffersTransferData[7] = (abilityId >> 8) & 0xFF; + gBattleResources->transferBuffer[0] = CONTROLLER_CHOOSEPOKEMON; + gBattleResources->transferBuffer[1] = caseId; + gBattleResources->transferBuffer[2] = slotId; + gBattleResources->transferBuffer[3] = abilityId & 0xFF; + gBattleResources->transferBuffer[7] = (abilityId >> 8) & 0xFF; for (i = 0; i < 3; i++) - sBattleBuffersTransferData[4 + i] = data[i]; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 8); // Only 7 bytes were written. + gBattleResources->transferBuffer[4 + i] = data[i]; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 8); // Only 7 bytes were written. } // Unused -static void BtlController_EmitCmd23(u8 bufferId) +static void BtlController_EmitCmd23(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_23; - sBattleBuffersTransferData[1] = CONTROLLER_23; - sBattleBuffersTransferData[2] = CONTROLLER_23; - sBattleBuffersTransferData[3] = CONTROLLER_23; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_23; + gBattleResources->transferBuffer[1] = CONTROLLER_23; + gBattleResources->transferBuffer[2] = CONTROLLER_23; + gBattleResources->transferBuffer[3] = CONTROLLER_23; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // why is the argument u16 if it's being cast to s16 anyway? -void BtlController_EmitHealthBarUpdate(u8 bufferId, u16 hpValue) +void BtlController_EmitHealthBarUpdate(u32 battler, u32 bufferId, u16 hpValue) { - sBattleBuffersTransferData[0] = CONTROLLER_HEALTHBARUPDATE; - sBattleBuffersTransferData[1] = 0; - sBattleBuffersTransferData[2] = (s16)hpValue; - sBattleBuffersTransferData[3] = ((s16)hpValue & 0xFF00) >> 8; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_HEALTHBARUPDATE; + gBattleResources->transferBuffer[1] = 0; + gBattleResources->transferBuffer[2] = (s16)hpValue; + gBattleResources->transferBuffer[3] = ((s16)hpValue & 0xFF00) >> 8; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitExpUpdate(u8 bufferId, u8 partyId, s32 expPoints) +void BtlController_EmitExpUpdate(u32 battler, u32 bufferId, u8 partyId, s32 expPoints) { - sBattleBuffersTransferData[0] = CONTROLLER_EXPUPDATE; - sBattleBuffersTransferData[1] = partyId; - sBattleBuffersTransferData[2] = expPoints; - sBattleBuffersTransferData[3] = (expPoints & 0x0000FF00) >> 8; - sBattleBuffersTransferData[4] = (expPoints & 0x00FF0000) >> 16; - sBattleBuffersTransferData[5] = (expPoints & 0xFF000000) >> 24; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 6); + gBattleResources->transferBuffer[0] = CONTROLLER_EXPUPDATE; + gBattleResources->transferBuffer[1] = partyId; + gBattleResources->transferBuffer[2] = expPoints; + gBattleResources->transferBuffer[3] = (expPoints & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[4] = (expPoints & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[5] = (expPoints & 0xFF000000) >> 24; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } -void BtlController_EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2) +void BtlController_EmitStatusIconUpdate(u32 battler, u32 bufferId, u32 status1, u32 status2) { - sBattleBuffersTransferData[0] = CONTROLLER_STATUSICONUPDATE; - sBattleBuffersTransferData[1] = status1; - sBattleBuffersTransferData[2] = (status1 & 0x0000FF00) >> 8; - sBattleBuffersTransferData[3] = (status1 & 0x00FF0000) >> 16; - sBattleBuffersTransferData[4] = (status1 & 0xFF000000) >> 24; - sBattleBuffersTransferData[5] = status2; - sBattleBuffersTransferData[6] = (status2 & 0x0000FF00) >> 8; - sBattleBuffersTransferData[7] = (status2 & 0x00FF0000) >> 16; - sBattleBuffersTransferData[8] = (status2 & 0xFF000000) >> 24; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 9); + gBattleResources->transferBuffer[0] = CONTROLLER_STATUSICONUPDATE; + gBattleResources->transferBuffer[1] = status1; + gBattleResources->transferBuffer[2] = (status1 & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[3] = (status1 & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[4] = (status1 & 0xFF000000) >> 24; + gBattleResources->transferBuffer[5] = status2; + gBattleResources->transferBuffer[6] = (status2 & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[7] = (status2 & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[8] = (status2 & 0xFF000000) >> 24; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 9); } -void BtlController_EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status) +void BtlController_EmitStatusAnimation(u32 battler, u32 bufferId, bool8 status2, u32 status) { - sBattleBuffersTransferData[0] = CONTROLLER_STATUSANIMATION; - sBattleBuffersTransferData[1] = status2; - sBattleBuffersTransferData[2] = status; - sBattleBuffersTransferData[3] = (status & 0x0000FF00) >> 8; - sBattleBuffersTransferData[4] = (status & 0x00FF0000) >> 16; - sBattleBuffersTransferData[5] = (status & 0xFF000000) >> 24; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 6); + gBattleResources->transferBuffer[0] = CONTROLLER_STATUSANIMATION; + gBattleResources->transferBuffer[1] = status2; + gBattleResources->transferBuffer[2] = status; + gBattleResources->transferBuffer[3] = (status & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[4] = (status & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[5] = (status & 0xFF000000) >> 24; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } // Unused -static void BtlController_EmitStatusXor(u8 bufferId, u8 b) +static void BtlController_EmitStatusXor(u32 battler, u32 bufferId, u8 b) { - sBattleBuffersTransferData[0] = CONTROLLER_STATUSXOR; - sBattleBuffersTransferData[1] = b; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_STATUSXOR; + gBattleResources->transferBuffer[1] = b; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitDataTransfer(u8 bufferId, u16 size, void *data) +void BtlController_EmitDataTransfer(u32 battler, u32 bufferId, u16 size, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_DATATRANSFER; - sBattleBuffersTransferData[1] = CONTROLLER_DATATRANSFER; - sBattleBuffersTransferData[2] = size; - sBattleBuffersTransferData[3] = (size & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_DATATRANSFER; + gBattleResources->transferBuffer[1] = CONTROLLER_DATATRANSFER; + gBattleResources->transferBuffer[2] = size; + gBattleResources->transferBuffer[3] = (size & 0xFF00) >> 8; for (i = 0; i < size; i++) - sBattleBuffersTransferData[4 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 4); + gBattleResources->transferBuffer[4 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 4); } // Unused -static void BtlController_EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data) +static void BtlController_EmitDMA3Transfer(u32 battler, u32 bufferId, void *dst, u16 size, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_DMA3TRANSFER; - sBattleBuffersTransferData[1] = (u32)(dst); - sBattleBuffersTransferData[2] = ((u32)(dst) & 0x0000FF00) >> 8; - sBattleBuffersTransferData[3] = ((u32)(dst) & 0x00FF0000) >> 16; - sBattleBuffersTransferData[4] = ((u32)(dst) & 0xFF000000) >> 24; - sBattleBuffersTransferData[5] = size; - sBattleBuffersTransferData[6] = (size & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_DMA3TRANSFER; + gBattleResources->transferBuffer[1] = (u32)(dst); + gBattleResources->transferBuffer[2] = ((u32)(dst) & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[3] = ((u32)(dst) & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[4] = ((u32)(dst) & 0xFF000000) >> 24; + gBattleResources->transferBuffer[5] = size; + gBattleResources->transferBuffer[6] = (size & 0xFF00) >> 8; for (i = 0; i < size; i++) - sBattleBuffersTransferData[7 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 7); + gBattleResources->transferBuffer[7 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 7); } // Unused -static void BtlController_EmitPlayBGM(u8 bufferId, u16 songId, void *data) +static void BtlController_EmitPlayBGM(u32 battler, u32 bufferId, u16 songId, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_PLAYBGM; - sBattleBuffersTransferData[1] = songId; - sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_PLAYBGM; + gBattleResources->transferBuffer[1] = songId; + gBattleResources->transferBuffer[2] = (songId & 0xFF00) >> 8; // Nonsense loop using songId as a size // Would go out of bounds for any song id after SE_RG_BAG_POCKET (253) for (i = 0; i < songId; i++) - sBattleBuffersTransferData[3 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, songId + 3); + gBattleResources->transferBuffer[3 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, songId + 3); } // Unused -static void BtlController_EmitCmd32(u8 bufferId, u16 size, void *data) +static void BtlController_EmitCmd32(u32 battler, u32 bufferId, u16 size, void *data) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_32; - sBattleBuffersTransferData[1] = size; - sBattleBuffersTransferData[2] = (size & 0xFF00) >> 8; + gBattleResources->transferBuffer[0] = CONTROLLER_32; + gBattleResources->transferBuffer[1] = size; + gBattleResources->transferBuffer[2] = (size & 0xFF00) >> 8; for (i = 0; i < size; i++) - sBattleBuffersTransferData[3 + i] = *(u8 *)(data++); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 3); + gBattleResources->transferBuffer[3 + i] = *(u8 *)(data++); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 3); } -void BtlController_EmitTwoReturnValues(u8 bufferId, u8 ret8, u32 ret32) +void BtlController_EmitTwoReturnValues(u32 battler, u32 bufferId, u8 ret8, u32 ret32) { - sBattleBuffersTransferData[0] = CONTROLLER_TWORETURNVALUES; - sBattleBuffersTransferData[1] = ret8; - sBattleBuffersTransferData[2] = ret32; - sBattleBuffersTransferData[3] = (ret32 & 0x0000FF00) >> 8; - sBattleBuffersTransferData[4] = (ret32 & 0x00FF0000) >> 16; - sBattleBuffersTransferData[5] = (ret32 & 0xFF000000) >> 24; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 6); + gBattleResources->transferBuffer[0] = CONTROLLER_TWORETURNVALUES; + gBattleResources->transferBuffer[1] = ret8; + gBattleResources->transferBuffer[2] = ret32; + gBattleResources->transferBuffer[3] = (ret32 & 0x0000FF00) >> 8; + gBattleResources->transferBuffer[4] = (ret32 & 0x00FF0000) >> 16; + gBattleResources->transferBuffer[5] = (ret32 & 0xFF000000) >> 24; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } -void BtlController_EmitChosenMonReturnValue(u8 bufferId, u8 partyId, u8 *battlePartyOrder) +void BtlController_EmitChosenMonReturnValue(u32 battler, u32 bufferId, u8 partyId, u8 *battlePartyOrder) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_CHOSENMONRETURNVALUE; - sBattleBuffersTransferData[1] = partyId; + gBattleResources->transferBuffer[0] = CONTROLLER_CHOSENMONRETURNVALUE; + gBattleResources->transferBuffer[1] = partyId; for (i = 0; i < (int)ARRAY_COUNT(gBattlePartyCurrentOrder); i++) - sBattleBuffersTransferData[2 + i] = battlePartyOrder[i]; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 5); + gBattleResources->transferBuffer[2 + i] = battlePartyOrder[i]; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 5); } -void BtlController_EmitOneReturnValue(u8 bufferId, u16 ret) +void BtlController_EmitOneReturnValue(u32 battler, u32 bufferId, u16 ret) { - sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE; - sBattleBuffersTransferData[1] = ret; - sBattleBuffersTransferData[2] = (ret & 0xFF00) >> 8; - sBattleBuffersTransferData[3] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_ONERETURNVALUE; + gBattleResources->transferBuffer[1] = ret; + gBattleResources->transferBuffer[2] = (ret & 0xFF00) >> 8; + gBattleResources->transferBuffer[3] = 0; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitOneReturnValue_Duplicate(u8 bufferId, u16 ret) +void BtlController_EmitOneReturnValue_Duplicate(u32 battler, u32 bufferId, u16 ret) { - sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE; - sBattleBuffersTransferData[1] = ret; - sBattleBuffersTransferData[2] = (ret & 0xFF00) >> 8; - sBattleBuffersTransferData[3] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE; + gBattleResources->transferBuffer[1] = ret; + gBattleResources->transferBuffer[2] = (ret & 0xFF00) >> 8; + gBattleResources->transferBuffer[3] = 0; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitClearUnkVar(u8 bufferId) +static void BtlController_EmitClearUnkVar(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_CLEARUNKVAR; - sBattleBuffersTransferData[1] = CONTROLLER_CLEARUNKVAR; - sBattleBuffersTransferData[2] = CONTROLLER_CLEARUNKVAR; - sBattleBuffersTransferData[3] = CONTROLLER_CLEARUNKVAR; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_CLEARUNKVAR; + gBattleResources->transferBuffer[1] = CONTROLLER_CLEARUNKVAR; + gBattleResources->transferBuffer[2] = CONTROLLER_CLEARUNKVAR; + gBattleResources->transferBuffer[3] = CONTROLLER_CLEARUNKVAR; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitSetUnkVar(u8 bufferId, u8 b) +static void BtlController_EmitSetUnkVar(u32 battler, u32 bufferId, u8 b) { - sBattleBuffersTransferData[0] = CONTROLLER_SETUNKVAR; - sBattleBuffersTransferData[1] = b; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_SETUNKVAR; + gBattleResources->transferBuffer[1] = b; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } // Unused -static void BtlController_EmitClearUnkFlag(u8 bufferId) +static void BtlController_EmitClearUnkFlag(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_CLEARUNKFLAG; - sBattleBuffersTransferData[1] = CONTROLLER_CLEARUNKFLAG; - sBattleBuffersTransferData[2] = CONTROLLER_CLEARUNKFLAG; - sBattleBuffersTransferData[3] = CONTROLLER_CLEARUNKFLAG; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_CLEARUNKFLAG; + gBattleResources->transferBuffer[1] = CONTROLLER_CLEARUNKFLAG; + gBattleResources->transferBuffer[2] = CONTROLLER_CLEARUNKFLAG; + gBattleResources->transferBuffer[3] = CONTROLLER_CLEARUNKFLAG; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // Unused -static void BtlController_EmitToggleUnkFlag(u8 bufferId) +static void BtlController_EmitToggleUnkFlag(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_TOGGLEUNKFLAG; - sBattleBuffersTransferData[1] = CONTROLLER_TOGGLEUNKFLAG; - sBattleBuffersTransferData[2] = CONTROLLER_TOGGLEUNKFLAG; - sBattleBuffersTransferData[3] = CONTROLLER_TOGGLEUNKFLAG; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_TOGGLEUNKFLAG; + gBattleResources->transferBuffer[1] = CONTROLLER_TOGGLEUNKFLAG; + gBattleResources->transferBuffer[2] = CONTROLLER_TOGGLEUNKFLAG; + gBattleResources->transferBuffer[3] = CONTROLLER_TOGGLEUNKFLAG; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitHitAnimation(u8 bufferId) +void BtlController_EmitHitAnimation(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION; - sBattleBuffersTransferData[1] = CONTROLLER_HITANIMATION; - sBattleBuffersTransferData[2] = CONTROLLER_HITANIMATION; - sBattleBuffersTransferData[3] = CONTROLLER_HITANIMATION; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_HITANIMATION; + gBattleResources->transferBuffer[1] = CONTROLLER_HITANIMATION; + gBattleResources->transferBuffer[2] = CONTROLLER_HITANIMATION; + gBattleResources->transferBuffer[3] = CONTROLLER_HITANIMATION; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitCantSwitch(u8 bufferId) +void BtlController_EmitCantSwitch(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_CANTSWITCH; - sBattleBuffersTransferData[1] = CONTROLLER_CANTSWITCH; - sBattleBuffersTransferData[2] = CONTROLLER_CANTSWITCH; - sBattleBuffersTransferData[3] = CONTROLLER_CANTSWITCH; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_CANTSWITCH; + gBattleResources->transferBuffer[1] = CONTROLLER_CANTSWITCH; + gBattleResources->transferBuffer[2] = CONTROLLER_CANTSWITCH; + gBattleResources->transferBuffer[3] = CONTROLLER_CANTSWITCH; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitPlaySE(u8 bufferId, u16 songId) +void BtlController_EmitPlaySE(u32 battler, u32 bufferId, u16 songId) { - sBattleBuffersTransferData[0] = CONTROLLER_PLAYSE; - sBattleBuffersTransferData[1] = songId; - sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8; - sBattleBuffersTransferData[3] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_PLAYSE; + gBattleResources->transferBuffer[1] = songId; + gBattleResources->transferBuffer[2] = (songId & 0xFF00) >> 8; + gBattleResources->transferBuffer[3] = 0; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM) +void BtlController_EmitPlayFanfareOrBGM(u32 battler, u32 bufferId, u16 songId, bool8 playBGM) { - sBattleBuffersTransferData[0] = CONTROLLER_PLAYFANFAREORBGM; - sBattleBuffersTransferData[1] = songId; - sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8; - sBattleBuffersTransferData[3] = playBGM; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_PLAYFANFAREORBGM; + gBattleResources->transferBuffer[1] = songId; + gBattleResources->transferBuffer[2] = (songId & 0xFF00) >> 8; + gBattleResources->transferBuffer[3] = playBGM; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitFaintingCry(u8 bufferId) +void BtlController_EmitFaintingCry(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY; - sBattleBuffersTransferData[1] = CONTROLLER_FAINTINGCRY; - sBattleBuffersTransferData[2] = CONTROLLER_FAINTINGCRY; - sBattleBuffersTransferData[3] = CONTROLLER_FAINTINGCRY; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_FAINTINGCRY; + gBattleResources->transferBuffer[1] = CONTROLLER_FAINTINGCRY; + gBattleResources->transferBuffer[2] = CONTROLLER_FAINTINGCRY; + gBattleResources->transferBuffer[3] = CONTROLLER_FAINTINGCRY; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitIntroSlide(u8 bufferId, u8 terrainId) +void BtlController_EmitIntroSlide(u32 battler, u32 bufferId, u8 terrainId) { - sBattleBuffersTransferData[0] = CONTROLLER_INTROSLIDE; - sBattleBuffersTransferData[1] = terrainId; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_INTROSLIDE; + gBattleResources->transferBuffer[1] = terrainId; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitIntroTrainerBallThrow(u8 bufferId) +void BtlController_EmitIntroTrainerBallThrow(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW; - sBattleBuffersTransferData[1] = CONTROLLER_INTROTRAINERBALLTHROW; - sBattleBuffersTransferData[2] = CONTROLLER_INTROTRAINERBALLTHROW; - sBattleBuffersTransferData[3] = CONTROLLER_INTROTRAINERBALLTHROW; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_INTROTRAINERBALLTHROW; + gBattleResources->transferBuffer[1] = CONTROLLER_INTROTRAINERBALLTHROW; + gBattleResources->transferBuffer[2] = CONTROLLER_INTROTRAINERBALLTHROW; + gBattleResources->transferBuffer[3] = CONTROLLER_INTROTRAINERBALLTHROW; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 flags) +void BtlController_EmitDrawPartyStatusSummary(u32 battler, u32 bufferId, struct HpAndStatus* hpAndStatus, u8 flags) { s32 i; - sBattleBuffersTransferData[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; - sBattleBuffersTransferData[1] = flags & ~PARTY_SUMM_SKIP_DRAW_DELAY; // If true, skip player side - sBattleBuffersTransferData[2] = (flags & PARTY_SUMM_SKIP_DRAW_DELAY) >> 7; // If true, skip delay after drawing. True during intro - sBattleBuffersTransferData[3] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; + gBattleResources->transferBuffer[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; + gBattleResources->transferBuffer[1] = flags & ~PARTY_SUMM_SKIP_DRAW_DELAY; // If true, skip player side + gBattleResources->transferBuffer[2] = (flags & PARTY_SUMM_SKIP_DRAW_DELAY) >> 7; // If true, skip delay after drawing. True during intro + gBattleResources->transferBuffer[3] = CONTROLLER_DRAWPARTYSTATUSSUMMARY; for (i = 0; i < (s32)(sizeof(struct HpAndStatus) * PARTY_SIZE); i++) - sBattleBuffersTransferData[4 + i] = *(i + (u8 *)(hpAndStatus)); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct HpAndStatus) * PARTY_SIZE + 4); + gBattleResources->transferBuffer[4 + i] = *(i + (u8 *)(hpAndStatus)); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(struct HpAndStatus) * PARTY_SIZE + 4); } -void BtlController_EmitHidePartyStatusSummary(u8 bufferId) +void BtlController_EmitHidePartyStatusSummary(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; - sBattleBuffersTransferData[1] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; - sBattleBuffersTransferData[2] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; - sBattleBuffersTransferData[3] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; + gBattleResources->transferBuffer[1] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; + gBattleResources->transferBuffer[2] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; + gBattleResources->transferBuffer[3] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitEndBounceEffect(u8 bufferId) +void BtlController_EmitEndBounceEffect(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_ENDBOUNCE; - sBattleBuffersTransferData[1] = CONTROLLER_ENDBOUNCE; - sBattleBuffersTransferData[2] = CONTROLLER_ENDBOUNCE; - sBattleBuffersTransferData[3] = CONTROLLER_ENDBOUNCE; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_ENDBOUNCE; + gBattleResources->transferBuffer[1] = CONTROLLER_ENDBOUNCE; + gBattleResources->transferBuffer[2] = CONTROLLER_ENDBOUNCE; + gBattleResources->transferBuffer[3] = CONTROLLER_ENDBOUNCE; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible) +void BtlController_EmitSpriteInvisibility(u32 battler, u32 bufferId, bool8 isInvisible) { - sBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY; - sBattleBuffersTransferData[1] = isInvisible; - sBattleBuffersTransferData[2] = CONTROLLER_SPRITEINVISIBILITY; - sBattleBuffersTransferData[3] = CONTROLLER_SPRITEINVISIBILITY; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_SPRITEINVISIBILITY; + gBattleResources->transferBuffer[1] = isInvisible; + gBattleResources->transferBuffer[2] = CONTROLLER_SPRITEINVISIBILITY; + gBattleResources->transferBuffer[3] = CONTROLLER_SPRITEINVISIBILITY; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument) +void BtlController_EmitBattleAnimation(u32 battler, u32 bufferId, u8 animationId, u16 argument) { - sBattleBuffersTransferData[0] = CONTROLLER_BATTLEANIMATION; - sBattleBuffersTransferData[1] = animationId; - sBattleBuffersTransferData[2] = argument; - sBattleBuffersTransferData[3] = (argument & 0xFF00) >> 8; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4); + gBattleResources->transferBuffer[0] = CONTROLLER_BATTLEANIMATION; + gBattleResources->transferBuffer[1] = animationId; + gBattleResources->transferBuffer[2] = argument; + gBattleResources->transferBuffer[3] = (argument & 0xFF00) >> 8; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } // mode is a LINK_STANDBY_* constant -void BtlController_EmitLinkStandbyMsg(u8 bufferId, u8 mode, bool32 record) +void BtlController_EmitLinkStandbyMsg(u32 battler, u32 bufferId, u8 mode, bool32 record) { - bool8 record_ = record; - sBattleBuffersTransferData[0] = CONTROLLER_LINKSTANDBYMSG; - sBattleBuffersTransferData[1] = mode; + gBattleResources->transferBuffer[0] = CONTROLLER_LINKSTANDBYMSG; + gBattleResources->transferBuffer[1] = mode; - if (record_) - sBattleBuffersTransferData[3] = sBattleBuffersTransferData[2] = RecordedBattle_BufferNewBattlerData(&sBattleBuffersTransferData[4]); + if (record) + gBattleResources->transferBuffer[3] = gBattleResources->transferBuffer[2] = RecordedBattle_BufferNewBattlerData(&gBattleResources->transferBuffer[4]); else - sBattleBuffersTransferData[3] = sBattleBuffersTransferData[2] = 0; + gBattleResources->transferBuffer[3] = gBattleResources->transferBuffer[2] = 0; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sBattleBuffersTransferData[2] + 4); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, gBattleResources->transferBuffer[2] + 4); } -void BtlController_EmitResetActionMoveSelection(u8 bufferId, u8 caseId) +void BtlController_EmitResetActionMoveSelection(u32 battler, u32 bufferId, u8 caseId) { - sBattleBuffersTransferData[0] = CONTROLLER_RESETACTIONMOVESELECTION; - sBattleBuffersTransferData[1] = caseId; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2); + gBattleResources->transferBuffer[0] = CONTROLLER_RESETACTIONMOVESELECTION; + gBattleResources->transferBuffer[1] = caseId; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitEndLinkBattle(u8 bufferId, u8 battleOutcome) +void BtlController_EmitEndLinkBattle(u32 battler, u32 bufferId, u8 battleOutcome) { - sBattleBuffersTransferData[0] = CONTROLLER_ENDLINKBATTLE; - sBattleBuffersTransferData[1] = battleOutcome; - sBattleBuffersTransferData[2] = gSaveBlock2Ptr->frontier.disableRecordBattle; - sBattleBuffersTransferData[3] = gSaveBlock2Ptr->frontier.disableRecordBattle; - sBattleBuffersTransferData[5] = sBattleBuffersTransferData[4] = RecordedBattle_BufferNewBattlerData(&sBattleBuffersTransferData[6]); - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sBattleBuffersTransferData[4] + 6); + gBattleResources->transferBuffer[0] = CONTROLLER_ENDLINKBATTLE; + gBattleResources->transferBuffer[1] = battleOutcome; + gBattleResources->transferBuffer[2] = gSaveBlock2Ptr->frontier.disableRecordBattle; + gBattleResources->transferBuffer[3] = gSaveBlock2Ptr->frontier.disableRecordBattle; + gBattleResources->transferBuffer[5] = gBattleResources->transferBuffer[4] = RecordedBattle_BufferNewBattlerData(&gBattleResources->transferBuffer[6]); + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, gBattleResources->transferBuffer[4] + 6); } -void BtlController_EmitDebugMenu(u8 bufferId) +void BtlController_EmitDebugMenu(u32 battler, u32 bufferId) { - sBattleBuffersTransferData[0] = CONTROLLER_DEBUGMENU; - PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 1); + gBattleResources->transferBuffer[0] = CONTROLLER_DEBUGMENU; + PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 1); } // Standardized Controller functions @@ -2124,7 +2122,7 @@ void StartSendOutAnim(u32 battler, bool32 dontClearSubstituteBit) gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler]; gSprites[gBattleControllerData[battler]].data[2] = battler; - gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, (side == B_SIDE_OPPONENT) ? POKEBALL_OPPONENT_SENDOUT : POKEBALL_PLAYER_SENDOUT); + gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(battler, 0, (side == B_SIDE_OPPONENT) ? POKEBALL_OPPONENT_SENDOUT : POKEBALL_PLAYER_SENDOUT); } static void FreeMonSprite(u32 battler) @@ -2363,7 +2361,7 @@ void BtlController_HandleGetMonData(u32 battler) monToCheck >>= 1; } } - BtlController_EmitDataTransfer(BUFFER_B, size, monData); + BtlController_EmitDataTransfer(battler, BUFFER_B, size, monData); BattleControllerComplete(battler); } @@ -2379,7 +2377,7 @@ void BtlController_HandleGetRawMonData(u32 battler) for (i = 0; i < gBattleResources->bufferA[battler][2]; i++) dst[i] = src[i]; - BtlController_EmitDataTransfer(BUFFER_B, gBattleResources->bufferA[battler][2], dst); + BtlController_EmitDataTransfer(battler, BUFFER_B, gBattleResources->bufferA[battler][2], dst); BattleControllerComplete(battler); } @@ -2930,26 +2928,25 @@ static void Task_StartSendOutAnim(u8 taskId) } else { - u8 savedActiveBattler = gActiveBattler; + u32 battlerPartner; + u32 battler = gTasks[taskId].tBattlerId; - gActiveBattler = gTasks[taskId].tBattlerId; - if (TwoMonsAtSendOut(gActiveBattler)) + if (TwoMonsAtSendOut(battler)) { - gBattleResources->bufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; - StartSendOutAnim(gActiveBattler, FALSE); - gActiveBattler ^= BIT_FLANK; - gBattleResources->bufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; - BattleLoadMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); - StartSendOutAnim(gActiveBattler, FALSE); - gActiveBattler ^= BIT_FLANK; + gBattleResources->bufferA[battler][1] = gBattlerPartyIndexes[battler]; + StartSendOutAnim(battler, FALSE); + + battlerPartner = battler ^ BIT_FLANK; + gBattleResources->bufferA[battlerPartner][1] = gBattlerPartyIndexes[battlerPartner]; + BattleLoadMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battlerPartner]], battlerPartner); + StartSendOutAnim(battlerPartner, FALSE); } else { - gBattleResources->bufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler]; - StartSendOutAnim(gActiveBattler, FALSE); + gBattleResources->bufferA[battler][1] = gBattlerPartyIndexes[battler]; + StartSendOutAnim(battler, FALSE); } - gBattlerControllerFuncs[gActiveBattler] = (void*)(GetWordTaskArg(taskId, tControllerFunc_1)); - gActiveBattler = savedActiveBattler; + gBattlerControllerFuncs[battler] = (void*)(GetWordTaskArg(taskId, tControllerFunc_1)); DestroyTask(taskId); } } diff --git a/src/battle_main.c b/src/battle_main.c index ed26436f87..17c045f07d 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -3412,14 +3412,15 @@ void FaintClearSetData(void) static void DoBattleIntro(void) { s32 i; + u32 battler; u8 *state = &gBattleStruct->introState; switch (*state) { case 0: // Get Data of all battlers. - gActiveBattler = gBattleCommunication[1]; - BtlController_EmitGetMonData(BUFFER_A, REQUEST_ALL_BATTLE, 0); - MarkBattlerForControllerExec(gActiveBattler); + battler = gBattleCommunication[1]; + BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 0); + MarkBattlerForControllerExec(battler); (*state)++; break; case 1: // Loop through all battlers. @@ -3434,9 +3435,9 @@ static void DoBattleIntro(void) case 2: // Start graphical intro slide. if (!gBattleControllerExecFlags) { - gActiveBattler = GetBattlerAtPosition(0); - BtlController_EmitIntroSlide(BUFFER_A, gBattleTerrain); - MarkBattlerForControllerExec(gActiveBattler); + battler = GetBattlerAtPosition(0); + BtlController_EmitIntroSlide(battler, BUFFER_A, gBattleTerrain); + MarkBattlerForControllerExec(battler); gBattleCommunication[0] = 0; gBattleCommunication[1] = 0; (*state)++; @@ -3447,50 +3448,50 @@ static void DoBattleIntro(void) (*state)++; break; case 4: // Copy battler data gotten in cases 0 and 1. Draw trainer/mon sprite. - for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) + for (battler = 0; battler < gBattlersCount; battler++) { - if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI) && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + if ((gBattleTypeFlags & BATTLE_TYPE_SAFARI) && GetBattlerSide(battler) == B_SIDE_PLAYER) { - memset(&gBattleMons[gActiveBattler], 0, sizeof(struct BattlePokemon)); + memset(&gBattleMons[battler], 0, sizeof(struct BattlePokemon)); } else { - memcpy(&gBattleMons[gActiveBattler], &gBattleResources->bufferB[gActiveBattler][4], sizeof(struct BattlePokemon)); - gBattleMons[gActiveBattler].type1 = gSpeciesInfo[gBattleMons[gActiveBattler].species].types[0]; - gBattleMons[gActiveBattler].type2 = gSpeciesInfo[gBattleMons[gActiveBattler].species].types[1]; - gBattleMons[gActiveBattler].type3 = TYPE_MYSTERY; - gBattleMons[gActiveBattler].ability = GetAbilityBySpecies(gBattleMons[gActiveBattler].species, gBattleMons[gActiveBattler].abilityNum); - gBattleStruct->hpOnSwitchout[GetBattlerSide(gActiveBattler)] = gBattleMons[gActiveBattler].hp; - gBattleMons[gActiveBattler].status2 = 0; + memcpy(&gBattleMons[battler], &gBattleResources->bufferB[battler][4], sizeof(struct BattlePokemon)); + gBattleMons[battler].type1 = gSpeciesInfo[gBattleMons[battler].species].types[0]; + gBattleMons[battler].type2 = gSpeciesInfo[gBattleMons[battler].species].types[1]; + gBattleMons[battler].type3 = TYPE_MYSTERY; + gBattleMons[battler].ability = GetAbilityBySpecies(gBattleMons[battler].species, gBattleMons[battler].abilityNum); + gBattleStruct->hpOnSwitchout[GetBattlerSide(battler)] = gBattleMons[battler].hp; + gBattleMons[battler].status2 = 0; for (i = 0; i < NUM_BATTLE_STATS; i++) - gBattleMons[gActiveBattler].statStages[i] = DEFAULT_STAT_STAGE; + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; } // Draw sprite. - switch (GetBattlerPosition(gActiveBattler)) + switch (GetBattlerPosition(battler)) { case B_POSITION_PLAYER_LEFT: // player sprite - BtlController_EmitDrawTrainerPic(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitDrawTrainerPic(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); break; case B_POSITION_OPPONENT_LEFT: if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) // opponent 1 sprite { - BtlController_EmitDrawTrainerPic(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitDrawTrainerPic(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } else // wild mon 1 { - BtlController_EmitLoadMonSprite(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); - gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES, NULL); + BtlController_EmitLoadMonSprite(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); + gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL); } break; case B_POSITION_PLAYER_RIGHT: if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_INGAME_PARTNER)) // partner sprite { - BtlController_EmitDrawTrainerPic(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitDrawTrainerPic(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } break; case B_POSITION_OPPONENT_RIGHT: @@ -3498,15 +3499,15 @@ static void DoBattleIntro(void) { if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) // opponent 2 if exists { - BtlController_EmitDrawTrainerPic(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitDrawTrainerPic(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } } - else if (IsBattlerAlive(gActiveBattler)) // wild mon 2 if alive + else if (IsBattlerAlive(battler)) // wild mon 2 if alive { - BtlController_EmitLoadMonSprite(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); - gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES, NULL); + BtlController_EmitLoadMonSprite(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); + gBattleResults.lastOpponentSpecies = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL); } break; } @@ -3548,9 +3549,9 @@ static void DoBattleIntro(void) } } - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); - BtlController_EmitDrawPartyStatusSummary(BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY); - MarkBattlerForControllerExec(gActiveBattler); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY); + MarkBattlerForControllerExec(battler); for (i = 0; i < PARTY_SIZE; i++) { @@ -3567,9 +3568,9 @@ static void DoBattleIntro(void) } } - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - BtlController_EmitDrawPartyStatusSummary(BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY); - MarkBattlerForControllerExec(gActiveBattler); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatus, PARTY_SUMM_SKIP_DRAW_DELAY); + MarkBattlerForControllerExec(battler); (*state)++; } @@ -3615,12 +3616,12 @@ static void DoBattleIntro(void) break; case 11: // first opponent's mon send out animation if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); - BtlController_EmitIntroTrainerBallThrow(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); (*state)++; break; case 12: // nothing @@ -3629,12 +3630,12 @@ static void DoBattleIntro(void) if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_TWO_OPPONENTS) && !BATTLE_TWO_VS_ONE_OPPONENT) { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); - BtlController_EmitIntroTrainerBallThrow(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } #if B_FAST_INTRO == TRUE if (!(gBattleTypeFlags & (BATTLE_TYPE_RECORDED | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_LINK))) @@ -3655,21 +3656,21 @@ static void DoBattleIntro(void) if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI)) { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); // A hack that makes fast intro work in trainer battles too. #if B_FAST_INTRO == TRUE if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && !(gBattleTypeFlags & (BATTLE_TYPE_RECORDED | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_RECORDED_IS_MASTER | BATTLE_TYPE_LINK)) - && gSprites[gHealthboxSpriteIds[gActiveBattler ^ BIT_SIDE]].callback == SpriteCallbackDummy) + && gSprites[gHealthboxSpriteIds[battler ^ BIT_SIDE]].callback == SpriteCallbackDummy) { return; } #endif - PrepareStringBattle(STRINGID_INTROSENDOUT, gActiveBattler); + PrepareStringBattle(STRINGID_INTROSENDOUT, battler); } (*state)++; break; @@ -3677,50 +3678,50 @@ static void DoBattleIntro(void) if (!(gBattleTypeFlags & BATTLE_TYPE_LINK && gBattleControllerExecFlags)) { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - if (!IsBattlerMarkedForControllerExec(gActiveBattler)) + if (!IsBattlerMarkedForControllerExec(battler)) (*state)++; } break; case 18: // player 1 send out if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - BtlController_EmitIntroTrainerBallThrow(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); (*state)++; break; case 19: // player 2 send out if (gBattleTypeFlags & (BATTLE_TYPE_MULTI | BATTLE_TYPE_INGAME_PARTNER)) { if (gBattleTypeFlags & BATTLE_TYPE_RECORDED_LINK && !(gBattleTypeFlags & BATTLE_TYPE_RECORDED_IS_MASTER)) - gActiveBattler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + battler = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); else - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + battler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); - BtlController_EmitIntroTrainerBallThrow(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitIntroTrainerBallThrow(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } (*state)++; break; case 20: // set dex and battle vars if (!gBattleControllerExecFlags) { - for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) + for (battler = 0; battler < gBattlersCount; battler++) { - if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT + if (GetBattlerSide(battler) == B_SIDE_OPPONENT && !(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_FRONTIER | BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER_HILL))) { - HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBattler].species), FLAG_SET_SEEN, gBattleMons[gActiveBattler].personality); + HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[battler].species), FLAG_SET_SEEN, gBattleMons[battler].personality); } } @@ -4123,7 +4124,7 @@ static void HandleTurnActionSelectionState(void) else { gBattleStruct->itemPartyIndex[gActiveBattler] = PARTY_SIZE; - BtlController_EmitChooseAction(BUFFER_A, gChosenActionByBattler[0], gBattleResources->bufferB[0][1] | (gBattleResources->bufferB[0][2] << 8)); + BtlController_EmitChooseAction(gActiveBattler, BUFFER_A, gChosenActionByBattler[0], gBattleResources->bufferB[0][1] | (gBattleResources->bufferB[0][2] << 8)); MarkBattlerForControllerExec(gActiveBattler); gBattleCommunication[gActiveBattler]++; } @@ -4175,7 +4176,7 @@ static void HandleTurnActionSelectionState(void) i); } - BtlController_EmitChooseMove(BUFFER_A, (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) != 0, FALSE, &moveInfo); + BtlController_EmitChooseMove(gActiveBattler, BUFFER_A, (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) != 0, FALSE, &moveInfo); MarkBattlerForControllerExec(gActiveBattler); } break; @@ -4207,7 +4208,7 @@ static void HandleTurnActionSelectionState(void) } else { - BtlController_EmitChooseItem(BUFFER_A, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChooseItem(gActiveBattler, BUFFER_A, gBattleStruct->battlerPartyOrders[gActiveBattler]); MarkBattlerForControllerExec(gActiveBattler); } break; @@ -4216,21 +4217,21 @@ static void HandleTurnActionSelectionState(void) if (gBattleTypeFlags & BATTLE_TYPE_ARENA || !CanBattlerEscape(gActiveBattler)) { - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_CANT_SWITCH, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChoosePokemon(gActiveBattler, BUFFER_A, PARTY_ACTION_CANT_SWITCH, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); } else if (ItemId_GetHoldEffect(gBattleMons[gActiveBattler].item) != HOLD_EFFECT_SHED_SHELL && (i = IsAbilityPreventingEscape(gActiveBattler))) // must be last to keep i value integrity { - BtlController_EmitChoosePokemon(BUFFER_A, ((i - 1) << 4) | PARTY_ACTION_ABILITY_PREVENTS, PARTY_SIZE, gBattleMons[i - 1].ability, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChoosePokemon(gActiveBattler, BUFFER_A, ((i - 1) << 4) | PARTY_ACTION_ABILITY_PREVENTS, PARTY_SIZE, gBattleMons[i - 1].ability, gBattleStruct->battlerPartyOrders[gActiveBattler]); } else { if (gActiveBattler == 2 && gChosenActionByBattler[0] == B_ACTION_SWITCH) - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 0), ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChoosePokemon(gActiveBattler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 0), ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); else if (gActiveBattler == 3 && gChosenActionByBattler[1] == B_ACTION_SWITCH) - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 1), ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChoosePokemon(gActiveBattler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, *(gBattleStruct->monToSwitchIntoId + 1), ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); else - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_CHOOSE_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChoosePokemon(gActiveBattler, BUFFER_A, PARTY_ACTION_CHOOSE_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); } MarkBattlerForControllerExec(gActiveBattler); break; @@ -4245,7 +4246,7 @@ static void HandleTurnActionSelectionState(void) } break; case B_ACTION_SAFARI_POKEBLOCK: - BtlController_EmitChooseItem(BUFFER_A, gBattleStruct->battlerPartyOrders[gActiveBattler]); + BtlController_EmitChooseItem(gActiveBattler, BUFFER_A, gBattleStruct->battlerPartyOrders[gActiveBattler]); MarkBattlerForControllerExec(gActiveBattler); break; case B_ACTION_CANCEL_PARTNER: @@ -4255,7 +4256,7 @@ static void HandleTurnActionSelectionState(void) if (gBattleMons[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))].status2 & STATUS2_MULTIPLETURNS || gBattleMons[GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gActiveBattler)))].status2 & STATUS2_RECHARGE) { - BtlController_EmitEndBounceEffect(BUFFER_A); + BtlController_EmitEndBounceEffect(gActiveBattler, BUFFER_A); MarkBattlerForControllerExec(gActiveBattler); return; } @@ -4286,11 +4287,11 @@ static void HandleTurnActionSelectionState(void) gBattleStruct->mega.toEvolve &= ~(gBitTable[BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))]); gBattleStruct->zmove.toBeUsed[BATTLE_PARTNER(GetBattlerPosition(gActiveBattler))] = MOVE_NONE; - BtlController_EmitEndBounceEffect(BUFFER_A); + BtlController_EmitEndBounceEffect(gActiveBattler, BUFFER_A); MarkBattlerForControllerExec(gActiveBattler); return; case B_ACTION_DEBUG: - BtlController_EmitDebugMenu(BUFFER_A); + BtlController_EmitDebugMenu(gActiveBattler, BUFFER_A); MarkBattlerForControllerExec(gActiveBattler); break; } @@ -4458,11 +4459,11 @@ static void HandleTurnActionSelectionState(void) || (position & BIT_FLANK) != B_FLANK_LEFT || (*(&gBattleStruct->absentBattlerFlags) & gBitTable[GetBattlerAtPosition(BATTLE_PARTNER(position))])) { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_STOP_BOUNCE, i); + BtlController_EmitLinkStandbyMsg(gActiveBattler, BUFFER_A, LINK_STANDBY_MSG_STOP_BOUNCE, i); } else { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_STOP_BOUNCE_ONLY, i); + BtlController_EmitLinkStandbyMsg(gActiveBattler, BUFFER_A, LINK_STANDBY_STOP_BOUNCE_ONLY, i); } MarkBattlerForControllerExec(gActiveBattler); gBattleCommunication[gActiveBattler]++; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index a8e689dc69..f72c7b5e62 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -1879,8 +1879,7 @@ static void Cmd_ppreduce(void) if (MOVE_IS_PERMANENT(gBattlerAttacker, gCurrMovePos)) { - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0, + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_PPMOVE1_BATTLE + gCurrMovePos, 0, sizeof(gBattleMons[gBattlerAttacker].pp[gCurrMovePos]), &gBattleMons[gBattlerAttacker].pp[gCurrMovePos]); MarkBattlerForControllerExec(gBattlerAttacker); @@ -2212,8 +2211,6 @@ static void Cmd_attackanimation(void) { u8 multihit; - gActiveBattler = gBattlerAttacker; - if (gBattleMons[gBattlerTarget].status2 & STATUS2_SUBSTITUTE) multihit = gMultiHitCounter; else if (gMultiHitCounter != 0 && gMultiHitCounter != 1) @@ -2226,7 +2223,7 @@ static void Cmd_attackanimation(void) else multihit = gMultiHitCounter; - BtlController_EmitMoveAnimation(BUFFER_A, gCurrentMove, gBattleScripting.animTurn, gBattleMovePower, gBattleMoveDamage, gBattleMons[gBattlerAttacker].friendship, &gDisableStructs[gBattlerAttacker], multihit); + BtlController_EmitMoveAnimation(gBattlerAttacker, BUFFER_A, gCurrentMove, gBattleScripting.animTurn, gBattleMovePower, gBattleMoveDamage, gBattleMons[gBattlerAttacker].friendship, &gDisableStructs[gBattlerAttacker], multihit); gBattleScripting.animTurn++; gBattleScripting.animTargetsHit++; MarkBattlerForControllerExec(gBattlerAttacker); @@ -2257,20 +2254,20 @@ static void Cmd_healthbarupdate(void) if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT) || (gHitMarker & HITMARKER_PASSIVE_DAMAGE)) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + u32 battler = GetBattlerForBattleScript(cmd->battler); - if (DoesSubstituteBlockMove(gBattlerAttacker, gActiveBattler, gCurrentMove) && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE)) + if (DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && gDisableStructs[battler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE)) { - PrepareStringBattle(STRINGID_SUBSTITUTEDAMAGED, gActiveBattler); + PrepareStringBattle(STRINGID_SUBSTITUTEDAMAGED, battler); } - else if (!DoesDisguiseBlockMove(gBattlerAttacker, gActiveBattler, gCurrentMove)) + else if (!DoesDisguiseBlockMove(gBattlerAttacker, battler, gCurrentMove)) { s16 healthValue = min(gBattleMoveDamage, 10000); // Max damage (10000) not present in R/S, ensures that huge damage values don't change sign - BtlController_EmitHealthBarUpdate(BUFFER_A, healthValue); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitHealthBarUpdate(battler, BUFFER_A, healthValue); + MarkBattlerForControllerExec(battler); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleMoveDamage > 0) + if (GetBattlerSide(battler) == B_SIDE_PLAYER && gBattleMoveDamage > 0) gBattleResults.playerMonWasDamaged = TRUE; } } @@ -2282,7 +2279,7 @@ static void Cmd_datahpupdate(void) { CMD_ARGS(u8 battler); - u32 moveType; + u32 battler, moveType; if (gBattleControllerExecFlags) return; @@ -2296,25 +2293,25 @@ static void Cmd_datahpupdate(void) if (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT) || (gHitMarker & HITMARKER_PASSIVE_DAMAGE)) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - if (DoesSubstituteBlockMove(gBattlerAttacker, gActiveBattler, gCurrentMove) && gDisableStructs[gActiveBattler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE)) + battler = GetBattlerForBattleScript(cmd->battler); + if (DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && gDisableStructs[battler].substituteHP && !(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE)) { - if (gDisableStructs[gActiveBattler].substituteHP >= gBattleMoveDamage) + if (gDisableStructs[battler].substituteHP >= gBattleMoveDamage) { - if (gSpecialStatuses[gActiveBattler].dmg == 0) - gSpecialStatuses[gActiveBattler].dmg = gBattleMoveDamage; - gDisableStructs[gActiveBattler].substituteHP -= gBattleMoveDamage; + if (gSpecialStatuses[battler].dmg == 0) + gSpecialStatuses[battler].dmg = gBattleMoveDamage; + gDisableStructs[battler].substituteHP -= gBattleMoveDamage; gHpDealt = gBattleMoveDamage; } else { - if (gSpecialStatuses[gActiveBattler].dmg == 0) - gSpecialStatuses[gActiveBattler].dmg = gDisableStructs[gActiveBattler].substituteHP; - gHpDealt = gDisableStructs[gActiveBattler].substituteHP; - gDisableStructs[gActiveBattler].substituteHP = 0; + if (gSpecialStatuses[battler].dmg == 0) + gSpecialStatuses[battler].dmg = gDisableStructs[battler].substituteHP; + gHpDealt = gDisableStructs[battler].substituteHP; + gDisableStructs[battler].substituteHP = 0; } // check substitute fading - if (gDisableStructs[gActiveBattler].substituteHP == 0) + if (gDisableStructs[battler].substituteHP == 0) { gBattlescriptCurrInstr = cmd->nextInstr; BattleScriptPushCursor(); @@ -2322,9 +2319,9 @@ static void Cmd_datahpupdate(void) return; } } - else if (DoesDisguiseBlockMove(gBattlerAttacker, gActiveBattler, gCurrentMove)) + else if (DoesDisguiseBlockMove(gBattlerAttacker, battler, gCurrentMove)) { - gBattleMons[gActiveBattler].species = SPECIES_MIMIKYU_BUSTED; + gBattleMons[battler].species = SPECIES_MIMIKYU_BUSTED; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = BattleScript_TargetFormChange; return; @@ -2334,9 +2331,9 @@ static void Cmd_datahpupdate(void) gHitMarker &= ~HITMARKER_IGNORE_SUBSTITUTE; if (gBattleMoveDamage < 0) // hp goes up { - gBattleMons[gActiveBattler].hp -= gBattleMoveDamage; - if (gBattleMons[gActiveBattler].hp > gBattleMons[gActiveBattler].maxHP) - gBattleMons[gActiveBattler].hp = gBattleMons[gActiveBattler].maxHP; + gBattleMons[battler].hp -= gBattleMoveDamage; + if (gBattleMons[battler].hp > gBattleMons[battler].maxHP) + gBattleMons[battler].hp = gBattleMons[battler].maxHP; } else // hp goes down @@ -2347,68 +2344,68 @@ static void Cmd_datahpupdate(void) } else { - gTakenDmg[gActiveBattler] += gBattleMoveDamage; + gTakenDmg[battler] += gBattleMoveDamage; if (cmd->battler == BS_TARGET) - gTakenDmgByBattler[gActiveBattler] = gBattlerAttacker; + gTakenDmgByBattler[battler] = gBattlerAttacker; else - gTakenDmgByBattler[gActiveBattler] = gBattlerTarget; + gTakenDmgByBattler[battler] = gBattlerTarget; } - if (gBattleMons[gActiveBattler].hp > gBattleMoveDamage) + if (gBattleMons[battler].hp > gBattleMoveDamage) { - gBattleMons[gActiveBattler].hp -= gBattleMoveDamage; + gBattleMons[battler].hp -= gBattleMoveDamage; gHpDealt = gBattleMoveDamage; } else { - gHpDealt = gBattleMons[gActiveBattler].hp; - gBattleMons[gActiveBattler].hp = 0; + gHpDealt = gBattleMons[battler].hp; + gBattleMons[battler].hp = 0; } - if (!gSpecialStatuses[gActiveBattler].dmg && !(gHitMarker & HITMARKER_PASSIVE_DAMAGE)) - gSpecialStatuses[gActiveBattler].dmg = gHpDealt; + if (!gSpecialStatuses[battler].dmg && !(gHitMarker & HITMARKER_PASSIVE_DAMAGE)) + gSpecialStatuses[battler].dmg = gHpDealt; if (IS_MOVE_PHYSICAL(gCurrentMove) && !(gHitMarker & HITMARKER_PASSIVE_DAMAGE) && gCurrentMove != MOVE_PAIN_SPLIT) { - gProtectStructs[gActiveBattler].physicalDmg = gHpDealt; - gSpecialStatuses[gActiveBattler].physicalDmg = gHpDealt; + gProtectStructs[battler].physicalDmg = gHpDealt; + gSpecialStatuses[battler].physicalDmg = gHpDealt; if (cmd->battler == BS_TARGET) { - gProtectStructs[gActiveBattler].physicalBattlerId = gBattlerAttacker; - gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerAttacker; + gProtectStructs[battler].physicalBattlerId = gBattlerAttacker; + gSpecialStatuses[battler].physicalBattlerId = gBattlerAttacker; } else { - gProtectStructs[gActiveBattler].physicalBattlerId = gBattlerTarget; - gSpecialStatuses[gActiveBattler].physicalBattlerId = gBattlerTarget; + gProtectStructs[battler].physicalBattlerId = gBattlerTarget; + gSpecialStatuses[battler].physicalBattlerId = gBattlerTarget; } } else if (!IS_MOVE_PHYSICAL(gCurrentMove) && !(gHitMarker & HITMARKER_PASSIVE_DAMAGE)) { - gProtectStructs[gActiveBattler].specialDmg = gHpDealt; - gSpecialStatuses[gActiveBattler].specialDmg = gHpDealt; + gProtectStructs[battler].specialDmg = gHpDealt; + gSpecialStatuses[battler].specialDmg = gHpDealt; if (cmd->battler == BS_TARGET) { - gProtectStructs[gActiveBattler].specialBattlerId = gBattlerAttacker; - gSpecialStatuses[gActiveBattler].specialBattlerId = gBattlerAttacker; + gProtectStructs[battler].specialBattlerId = gBattlerAttacker; + gSpecialStatuses[battler].specialBattlerId = gBattlerAttacker; } else { - gProtectStructs[gActiveBattler].specialBattlerId = gBattlerTarget; - gSpecialStatuses[gActiveBattler].specialBattlerId = gBattlerTarget; + gProtectStructs[battler].specialBattlerId = gBattlerTarget; + gSpecialStatuses[battler].specialBattlerId = gBattlerTarget; } } } gHitMarker &= ~HITMARKER_PASSIVE_DAMAGE; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].hp), &gBattleMons[gActiveBattler].hp); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[battler].hp), &gBattleMons[battler].hp); + MarkBattlerForControllerExec(battler); } } else { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - if (gSpecialStatuses[gActiveBattler].dmg == 0) - gSpecialStatuses[gActiveBattler].dmg = 0xFFFF; + battler = GetBattlerForBattleScript(cmd->battler); + if (gSpecialStatuses[battler].dmg == 0) + gSpecialStatuses[battler].dmg = 0xFFFF; } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -2440,18 +2437,17 @@ static void Cmd_effectivenesssound(void) if (gBattleControllerExecFlags) return; - gActiveBattler = gBattlerTarget; if (!(gMoveResultFlags & MOVE_RESULT_MISSED)) { switch (gMoveResultFlags & ~MOVE_RESULT_MISSED) { case MOVE_RESULT_SUPER_EFFECTIVE: - BtlController_EmitPlaySE(BUFFER_A, SE_SUPER_EFFECTIVE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_SUPER_EFFECTIVE); + MarkBattlerForControllerExec(gBattlerTarget); break; case MOVE_RESULT_NOT_VERY_EFFECTIVE: - BtlController_EmitPlaySE(BUFFER_A, SE_NOT_EFFECTIVE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_NOT_EFFECTIVE); + MarkBattlerForControllerExec(gBattlerTarget); break; case MOVE_RESULT_DOESNT_AFFECT_FOE: case MOVE_RESULT_FAILED: @@ -2464,18 +2460,18 @@ static void Cmd_effectivenesssound(void) default: if (gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE) { - BtlController_EmitPlaySE(BUFFER_A, SE_SUPER_EFFECTIVE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_SUPER_EFFECTIVE); + MarkBattlerForControllerExec(gBattlerTarget); } else if (gMoveResultFlags & MOVE_RESULT_NOT_VERY_EFFECTIVE) { - BtlController_EmitPlaySE(BUFFER_A, SE_NOT_EFFECTIVE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_NOT_EFFECTIVE); + MarkBattlerForControllerExec(gBattlerTarget); } else if (!(gMoveResultFlags & (MOVE_RESULT_DOESNT_AFFECT_FOE | MOVE_RESULT_FAILED))) { - BtlController_EmitPlaySE(BUFFER_A, SE_EFFECTIVE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerTarget, BUFFER_A, SE_EFFECTIVE); + MarkBattlerForControllerExec(gBattlerTarget); } break; } @@ -2629,10 +2625,8 @@ static void Cmd_printselectionstring(void) { CMD_ARGS(u16 id); - gActiveBattler = gBattlerAttacker; - - BtlController_EmitPrintSelectionString(BUFFER_A, cmd->id); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPrintSelectionString(gBattlerAttacker, BUFFER_A, cmd->id); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; gBattleCommunication[MSG_DISPLAY] = 1; @@ -2685,9 +2679,8 @@ static void Cmd_printselectionstringfromtable(void) const u16 *ptr = cmd->ptr; ptr += gBattleCommunication[MULTISTRING_CHOOSER]; - gActiveBattler = gBattlerAttacker; - BtlController_EmitPrintSelectionString(BUFFER_A, *ptr); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPrintSelectionString(gBattlerAttacker, BUFFER_A, *ptr); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; gBattleCommunication[MSG_DISPLAY] = 1; @@ -2727,12 +2720,10 @@ void StealTargetItem(u8 battlerStealer, u8 battlerItem) CheckSetUnburden(battlerItem); gBattleResources->flags->flags[battlerStealer] &= ~RESOURCE_FLAG_UNBURDEN; - gActiveBattler = battlerStealer; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gLastUsedItem), &gLastUsedItem); // set attacker item + BtlController_EmitSetMonData(battlerStealer, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gLastUsedItem), &gLastUsedItem); // set attacker item MarkBattlerForControllerExec(battlerStealer); - gActiveBattler = battlerItem; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[battlerItem].item); // remove target item + BtlController_EmitSetMonData(battlerItem, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[battlerItem].item); // remove target item MarkBattlerForControllerExec(battlerItem); gBattleStruct->choicedMove[battlerItem] = 0; @@ -3048,9 +3039,8 @@ void SetMoveEffect(bool32 primary, u32 certain) gBattlescriptCurrInstr = sMoveEffectBS_Ptrs[gBattleScripting.moveEffect]; - gActiveBattler = gEffectBattler; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].status1), &gBattleMons[gEffectBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].status1), &gBattleMons[gEffectBattler].status1); + MarkBattlerForControllerExec(gEffectBattler); if (gHitMarker & HITMARKER_IGNORE_SAFEGUARD) { @@ -3578,9 +3568,8 @@ void SetMoveEffect(bool32 primary, u32 certain) gBattleMons[gEffectBattler].item = 0; CheckSetUnburden(gEffectBattler); - gActiveBattler = gEffectBattler; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item); + MarkBattlerForControllerExec(gEffectBattler); BattleScriptPush(gBattlescriptCurrInstr + 1); gBattlescriptCurrInstr = BattleScript_MoveEffectIncinerate; } @@ -3593,10 +3582,9 @@ void SetMoveEffect(bool32 primary, u32 certain) gLastUsedItem = gBattleMons[gEffectBattler].item; gBattleMons[gEffectBattler].item = 0; CheckSetUnburden(gEffectBattler); - gActiveBattler = gEffectBattler; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gEffectBattler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gEffectBattler].item), &gBattleMons[gEffectBattler].item); + MarkBattlerForControllerExec(gEffectBattler); BattleScriptPush(gBattlescriptCurrInstr + 1); gBattlescriptCurrInstr = BattleScript_MoveEffectBugBite; } @@ -3841,9 +3829,8 @@ static void Cmd_tryfaintmon(void) gBattleMons[gBattlerAttacker].pp[moveIndex] = 0; BattleScriptPush(gBattlescriptCurrInstr); gBattlescriptCurrInstr = BattleScript_GrudgeTakesPp; - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].pp[moveIndex]), &gBattleMons[gActiveBattler].pp[moveIndex]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, moveIndex + REQUEST_PPMOVE1_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].pp[moveIndex]), &gBattleMons[gBattlerAttacker].pp[moveIndex]); + MarkBattlerForControllerExec(gBattlerAttacker); PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerAttacker].moves[moveIndex]) } @@ -3861,9 +3848,9 @@ static void Cmd_dofaintanimation(void) if (gBattleControllerExecFlags == 0) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitFaintAnimation(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitFaintAnimation(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } } @@ -3874,13 +3861,13 @@ static void Cmd_cleareffectsonfaint(void) if (gBattleControllerExecFlags == 0) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + u32 battler = GetBattlerForBattleScript(cmd->battler); - if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || gBattleMons[gActiveBattler].hp == 0) + if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || gBattleMons[battler].hp == 0) { - gBattleMons[gActiveBattler].status1 = 0; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMons[battler].status1 = 0; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } FaintClearSetData(); // Effects like attractions, trapping, etc. @@ -4281,9 +4268,8 @@ static void Cmd_getexp(void) gBattleResources->beforeLvlUp->stats[STAT_SPATK] = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPATK); gBattleResources->beforeLvlUp->stats[STAT_SPDEF] = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_SPDEF); - gActiveBattler = gBattleStruct->expGetterBattlerId; - BtlController_EmitExpUpdate(BUFFER_A, gBattleStruct->expGetterMonId, gBattleMoveDamage); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitExpUpdate(gBattleStruct->expGetterBattlerId, BUFFER_A, gBattleStruct->expGetterMonId, gBattleMoveDamage); + MarkBattlerForControllerExec(gBattleStruct->expGetterBattlerId); } gBattleScripting.getexpState++; } @@ -4857,14 +4843,15 @@ static void Cmd_waitstate(void) static void Cmd_healthbar_update(void) { CMD_ARGS(u8 battler); + u32 battler; if (cmd->battler == BS_TARGET) - gActiveBattler = gBattlerTarget; + battler = gBattlerTarget; else - gActiveBattler = gBattlerAttacker; + battler = gBattlerAttacker; - BtlController_EmitHealthBarUpdate(BUFFER_A, gBattleMoveDamage); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitHealthBarUpdate(battler, BUFFER_A, gBattleMoveDamage); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -4973,21 +4960,13 @@ static void Cmd_endselectionscript(void) *(gBattlerAttacker + gBattleStruct->selectionScriptFinished) = TRUE; } -static void Cmd_playanimation(void) +static void PlayAnimation(u32 battler, u8 animId, const u16 *argPtr, const u8 *nextInstr) { - CMD_ARGS(u8 battler, u8 animId, const u16 *argPtr); - - const u16 *argPtr; - u8 animId = cmd->animId; - - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - argPtr = cmd->argPtr; - #if B_TERRAIN_BG_CHANGE == FALSE if (animId == B_ANIM_RESTORE_BG) { // workaround for .if not working - gBattlescriptCurrInstr = cmd->nextInstr; + gBattlescriptCurrInstr = nextInstr; return; } #endif @@ -5000,13 +4979,13 @@ static void Cmd_playanimation(void) || animId == B_ANIM_SUBSTITUTE_FADE || animId == B_ANIM_PRIMAL_REVERSION) { - BtlController_EmitBattleAnimation(BUFFER_A, animId, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; + BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, *argPtr); + MarkBattlerForControllerExec(battler); + gBattlescriptCurrInstr = nextInstr; } else if (gHitMarker & HITMARKER_NO_ANIMATIONS && animId != B_ANIM_RESTORE_BG) { - BattleScriptPush(cmd->nextInstr); + BattleScriptPush(nextInstr); gBattlescriptCurrInstr = BattleScript_Pausex20; } else if (animId == B_ANIM_RAIN_CONTINUES @@ -5015,70 +4994,37 @@ static void Cmd_playanimation(void) || animId == B_ANIM_HAIL_CONTINUES || animId == B_ANIM_SNOW_CONTINUES) { - BtlController_EmitBattleAnimation(BUFFER_A, animId, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; + BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, *argPtr); + MarkBattlerForControllerExec(battler); + gBattlescriptCurrInstr = nextInstr; } - else if (gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) + else if (gStatuses3[battler] & STATUS3_SEMI_INVULNERABLE) { - gBattlescriptCurrInstr = cmd->nextInstr; + gBattlescriptCurrInstr = nextInstr; } else { - BtlController_EmitBattleAnimation(BUFFER_A, animId, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; + BtlController_EmitBattleAnimation(battler, BUFFER_A, animId, *argPtr); + MarkBattlerForControllerExec(battler); + gBattlescriptCurrInstr = nextInstr; } } +static void Cmd_playanimation(void) +{ + CMD_ARGS(u8 battler, u8 animId, const u16 *argPtr); + + u32 battler = GetBattlerForBattleScript(cmd->battler); + PlayAnimation(battler, cmd->animId, cmd->argPtr, cmd->nextInstr); +} + // Same as playanimation, except it takes a pointer to some animation id, instead of taking the value directly static void Cmd_playanimation_var(void) { CMD_ARGS(u8 battler, const u8 *animIdPtr, const u16 *argPtr); - const u16 *argPtr; - const u8 *animIdPtr; - - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - animIdPtr = cmd->animIdPtr; - argPtr = cmd->argPtr; - - if (*animIdPtr == B_ANIM_STATS_CHANGE - || *animIdPtr == B_ANIM_SNATCH_MOVE - || *animIdPtr == B_ANIM_MEGA_EVOLUTION - || *animIdPtr == B_ANIM_ILLUSION_OFF - || *animIdPtr == B_ANIM_FORM_CHANGE - || *animIdPtr == B_ANIM_SUBSTITUTE_FADE - || *animIdPtr == B_ANIM_PRIMAL_REVERSION) - { - BtlController_EmitBattleAnimation(BUFFER_A, *animIdPtr, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; - } - else if (gHitMarker & HITMARKER_NO_ANIMATIONS) - { - gBattlescriptCurrInstr = cmd->nextInstr; - } - else if (*animIdPtr == B_ANIM_RAIN_CONTINUES - || *animIdPtr == B_ANIM_SUN_CONTINUES - || *animIdPtr == B_ANIM_SANDSTORM_CONTINUES - || *animIdPtr == B_ANIM_HAIL_CONTINUES - || *animIdPtr == B_ANIM_SNOW_CONTINUES) - { - BtlController_EmitBattleAnimation(BUFFER_A, *animIdPtr, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; - } - else if (gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) - { - gBattlescriptCurrInstr = cmd->nextInstr; - } - else - { - BtlController_EmitBattleAnimation(BUFFER_A, *animIdPtr, *argPtr); - MarkBattlerForControllerExec(gActiveBattler); - gBattlescriptCurrInstr = cmd->nextInstr; - } + u32 battler = GetBattlerForBattleScript(cmd->battler); + PlayAnimation(battler, *(cmd->animIdPtr), cmd->argPtr, cmd->nextInstr); } static void Cmd_setgraphicalstatchangevalues(void) @@ -5123,17 +5069,14 @@ static void Cmd_playstatchangeanimation(void) { CMD_ARGS(u8 battler, u8 stats, u8 flags); - u32 ability; u32 currStat = 0; u32 statAnimId = 0; u32 changeableStatsCount = 0; - u32 stats = 0; u32 startingStatAnimId = 0; u32 flags = cmd->flags; - - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - ability = GetBattlerAbility(gActiveBattler); - stats = cmd->stats; + u32 battler = GetBattlerForBattleScript(cmd->battler); + u32 ability = GetBattlerAbility(battler); + u32 stats = cmd->stats; // Handle Contrary and Simple if (ability == ABILITY_CONTRARY) @@ -5154,14 +5097,14 @@ static void Cmd_playstatchangeanimation(void) { if (flags & STAT_CHANGE_CANT_PREVENT) { - if (gBattleMons[gActiveBattler].statStages[currStat] > MIN_STAT_STAGE) + if (gBattleMons[battler].statStages[currStat] > MIN_STAT_STAGE) { statAnimId = startingStatAnimId + currStat; changeableStatsCount++; } } - else if (!gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].mistTimer - && GetBattlerHoldEffect(gActiveBattler, TRUE) != HOLD_EFFECT_CLEAR_AMULET + else if (!gSideTimers[GET_BATTLER_SIDE(battler)].mistTimer + && GetBattlerHoldEffect(battler, TRUE) != HOLD_EFFECT_CLEAR_AMULET && ability != ABILITY_CLEAR_BODY && ability != ABILITY_FULL_METAL_BODY && ability != ABILITY_WHITE_SMOKE @@ -5169,7 +5112,7 @@ static void Cmd_playstatchangeanimation(void) && !(ability == ABILITY_HYPER_CUTTER && currStat == STAT_ATK) && !(ability == ABILITY_BIG_PECKS && currStat == STAT_DEF)) { - if (gBattleMons[gActiveBattler].statStages[currStat] > MIN_STAT_STAGE) + if (gBattleMons[battler].statStages[currStat] > MIN_STAT_STAGE) { statAnimId = startingStatAnimId + currStat; changeableStatsCount++; @@ -5196,7 +5139,7 @@ static void Cmd_playstatchangeanimation(void) while (stats != 0) { - if (stats & 1 && gBattleMons[gActiveBattler].statStages[currStat] < MAX_STAT_STAGE) + if (stats & 1 && gBattleMons[battler].statStages[currStat] < MAX_STAT_STAGE) { statAnimId = startingStatAnimId + currStat; changeableStatsCount++; @@ -5219,8 +5162,8 @@ static void Cmd_playstatchangeanimation(void) } else if (changeableStatsCount != 0 && !gBattleScripting.statAnimPlayed) { - BtlController_EmitBattleAnimation(BUFFER_A, B_ANIM_STATS_CHANGE, statAnimId); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitBattleAnimation(battler, BUFFER_A, B_ANIM_STATS_CHANGE, statAnimId); + MarkBattlerForControllerExec(battler); if (flags & STAT_CHANGE_MULTIPLE_STATS && changeableStatsCount > 1) gBattleScripting.statAnimPlayed = TRUE; gBattlescriptCurrInstr = cmd->nextInstr; @@ -5384,9 +5327,8 @@ static void Cmd_moveend(void) { gProtectStructs[gBattlerAttacker].touchedProtectLike = FALSE; gBattleMons[gBattlerAttacker].status1 = STATUS1_BURN; - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1); + MarkBattlerForControllerExec(gBattlerAttacker); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BeakBlastBurn; effect = 1; @@ -5423,9 +5365,8 @@ static void Cmd_moveend(void) && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT)) { gBattleMons[gBattlerTarget].status1 &= ~STATUS1_FREEZE; - gActiveBattler = gBattlerTarget; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1); + MarkBattlerForControllerExec(gBattlerTarget); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_DefrostedViaFireMove; effect = TRUE; @@ -5437,9 +5378,8 @@ static void Cmd_moveend(void) && !(gMoveResultFlags & MOVE_RESULT_NO_EFFECT)) { gBattleMons[gBattlerTarget].status1 &= ~STATUS1_FROSTBITE; - gActiveBattler = gBattlerTarget; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1); + MarkBattlerForControllerExec(gBattlerTarget); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_FrostbiteHealedViaFireMove; effect = TRUE; @@ -5579,9 +5519,8 @@ static void Cmd_moveend(void) { gBattleMons[gBattlerTarget].status1 &= ~(gBattleMoves[gCurrentMove].argument); - gActiveBattler = gBattlerTarget; - BtlController_EmitSetMonData(0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerTarget, 0, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerTarget].status1); + MarkBattlerForControllerExec(gBattlerTarget); effect = TRUE; BattleScriptPush(gBattlescriptCurrInstr); switch (gBattleMoves[gCurrentMove].argument) @@ -5619,9 +5558,8 @@ static void Cmd_moveend(void) if (gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE) && gHitMarker & HITMARKER_NO_ANIMATIONS) { - gActiveBattler = gBattlerAttacker; - BtlController_EmitSpriteInvisibility(BUFFER_A, TRUE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSpriteInvisibility(gBattlerAttacker, BUFFER_A, TRUE); + MarkBattlerForControllerExec(gBattlerAttacker); gBattleScripting.moveendState++; return; } @@ -5632,9 +5570,8 @@ static void Cmd_moveend(void) || !(gStatuses3[gBattlerAttacker] & (STATUS3_SEMI_INVULNERABLE)) || WasUnableToUseMove(gBattlerAttacker)) { - gActiveBattler = gBattlerAttacker; - BtlController_EmitSpriteInvisibility(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSpriteInvisibility(gBattlerAttacker, BUFFER_A, FALSE); + MarkBattlerForControllerExec(gBattlerAttacker); gStatuses3[gBattlerAttacker] &= ~STATUS3_SEMI_INVULNERABLE; gSpecialStatuses[gBattlerAttacker].restoredBattlerSprite = TRUE; gBattleScripting.moveendState++; @@ -5646,9 +5583,8 @@ static void Cmd_moveend(void) if (!gSpecialStatuses[gBattlerTarget].restoredBattlerSprite && gBattlerTarget < gBattlersCount && !(gStatuses3[gBattlerTarget] & STATUS3_SEMI_INVULNERABLE)) { - gActiveBattler = gBattlerTarget; - BtlController_EmitSpriteInvisibility(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSpriteInvisibility(gBattlerTarget, BUFFER_A, FALSE); + MarkBattlerForControllerExec(gBattlerTarget); gStatuses3[gBattlerTarget] &= ~STATUS3_SEMI_INVULNERABLE; gBattleScripting.moveendState++; return; @@ -6204,11 +6140,10 @@ static void Cmd_returnatktoball(void) { CMD_ARGS(); - gActiveBattler = gBattlerAttacker; - if (!(gHitMarker & HITMARKER_FAINTED(gActiveBattler))) + if (!(gHitMarker & HITMARKER_FAINTED(gBattlerAttacker))) { - BtlController_EmitReturnMonToBall(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitReturnMonToBall(gBattlerAttacker, BUFFER_A, FALSE); + MarkBattlerForControllerExec(gBattlerAttacker); } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -6217,15 +6152,14 @@ static void Cmd_getswitchedmondata(void) { CMD_ARGS(u8 battler); + u32 battler = GetBattlerForBattleScript(cmd->battler); if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + gBattlerPartyIndexes[battler] = gBattleStruct->monToSwitchIntoId[battler]; - gBattlerPartyIndexes[gActiveBattler] = *(gBattleStruct->monToSwitchIntoId + gActiveBattler); - - BtlController_EmitGetMonData(BUFFER_A, REQUEST_ALL_BATTLE, gBitTable[gBattlerPartyIndexes[gActiveBattler]]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, gBitTable[gBattlerPartyIndexes[battler]]); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -6235,78 +6169,80 @@ static void Cmd_switchindataupdate(void) CMD_ARGS(u8 battler); struct BattlePokemon oldData; - s32 i; + u32 battler, i; u8 *monData; if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - oldData = gBattleMons[gActiveBattler]; - monData = (u8 *)(&gBattleMons[gActiveBattler]); + battler = GetBattlerForBattleScript(cmd->battler); + oldData = gBattleMons[battler]; + monData = (u8 *)(&gBattleMons[battler]); for (i = 0; i < sizeof(struct BattlePokemon); i++) - monData[i] = gBattleResources->bufferB[gActiveBattler][4 + i]; + monData[i] = gBattleResources->bufferB[battler][4 + i]; - gBattleMons[gActiveBattler].type1 = gSpeciesInfo[gBattleMons[gActiveBattler].species].types[0]; - gBattleMons[gActiveBattler].type2 = gSpeciesInfo[gBattleMons[gActiveBattler].species].types[1]; - gBattleMons[gActiveBattler].type3 = TYPE_MYSTERY; - gBattleMons[gActiveBattler].ability = GetAbilityBySpecies(gBattleMons[gActiveBattler].species, gBattleMons[gActiveBattler].abilityNum); + gBattleMons[battler].type1 = gSpeciesInfo[gBattleMons[battler].species].types[0]; + gBattleMons[battler].type2 = gSpeciesInfo[gBattleMons[battler].species].types[1]; + gBattleMons[battler].type3 = TYPE_MYSTERY; + gBattleMons[battler].ability = GetAbilityBySpecies(gBattleMons[battler].species, gBattleMons[battler].abilityNum); // check knocked off item - i = GetBattlerSide(gActiveBattler); - if (gWishFutureKnock.knockedOffMons[i] & gBitTable[gBattlerPartyIndexes[gActiveBattler]]) + i = GetBattlerSide(battler); + if (gWishFutureKnock.knockedOffMons[i] & gBitTable[gBattlerPartyIndexes[battler]]) { - gBattleMons[gActiveBattler].item = ITEM_NONE; + gBattleMons[battler].item = ITEM_NONE; } if (gBattleMoves[gCurrentMove].effect == EFFECT_BATON_PASS) { for (i = 0; i < NUM_BATTLE_STATS; i++) { - gBattleMons[gActiveBattler].statStages[i] = oldData.statStages[i]; + gBattleMons[battler].statStages[i] = oldData.statStages[i]; } - gBattleMons[gActiveBattler].status2 = oldData.status2; + gBattleMons[battler].status2 = oldData.status2; } SwitchInClearSetData(); if (gBattleTypeFlags & BATTLE_TYPE_PALACE - && gBattleMons[gActiveBattler].maxHP / 2 >= gBattleMons[gActiveBattler].hp - && gBattleMons[gActiveBattler].hp != 0 - && !(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP)) + && gBattleMons[battler].maxHP / 2 >= gBattleMons[battler].hp + && gBattleMons[battler].hp != 0 + && !(gBattleMons[battler].status1 & STATUS1_SLEEP)) { - gBattleStruct->palaceFlags |= gBitTable[gActiveBattler]; + gBattleStruct->palaceFlags |= gBitTable[battler]; } - gBattleScripting.battler = gActiveBattler; + gBattleScripting.battler = battler; - PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gActiveBattler, gBattlerPartyIndexes[gActiveBattler]); + PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, battler, gBattlerPartyIndexes[battler]); gBattlescriptCurrInstr = cmd->nextInstr; } static void Cmd_switchinanim(void) { + u32 battler; + CMD_ARGS(u8 battler, bool8 dontClearSubstitute); if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + battler = GetBattlerForBattleScript(cmd->battler); - if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT + if (GetBattlerSide(battler) == B_SIDE_OPPONENT && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER_HILL | BATTLE_TYPE_FRONTIER))) - HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBattler].species), FLAG_SET_SEEN, gBattleMons[gActiveBattler].personality); + HandleSetPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[battler].species), FLAG_SET_SEEN, gBattleMons[battler].personality); - gAbsentBattlerFlags &= ~(gBitTable[gActiveBattler]); + gAbsentBattlerFlags &= ~(gBitTable[battler]); - BtlController_EmitSwitchInAnim(BUFFER_A, gBattlerPartyIndexes[gActiveBattler], cmd->dontClearSubstitute); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSwitchInAnim(battler, BUFFER_A, gBattlerPartyIndexes[battler], cmd->dontClearSubstitute); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; @@ -6479,54 +6415,50 @@ static void Cmd_jumpifcantswitch(void) // Opens the party screen to choose a new Pokémon to send out. // slotId is the Pokémon to replace. // Note that this is not used by the Switch action, only replacing fainted Pokémon or Baton Pass -static void ChooseMonToSendOut(u8 slotId) +static void ChooseMonToSendOut(u32 battler, u8 slotId) { - *(gBattleStruct->battlerPartyIndexes + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler]; - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - gBattleStruct->field_93 &= ~(gBitTable[gActiveBattler]); + gBattleStruct->battlerPartyIndexes[battler] = gBattlerPartyIndexes[battler]; + gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; + gBattleStruct->field_93 &= ~(gBitTable[battler]); - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_SEND_OUT, slotId, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitChoosePokemon(battler, BUFFER_A, PARTY_ACTION_SEND_OUT, slotId, ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]); + MarkBattlerForControllerExec(battler); } static void Cmd_openpartyscreen(void) { CMD_ARGS(u8 battler:7, u8 partyScreenOptional:1, const u8 *failInstr); - u32 flags; - u8 hitmarkerFaintBits; - u8 battlerId; - const u8 *failInstr; - - battlerId = 0; - flags = 0; - failInstr = cmd->failInstr; + u32 flags = 0; + u8 hitmarkerFaintBits = 0; + u32 i, battler = 0; + const u8 *failInstr = cmd->failInstr; if (cmd->battler == BS_FAINTED_LINK_MULTIPLE_1) { if ((gBattleTypeFlags & BATTLE_TYPE_MULTI) || !(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) { - for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) + for (battler = 0; battler < gBattlersCount; battler++) { - if (gHitMarker & HITMARKER_FAINTED(gActiveBattler)) + if (gHitMarker & HITMARKER_FAINTED(battler)) { - if (HasNoMonsToSwitch(gActiveBattler, PARTY_SIZE, PARTY_SIZE)) + if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(PARTY_SIZE); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, PARTY_SIZE); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } } else { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } } } @@ -6538,88 +6470,88 @@ static void Cmd_openpartyscreen(void) if (gBitTable[0] & hitmarkerFaintBits) { - gActiveBattler = 0; - if (HasNoMonsToSwitch(gActiveBattler, PARTY_SIZE, PARTY_SIZE)) + battler = 0; + if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[2]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[2]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } else { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); flags |= 1; } } if (gBitTable[2] & hitmarkerFaintBits && !(gBitTable[0] & hitmarkerFaintBits)) { - gActiveBattler = 2; - if (HasNoMonsToSwitch(gActiveBattler, PARTY_SIZE, PARTY_SIZE)) + battler = 2; + if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[0]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[0]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } else if (!(flags & 1)) { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } } if (gBitTable[1] & hitmarkerFaintBits) { - gActiveBattler = 1; - if (HasNoMonsToSwitch(gActiveBattler, PARTY_SIZE, PARTY_SIZE)) + battler = 1; + if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[3]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[3]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } else { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); flags |= 2; } } if (gBitTable[3] & hitmarkerFaintBits && !(gBitTable[1] & hitmarkerFaintBits)) { - gActiveBattler = 3; - if (HasNoMonsToSwitch(gActiveBattler, PARTY_SIZE, PARTY_SIZE)) + battler = 3; + if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[1]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[1]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } else if (!(flags & 2)) { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } } @@ -6630,12 +6562,12 @@ static void Cmd_openpartyscreen(void) if (!hasReplacement_2 && hitmarkerFaintBits != 0) { if (gAbsentBattlerFlags & gBitTable[0]) - gActiveBattler = 2; + battler = 2; else - gActiveBattler = 0; + battler = 0; - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } } @@ -6646,12 +6578,12 @@ static void Cmd_openpartyscreen(void) if (!hasReplacement_3 && hitmarkerFaintBits != 0) { if (gAbsentBattlerFlags & gBitTable[1]) - gActiveBattler = 3; + battler = 3; else - gActiveBattler = 1; + battler = 1; - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battler, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battler); } } } @@ -6666,34 +6598,34 @@ static void Cmd_openpartyscreen(void) hitmarkerFaintBits = gHitMarker >> 28; if (gBitTable[2] & hitmarkerFaintBits && gBitTable[0] & hitmarkerFaintBits) { - gActiveBattler = 2; - if (HasNoMonsToSwitch(gActiveBattler, gBattleResources->bufferB[0][1], PARTY_SIZE)) + battler = 2; + if (HasNoMonsToSwitch(battler, gBattleResources->bufferB[0][1], PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[0]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[0]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } } if (gBitTable[3] & hitmarkerFaintBits && hitmarkerFaintBits & gBitTable[1]) { - gActiveBattler = 3; - if (HasNoMonsToSwitch(gActiveBattler, gBattleResources->bufferB[1][1], PARTY_SIZE)) + battler = 3; + if (HasNoMonsToSwitch(battler, gBattleResources->bufferB[1][1], PARTY_SIZE)) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - BtlController_EmitCantSwitch(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); + BtlController_EmitCantSwitch(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); } - else if (!gSpecialStatuses[gActiveBattler].faintedHasReplacement) + else if (!gSpecialStatuses[battler].faintedHasReplacement) { - ChooseMonToSendOut(gBattleStruct->monToSwitchIntoId[1]); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = TRUE; + ChooseMonToSendOut(battler, gBattleStruct->monToSwitchIntoId[1]); + gSpecialStatuses[battler].faintedHasReplacement = TRUE; } } gBattlescriptCurrInstr = cmd->nextInstr; @@ -6727,52 +6659,50 @@ static void Cmd_openpartyscreen(void) else hitmarkerFaintBits = PARTY_ACTION_SEND_OUT; - battlerId = GetBattlerForBattleScript(cmd->battler); - if (gSpecialStatuses[battlerId].faintedHasReplacement) + battler = GetBattlerForBattleScript(cmd->battler); + if (gSpecialStatuses[battler].faintedHasReplacement) { gBattlescriptCurrInstr = cmd->nextInstr; } - else if (HasNoMonsToSwitch(battlerId, PARTY_SIZE, PARTY_SIZE)) + else if (HasNoMonsToSwitch(battler, PARTY_SIZE, PARTY_SIZE)) { - gActiveBattler = battlerId; - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker &= ~HITMARKER_FAINTED(battler); gBattlescriptCurrInstr = failInstr; } else { - gActiveBattler = battlerId; - *(gBattleStruct->battlerPartyIndexes + gActiveBattler) = gBattlerPartyIndexes[gActiveBattler]; - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; - gBattleStruct->field_93 &= ~(gBitTable[gActiveBattler]); + *(gBattleStruct->battlerPartyIndexes + battler) = gBattlerPartyIndexes[battler]; + *(gBattleStruct->monToSwitchIntoId + battler) = PARTY_SIZE; + gBattleStruct->field_93 &= ~(gBitTable[battler]); - BtlController_EmitChoosePokemon(BUFFER_A, hitmarkerFaintBits, *(gBattleStruct->monToSwitchIntoId + BATTLE_PARTNER(gActiveBattler)), ABILITY_NONE, gBattleStruct->battlerPartyOrders[gActiveBattler]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitChoosePokemon(battler, BUFFER_A, hitmarkerFaintBits, *(gBattleStruct->monToSwitchIntoId + BATTLE_PARTNER(battler)), ABILITY_NONE, gBattleStruct->battlerPartyOrders[battler]); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; - if (GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_LEFT && gBattleResults.playerSwitchesCounter < 255) + if (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT && gBattleResults.playerSwitchesCounter < 255) gBattleResults.playerSwitchesCounter++; if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) + for (i = 0; i < gBattlersCount; i++) { - if (gActiveBattler != battlerId) + if (i != battler) { - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(i, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(i); } } } else { - gActiveBattler = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battlerId))); - if (gAbsentBattlerFlags & gBitTable[gActiveBattler]) - gActiveBattler ^= BIT_FLANK; + u32 battlerOpposite = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler))); + if (gAbsentBattlerFlags & gBitTable[battlerOpposite]) + battlerOpposite ^= BIT_FLANK; - BtlController_EmitLinkStandbyMsg(BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitLinkStandbyMsg(battlerOpposite, BUFFER_A, LINK_STANDBY_MSG_ONLY, FALSE); + MarkBattlerForControllerExec(battlerOpposite); } } } @@ -6782,11 +6712,11 @@ static void Cmd_switchhandleorder(void) { CMD_ARGS(u8 battler, u8 state); - s32 i; + u32 battler, i; if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + battler = GetBattlerForBattleScript(cmd->battler); switch (cmd->state) { @@ -6806,40 +6736,40 @@ static void Cmd_switchhandleorder(void) break; case 1: if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - SwitchPartyOrder(gActiveBattler); + SwitchPartyOrder(battler); break; case 2: - if (!(gBattleStruct->field_93 & gBitTable[gActiveBattler])) + if (!(gBattleStruct->field_93 & gBitTable[battler])) { - RecordedBattle_SetBattlerAction(gActiveBattler, gBattleResources->bufferB[gActiveBattler][1]); - gBattleStruct->field_93 |= gBitTable[gActiveBattler]; + RecordedBattle_SetBattlerAction(battler, gBattleResources->bufferB[battler][1]); + gBattleStruct->field_93 |= gBitTable[battler]; } // fall through case 3: - gBattleCommunication[0] = gBattleResources->bufferB[gActiveBattler][1]; - *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = gBattleResources->bufferB[gActiveBattler][1]; + gBattleCommunication[0] = gBattleResources->bufferB[battler][1]; + *(gBattleStruct->monToSwitchIntoId + battler) = gBattleResources->bufferB[battler][1]; if (gBattleTypeFlags & BATTLE_TYPE_LINK && gBattleTypeFlags & BATTLE_TYPE_MULTI) { - *(gActiveBattler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) &= 0xF; - *(gActiveBattler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) |= (gBattleResources->bufferB[gActiveBattler][2] & 0xF0); - *(gActiveBattler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 1) = gBattleResources->bufferB[gActiveBattler][3]; + *(battler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) &= 0xF; + *(battler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) |= (gBattleResources->bufferB[battler][2] & 0xF0); + *(battler * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 1) = gBattleResources->bufferB[battler][3]; - *((BATTLE_PARTNER(gActiveBattler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) &= (0xF0); - *((BATTLE_PARTNER(gActiveBattler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) |= (gBattleResources->bufferB[gActiveBattler][2] & 0xF0) >> 4; - *((BATTLE_PARTNER(gActiveBattler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 2) = gBattleResources->bufferB[gActiveBattler][3]; + *((BATTLE_PARTNER(battler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) &= (0xF0); + *((BATTLE_PARTNER(battler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 0) |= (gBattleResources->bufferB[battler][2] & 0xF0) >> 4; + *((BATTLE_PARTNER(battler)) * 3 + (u8 *)(gBattleStruct->battlerPartyOrders) + 2) = gBattleResources->bufferB[battler][3]; } else if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) { - SwitchPartyOrderInGameMulti(gActiveBattler, *(gBattleStruct->monToSwitchIntoId + gActiveBattler)); + SwitchPartyOrderInGameMulti(battler, *(gBattleStruct->monToSwitchIntoId + battler)); } else { - SwitchPartyOrder(gActiveBattler); + SwitchPartyOrder(battler); } PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerAttacker].species) - PREPARE_MON_NICK_BUFFER(gBattleTextBuff2, gActiveBattler, gBattleResources->bufferB[gActiveBattler][1]) + PREPARE_MON_NICK_BUFFER(gBattleTextBuff2, battler, gBattleResources->bufferB[battler][1]) break; } @@ -6897,119 +6827,119 @@ static void Cmd_switchineffects(void) CMD_ARGS(u8 battler); s32 i; + u32 battler = GetBattlerForBattleScript(cmd->battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - UpdateSentPokesToOpponentValue(gActiveBattler); + UpdateSentPokesToOpponentValue(battler); - gHitMarker &= ~HITMARKER_FAINTED(gActiveBattler); - gSpecialStatuses[gActiveBattler].faintedHasReplacement = FALSE; + gHitMarker &= ~HITMARKER_FAINTED(battler); + gSpecialStatuses[battler].faintedHasReplacement = FALSE; - if (!BattlerHasAi(gActiveBattler)) - gBattleStruct->appearedInBattle |= gBitTable[gBattlerPartyIndexes[gActiveBattler]]; + if (!BattlerHasAi(battler)) + gBattleStruct->appearedInBattle |= gBitTable[gBattlerPartyIndexes[battler]]; // Neutralizing Gas announces itself before hazards - if (gBattleMons[gActiveBattler].ability == ABILITY_NEUTRALIZING_GAS && gSpecialStatuses[gActiveBattler].announceNeutralizingGas == 0) + if (gBattleMons[battler].ability == ABILITY_NEUTRALIZING_GAS && gSpecialStatuses[battler].announceNeutralizingGas == 0) { gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_SWITCHIN_NEUTRALIZING_GAS; - gSpecialStatuses[gActiveBattler].announceNeutralizingGas = TRUE; - gBattlerAbility = gActiveBattler; + gSpecialStatuses[battler].announceNeutralizingGas = TRUE; + gBattlerAbility = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_SwitchInAbilityMsgRet; } // Healing Wish activates before hazards. // Starting from Gen8 - it heals only pokemon which can be healed. In gens 5,6,7 the effect activates anyways. - else if (((gBattleStruct->storedHealingWish & gBitTable[gActiveBattler]) || (gBattleStruct->storedLunarDance & gBitTable[gActiveBattler])) - && (gBattleMons[gActiveBattler].hp != gBattleMons[gActiveBattler].maxHP || gBattleMons[gActiveBattler].status1 != 0 || B_HEALING_WISH_SWITCH < GEN_8)) + else if (((gBattleStruct->storedHealingWish & gBitTable[battler]) || (gBattleStruct->storedLunarDance & gBitTable[battler])) + && (gBattleMons[battler].hp != gBattleMons[battler].maxHP || gBattleMons[battler].status1 != 0 || B_HEALING_WISH_SWITCH < GEN_8)) { - if (gBattleStruct->storedHealingWish & gBitTable[gActiveBattler]) + if (gBattleStruct->storedHealingWish & gBitTable[battler]) { BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_HealingWishActivates; - gBattleStruct->storedHealingWish &= ~(gBitTable[gActiveBattler]); + gBattleStruct->storedHealingWish &= ~(gBitTable[battler]); } else // Lunar Dance { BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_LunarDanceActivates; - gBattleStruct->storedLunarDance &= ~(gBitTable[gActiveBattler]); + gBattleStruct->storedLunarDance &= ~(gBitTable[battler]); } } - else if (!(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES_DAMAGED) - && (gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SPIKES) - && GetBattlerAbility(gActiveBattler) != ABILITY_MAGIC_GUARD - && IsBattlerAffectedByHazards(gActiveBattler, FALSE) - && IsBattlerGrounded(gActiveBattler)) + else if (!(gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SPIKES_DAMAGED) + && (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SPIKES) + && GetBattlerAbility(battler) != ABILITY_MAGIC_GUARD + && IsBattlerAffectedByHazards(battler, FALSE) + && IsBattlerGrounded(battler)) { - u8 spikesDmg = (5 - gSideTimers[GetBattlerSide(gActiveBattler)].spikesAmount) * 2; - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / (spikesDmg); + u8 spikesDmg = (5 - gSideTimers[GetBattlerSide(battler)].spikesAmount) * 2; + gBattleMoveDamage = gBattleMons[battler].maxHP / (spikesDmg); if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; - gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_SPIKES_DAMAGED; - SetDmgHazardsBattlescript(gActiveBattler, B_MSG_PKMNHURTBYSPIKES); + gSideStatuses[GetBattlerSide(battler)] |= SIDE_STATUS_SPIKES_DAMAGED; + SetDmgHazardsBattlescript(battler, B_MSG_PKMNHURTBYSPIKES); } - else if (!(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_STEALTH_ROCK_DAMAGED) - && (gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_STEALTH_ROCK) - && IsBattlerAffectedByHazards(gActiveBattler, FALSE) - && GetBattlerAbility(gActiveBattler) != ABILITY_MAGIC_GUARD) + else if (!(gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_STEALTH_ROCK_DAMAGED) + && (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_STEALTH_ROCK) + && IsBattlerAffectedByHazards(battler, FALSE) + && GetBattlerAbility(battler) != ABILITY_MAGIC_GUARD) { - gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_STEALTH_ROCK_DAMAGED; - gBattleMoveDamage = GetStealthHazardDamage(gBattleMoves[MOVE_STEALTH_ROCK].type, gActiveBattler); + gSideStatuses[GetBattlerSide(battler)] |= SIDE_STATUS_STEALTH_ROCK_DAMAGED; + gBattleMoveDamage = GetStealthHazardDamage(gBattleMoves[MOVE_STEALTH_ROCK].type, battler); if (gBattleMoveDamage != 0) - SetDmgHazardsBattlescript(gActiveBattler, B_MSG_STEALTHROCKDMG); + SetDmgHazardsBattlescript(battler, B_MSG_STEALTHROCKDMG); } - else if (!(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_TOXIC_SPIKES_DAMAGED) - && (gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_TOXIC_SPIKES) - && IsBattlerGrounded(gActiveBattler)) + else if (!(gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_TOXIC_SPIKES_DAMAGED) + && (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_TOXIC_SPIKES) + && IsBattlerGrounded(battler)) { - gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_TOXIC_SPIKES_DAMAGED; - if (IS_BATTLER_OF_TYPE(gActiveBattler, TYPE_POISON)) // Absorb the toxic spikes. + gSideStatuses[GetBattlerSide(battler)] |= SIDE_STATUS_TOXIC_SPIKES_DAMAGED; + if (IS_BATTLER_OF_TYPE(battler, TYPE_POISON)) // Absorb the toxic spikes. { - gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~SIDE_STATUS_TOXIC_SPIKES; - gSideTimers[GetBattlerSide(gActiveBattler)].toxicSpikesAmount = 0; - gBattleScripting.battler = gActiveBattler; + gSideStatuses[GetBattlerSide(battler)] &= ~SIDE_STATUS_TOXIC_SPIKES; + gSideTimers[GetBattlerSide(battler)].toxicSpikesAmount = 0; + gBattleScripting.battler = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_ToxicSpikesAbsorbed; } - else if (IsBattlerAffectedByHazards(gActiveBattler, TRUE)) + else if (IsBattlerAffectedByHazards(battler, TRUE)) { - if (!(gBattleMons[gActiveBattler].status1 & STATUS1_ANY) - && !IS_BATTLER_OF_TYPE(gActiveBattler, TYPE_STEEL) - && GetBattlerAbility(gActiveBattler) != ABILITY_IMMUNITY - && !IsAbilityOnSide(gActiveBattler, ABILITY_PASTEL_VEIL) - && !(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_SAFEGUARD) + if (!(gBattleMons[battler].status1 & STATUS1_ANY) + && !IS_BATTLER_OF_TYPE(battler, TYPE_STEEL) + && GetBattlerAbility(battler) != ABILITY_IMMUNITY + && !IsAbilityOnSide(battler, ABILITY_PASTEL_VEIL) + && !(gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD) && !(gFieldStatuses & STATUS_FIELD_MISTY_TERRAIN)) { - if (gSideTimers[GetBattlerSide(gActiveBattler)].toxicSpikesAmount >= 2) - gBattleMons[gActiveBattler].status1 |= STATUS1_TOXIC_POISON; + if (gSideTimers[GetBattlerSide(battler)].toxicSpikesAmount >= 2) + gBattleMons[battler].status1 |= STATUS1_TOXIC_POISON; else - gBattleMons[gActiveBattler].status1 |= STATUS1_POISON; + gBattleMons[battler].status1 |= STATUS1_POISON; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); - gBattleScripting.battler = gActiveBattler; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); + gBattleScripting.battler = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_ToxicSpikesPoisoned; } } } - else if (!(gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_STICKY_WEB_DAMAGED) - && (gSideStatuses[GetBattlerSide(gActiveBattler)] & SIDE_STATUS_STICKY_WEB) - && IsBattlerAffectedByHazards(gActiveBattler, FALSE) - && IsBattlerGrounded(gActiveBattler)) + else if (!(gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_STICKY_WEB_DAMAGED) + && (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_STICKY_WEB) + && IsBattlerAffectedByHazards(battler, FALSE) + && IsBattlerGrounded(battler)) { - gSideStatuses[GetBattlerSide(gActiveBattler)] |= SIDE_STATUS_STICKY_WEB_DAMAGED; - gBattleScripting.battler = gActiveBattler; + gSideStatuses[GetBattlerSide(battler)] |= SIDE_STATUS_STICKY_WEB_DAMAGED; + gBattleScripting.battler = battler; SET_STATCHANGER(STAT_SPEED, 1, TRUE); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_StickyWebOnSwitchIn; } - else if (gBattleMons[gActiveBattler].hp != gBattleMons[gActiveBattler].maxHP && gBattleStruct->zmove.healReplacement) + else if (gBattleMons[battler].hp != gBattleMons[battler].maxHP && gBattleStruct->zmove.healReplacement) { gBattleStruct->zmove.healReplacement = FALSE; - gBattleMoveDamage = -1 * (gBattleMons[gActiveBattler].maxHP); - gBattleScripting.battler = gActiveBattler; + gBattleMoveDamage = -1 * (gBattleMons[battler].maxHP); + gBattleScripting.battler = battler; BattleScriptPushCursor(); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_Z_HP_TRAP; gBattlescriptCurrInstr = BattleScript_HealReplacementZMove; @@ -7019,30 +6949,30 @@ static void Cmd_switchineffects(void) { // There is a hack here to ensure the truant counter will be 0 when the battler's next turn starts. // The truant counter is not updated in the case where a mon switches in after a lost judgment in the battle arena. - if (GetBattlerAbility(gActiveBattler) == ABILITY_TRUANT + if (GetBattlerAbility(battler) == ABILITY_TRUANT && gCurrentActionFuncId != B_ACTION_USE_MOVE - && !gDisableStructs[gActiveBattler].truantSwitchInHack) - gDisableStructs[gActiveBattler].truantCounter = 1; + && !gDisableStructs[battler].truantSwitchInHack) + gDisableStructs[battler].truantCounter = 1; - gDisableStructs[gActiveBattler].truantSwitchInHack = 0; + gDisableStructs[battler].truantSwitchInHack = 0; // Don't activate switch-in abilities if the opposing field is empty. // This could happen when a mon uses explosion and causes everyone to faint. - if (ShouldPostponeSwitchInAbilities(gActiveBattler) || gBattleStruct->switchInAbilityPostponed) + if (ShouldPostponeSwitchInAbilities(battler) || gBattleStruct->switchInAbilityPostponed) { - gBattleStruct->switchInAbilityPostponed |= gBitTable[gActiveBattler]; + gBattleStruct->switchInAbilityPostponed |= gBitTable[battler]; } else { - if (DoSwitchInAbilitiesItems(gActiveBattler)) + if (DoSwitchInAbilitiesItems(battler)) return; } - gSideStatuses[GetBattlerSide(gActiveBattler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED | SIDE_STATUS_TOXIC_SPIKES_DAMAGED | SIDE_STATUS_STEALTH_ROCK_DAMAGED | SIDE_STATUS_STICKY_WEB_DAMAGED); + gSideStatuses[GetBattlerSide(battler)] &= ~(SIDE_STATUS_SPIKES_DAMAGED | SIDE_STATUS_TOXIC_SPIKES_DAMAGED | SIDE_STATUS_STEALTH_ROCK_DAMAGED | SIDE_STATUS_STICKY_WEB_DAMAGED); for (i = 0; i < gBattlersCount; i++) { - if (gBattlerByTurnOrder[i] == gActiveBattler) + if (gBattlerByTurnOrder[i] == battler) gActionsByTurnOrder[i] = B_ACTION_CANCEL_PARTNER; gBattleStruct->hpOnSwitchout[GetBattlerSide(i)] = gBattleMons[i].hp; @@ -7062,7 +6992,7 @@ static void Cmd_switchineffects(void) gBattlerFainted++; } } - gBattleStruct->forcedSwitch &= ~(gBitTable[gActiveBattler]); + gBattleStruct->forcedSwitch &= ~(gBitTable[battler]); gBattlescriptCurrInstr = cmd->nextInstr; } } @@ -7071,9 +7001,9 @@ static void Cmd_trainerslidein(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerAtPosition(cmd->battler); - BtlController_EmitTrainerSlide(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerAtPosition(cmd->battler); + BtlController_EmitTrainerSlide(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7082,9 +7012,8 @@ static void Cmd_playse(void) { CMD_ARGS(u16 song); - gActiveBattler = gBattlerAttacker; - BtlController_EmitPlaySE(BUFFER_A, cmd->song); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlaySE(gBattlerAttacker, BUFFER_A, cmd->song); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7093,9 +7022,8 @@ static void Cmd_fanfare(void) { CMD_ARGS(u16 song); - gActiveBattler = gBattlerAttacker; - BtlController_EmitPlayFanfareOrBGM(BUFFER_A, cmd->song, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlayFanfareOrBGM(gBattlerAttacker, BUFFER_A, cmd->song, FALSE); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7104,9 +7032,9 @@ static void Cmd_playfaintcry(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitFaintingCry(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitFaintingCry(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7115,9 +7043,9 @@ static void Cmd_endlinkbattle(void) { CMD_ARGS(); - gActiveBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - BtlController_EmitEndLinkBattle(BUFFER_A, gBattleOutcome); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + BtlController_EmitEndLinkBattle(battler, BUFFER_A, gBattleOutcome); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7126,9 +7054,9 @@ static void Cmd_returntoball(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitReturnMonToBall(BUFFER_A, TRUE); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitReturnMonToBall(battler, BUFFER_A, TRUE); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7346,16 +7274,15 @@ static void Cmd_hitanimation(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - + u32 battler = GetBattlerForBattleScript(cmd->battler); if (gMoveResultFlags & MOVE_RESULT_NO_EFFECT) { gBattlescriptCurrInstr = cmd->nextInstr; } - else if (!(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE) || !(DoesSubstituteBlockMove(gBattlerAttacker, gActiveBattler, gCurrentMove)) || gDisableStructs[gActiveBattler].substituteHP == 0) + else if (!(gHitMarker & HITMARKER_IGNORE_SUBSTITUTE) || !(DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove)) || gDisableStructs[battler].substituteHP == 0) { - BtlController_EmitHitAnimation(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitHitAnimation(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } else @@ -7440,24 +7367,24 @@ static void Cmd_updatebattlermoves(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + u32 battler = GetBattlerForBattleScript(cmd->battler); switch (gBattleCommunication[0]) { case 0: - BtlController_EmitGetMonData(BUFFER_A, REQUEST_ALL_BATTLE, 0); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitGetMonData(battler, BUFFER_A, REQUEST_ALL_BATTLE, 0); + MarkBattlerForControllerExec(battler); gBattleCommunication[0]++; break; case 1: if (gBattleControllerExecFlags == 0) { s32 i; - struct BattlePokemon *bufferPoke = (struct BattlePokemon *) &gBattleResources->bufferB[gActiveBattler][4]; + struct BattlePokemon *bufferPoke = (struct BattlePokemon *) &gBattleResources->bufferB[battler][4]; for (i = 0; i < MAX_MON_MOVES; i++) { - gBattleMons[gActiveBattler].moves[i] = bufferPoke->moves[i]; - gBattleMons[gActiveBattler].pp[i] = bufferPoke->pp[i]; + gBattleMons[battler].moves[i] = bufferPoke->moves[i]; + gBattleMons[battler].pp[i] = bufferPoke->pp[i]; } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7495,16 +7422,15 @@ static void Cmd_drawpartystatussummary(void) { CMD_ARGS(u8 battler); - s32 i; + u32 battler, i; struct Pokemon *party; struct HpAndStatus hpStatuses[PARTY_SIZE]; if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - - party = GetBattlerParty(gActiveBattler); + battler = GetBattlerForBattleScript(cmd->battler); + party = GetBattlerParty(battler); for (i = 0; i < PARTY_SIZE; i++) { @@ -7521,8 +7447,8 @@ static void Cmd_drawpartystatussummary(void) } } - BtlController_EmitDrawPartyStatusSummary(BUFFER_A, hpStatuses, 1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitDrawPartyStatusSummary(battler, BUFFER_A, hpStatuses, 1); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7531,9 +7457,9 @@ static void Cmd_hidepartystatussummary(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitHidePartyStatusSummary(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitHidePartyStatusSummary(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7556,13 +7482,13 @@ static void Cmd_statusanimation(void) if (gBattleControllerExecFlags == 0) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) - && gDisableStructs[gActiveBattler].substituteHP == 0 + u32 battler = GetBattlerForBattleScript(cmd->battler); + if (!(gStatuses3[battler] & STATUS3_SEMI_INVULNERABLE) + && gDisableStructs[battler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS)) { - BtlController_EmitStatusAnimation(BUFFER_A, FALSE, gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitStatusAnimation(battler, BUFFER_A, FALSE, gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7572,18 +7498,16 @@ static void Cmd_status2animation(void) { CMD_ARGS(u8 battler, u32 status2); - u32 wantedToAnimate; - if (gBattleControllerExecFlags == 0) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - wantedToAnimate = cmd->status2; - if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) - && gDisableStructs[gActiveBattler].substituteHP == 0 + u32 battler = GetBattlerForBattleScript(cmd->battler); + u32 status2ToAnim = cmd->status2; + if (!(gStatuses3[battler] & STATUS3_SEMI_INVULNERABLE) + && gDisableStructs[battler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS)) { - BtlController_EmitStatusAnimation(BUFFER_A, TRUE, gBattleMons[gActiveBattler].status2 & wantedToAnimate); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitStatusAnimation(battler, BUFFER_A, TRUE, gBattleMons[battler].status2 & status2ToAnim); + MarkBattlerForControllerExec(battler); } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7593,18 +7517,16 @@ static void Cmd_chosenstatusanimation(void) { CMD_ARGS(u8 battler, bool8 isStatus2, u32 status); - u32 wantedStatus; - if (gBattleControllerExecFlags == 0) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - wantedStatus = cmd->status; - if (!(gStatuses3[gActiveBattler] & STATUS3_SEMI_INVULNERABLE) - && gDisableStructs[gActiveBattler].substituteHP == 0 + u32 battler = GetBattlerForBattleScript(cmd->battler); + u32 wantedStatus = cmd->status; + if (!(gStatuses3[battler] & STATUS3_SEMI_INVULNERABLE) + && gDisableStructs[battler].substituteHP == 0 && !(gHitMarker & HITMARKER_NO_ANIMATIONS)) { - BtlController_EmitStatusAnimation(BUFFER_A, cmd->isStatus2, wantedStatus); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitStatusAnimation(battler, BUFFER_A, cmd->isStatus2, wantedStatus); + MarkBattlerForControllerExec(battler); } gBattlescriptCurrInstr = cmd->nextInstr; } @@ -7708,15 +7630,13 @@ static void BestowItem(u32 battlerAtk, u32 battlerDef) { gLastUsedItem = gBattleMons[battlerAtk].item; - gActiveBattler = battlerAtk; gBattleMons[battlerAtk].item = ITEM_NONE; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerAtk].item), &gBattleMons[battlerAtk].item); + BtlController_EmitSetMonData(battlerAtk, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerAtk].item), &gBattleMons[battlerAtk].item); MarkBattlerForControllerExec(battlerAtk); CheckSetUnburden(battlerAtk); - gActiveBattler = battlerDef; gBattleMons[battlerDef].item = gLastUsedItem; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item); + BtlController_EmitSetMonData(battlerDef, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battlerDef].item), &gBattleMons[battlerDef].item); MarkBattlerForControllerExec(battlerDef); gBattleResources->flags->flags[battlerDef] &= ~RESOURCE_FLAG_UNBURDEN; } @@ -7750,6 +7670,7 @@ static void Cmd_removeitem(void) { CMD_ARGS(u8 battler); + u32 battler; u16 itemId = 0; if (gBattleScripting.overrideBerryRequirements) @@ -7759,23 +7680,23 @@ static void Cmd_removeitem(void) return; } - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - itemId = gBattleMons[gActiveBattler].item; + battler = GetBattlerForBattleScript(cmd->battler); + itemId = gBattleMons[battler].item; // Popped Air Balloon cannot be restored by any means. // Corroded items cannot be restored either. - if (GetBattlerHoldEffect(gActiveBattler, TRUE) != HOLD_EFFECT_AIR_BALLOON + if (GetBattlerHoldEffect(battler, TRUE) != HOLD_EFFECT_AIR_BALLOON && gBattleMoves[gCurrentMove].effect != EFFECT_CORROSIVE_GAS) - gBattleStruct->usedHeldItems[gBattlerPartyIndexes[gActiveBattler]][GetBattlerSide(gActiveBattler)] = itemId; // Remember if switched out + gBattleStruct->usedHeldItems[gBattlerPartyIndexes[battler]][GetBattlerSide(battler)] = itemId; // Remember if switched out - gBattleMons[gActiveBattler].item = ITEM_NONE; - CheckSetUnburden(gActiveBattler); + gBattleMons[battler].item = ITEM_NONE; + CheckSetUnburden(battler); - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].item), &gBattleMons[gActiveBattler].item); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[battler].item), &gBattleMons[battler].item); + MarkBattlerForControllerExec(battler); - ClearBattlerItemEffectHistory(gActiveBattler); - if (!TryCheekPouch(gActiveBattler, itemId) && !TrySymbiosis(gActiveBattler, itemId)) + ClearBattlerItemEffectHistory(battler); + if (!TryCheekPouch(battler, itemId) && !TrySymbiosis(battler, itemId)) gBattlescriptCurrInstr = cmd->nextInstr; } @@ -8090,13 +8011,14 @@ static void Cmd_setatktoplayer0(void) static void Cmd_makevisible(void) { CMD_ARGS(u8 battler); + u32 battler; if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitSpriteInvisibility(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitSpriteInvisibility(battler, BUFFER_A, FALSE); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -8581,7 +8503,7 @@ static void HandleScriptMegaPrimal(u32 caseId, u32 battlerId, bool32 isMega) PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[battlerId].species); - BtlController_EmitSetMonData(BUFFER_A, REQUEST_SPECIES_BATTLE, gBitTable[gBattlerPartyIndexes[battlerId]], sizeof(gBattleMons[battlerId].species), &gBattleMons[battlerId].species); + BtlController_EmitSetMonData(battlerId, BUFFER_A, REQUEST_SPECIES_BATTLE, gBitTable[gBattlerPartyIndexes[battlerId]], sizeof(gBattleMons[battlerId].species), &gBattleMons[battlerId].species); MarkBattlerForControllerExec(battlerId); } // Update healthbox and elevation and play cry. @@ -8634,12 +8556,12 @@ static void Cmd_various(void) struct Pokemon *mon; s32 i, j; u8 data[10]; - u32 side, bits; + u32 side, battler, bits; if (gBattleControllerExecFlags) return; - gActiveBattler = GetBattlerForBattleScript(cmd->battler); + battler = GetBattlerForBattleScript(cmd->battler); switch (cmd->id) { @@ -8664,7 +8586,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_ABSENT: { VARIOUS_ARGS(const u8 *jumpInstr); - if (!IsBattlerAlive(gActiveBattler)) + if (!IsBattlerAlive(battler)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -8673,9 +8595,9 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_SHIELDS_DOWN_PROTECTED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (IsShieldsDownProtected(gActiveBattler)) + if (IsShieldsDownProtected(battler)) { - gBattlerAbility = gActiveBattler; + gBattlerAbility = battler; gBattlescriptCurrInstr = cmd->jumpInstr; } else @@ -8687,13 +8609,13 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_NO_HOLD_EFFECT: { VARIOUS_ARGS(u8 holdEffect, const u8 *jumpInstr); - if (GetBattlerHoldEffect(gActiveBattler, TRUE) != cmd->holdEffect) + if (GetBattlerHoldEffect(battler, TRUE) != cmd->holdEffect) { gBattlescriptCurrInstr = cmd->jumpInstr; } else { - gLastUsedItem = gBattleMons[gActiveBattler].item; // For B_LAST_USED_ITEM + gLastUsedItem = gBattleMons[battler].item; // For B_LAST_USED_ITEM gBattlescriptCurrInstr = cmd->nextInstr; } return; @@ -8701,7 +8623,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_NO_ALLY: { VARIOUS_ARGS(const u8 *jumpInstr); - if (!IsBattlerAlive(BATTLE_PARTNER(gActiveBattler))) + if (!IsBattlerAlive(BATTLE_PARTNER(battler))) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -8710,15 +8632,15 @@ static void Cmd_various(void) case VARIOUS_INFATUATE_WITH_BATTLER: { VARIOUS_ARGS(u8 infatuateWith); - gBattleScripting.battler = gActiveBattler; - gBattleMons[gActiveBattler].status2 |= STATUS2_INFATUATED_WITH(GetBattlerForBattleScript(cmd->infatuateWith)); + gBattleScripting.battler = battler; + gBattleMons[battler].status2 |= STATUS2_INFATUATED_WITH(GetBattlerForBattleScript(cmd->infatuateWith)); gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_SET_LAST_USED_ITEM: { VARIOUS_ARGS(); - gLastUsedItem = gBattleMons[gActiveBattler].item; + gLastUsedItem = gBattleMons[battler].item; break; } case VARIOUS_TRY_FAIRY_LOCK: @@ -8740,16 +8662,16 @@ static void Cmd_various(void) { VARIOUS_ARGS(u8 stat); i = cmd->stat; - gBattleMoveDamage = *(u16 *)(&gBattleMons[gActiveBattler].attack) + (i - 1); - gBattleMoveDamage *= gStatStageRatios[gBattleMons[gActiveBattler].statStages[i]][0]; - gBattleMoveDamage /= gStatStageRatios[gBattleMons[gActiveBattler].statStages[i]][1]; + gBattleMoveDamage = *(u16 *)(&gBattleMons[battler].attack) + (i - 1); + gBattleMoveDamage *= gStatStageRatios[gBattleMons[battler].statStages[i]][0]; + gBattleMoveDamage /= gStatStageRatios[gBattleMons[battler].statStages[i]][1]; gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_JUMP_IF_FULL_HP: { VARIOUS_ARGS(const u8 *jumpInstr); - if (BATTLER_MAX_HP(gActiveBattler)) + if (BATTLER_MAX_HP(battler)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -8761,7 +8683,7 @@ static void Cmd_various(void) while (gBattleStruct->friskedBattler < gBattlersCount) { gBattlerTarget = gBattleStruct->friskedBattler++; - if (GET_BATTLER_SIDE2(gActiveBattler) != GET_BATTLER_SIDE2(gBattlerTarget) + if (GET_BATTLER_SIDE2(battler) != GET_BATTLER_SIDE2(gBattlerTarget) && IsBattlerAlive(gBattlerTarget) && gBattleMons[gBattlerTarget].item != ITEM_NONE) { @@ -8788,7 +8710,7 @@ static void Cmd_various(void) case VARIOUS_POISON_TYPE_IMMUNITY: { VARIOUS_ARGS(u8 target, const u8 *failInstr); - if (!CanPoisonType(gActiveBattler, GetBattlerForBattleScript(cmd->target))) + if (!CanPoisonType(battler, GetBattlerForBattleScript(cmd->target))) gBattlescriptCurrInstr = cmd->failInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -8797,7 +8719,7 @@ static void Cmd_various(void) case VARIOUS_PARALYZE_TYPE_IMMUNITY: { VARIOUS_ARGS(u8 target, const u8 *failInstr); - if (!CanParalyzeType(gActiveBattler, GetBattlerForBattleScript(cmd->target))) + if (!CanParalyzeType(battler, GetBattlerForBattleScript(cmd->target))) gBattlescriptCurrInstr = cmd->failInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -8806,13 +8728,13 @@ static void Cmd_various(void) case VARIOUS_TRACE_ABILITY: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].ability = gBattleStruct->overwrittenAbilities[gActiveBattler] = gBattleStruct->tracedAbility[gActiveBattler]; + gBattleMons[battler].ability = gBattleStruct->overwrittenAbilities[battler] = gBattleStruct->tracedAbility[battler]; break; } case VARIOUS_TRY_ILLUSION_OFF: { VARIOUS_ARGS(); - if (GetIllusionMonPtr(gActiveBattler) != NULL) + if (GetIllusionMonPtr(battler) != NULL) { gBattlescriptCurrInstr = cmd->nextInstr; BattleScriptPushCursor(); @@ -8831,17 +8753,17 @@ static void Cmd_various(void) case VARIOUS_UPDATE_NICK: { VARIOUS_ARGS(); - if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) - mon = &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]; + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + mon = &gPlayerParty[gBattlerPartyIndexes[battler]]; else - mon = &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]; - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], mon, HEALTHBOX_NICK); + mon = &gEnemyParty[gBattlerPartyIndexes[battler]]; + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], mon, HEALTHBOX_NICK); break; } case VARIOUS_JUMP_IF_NOT_BERRY: { VARIOUS_ARGS(const u8 *jumpInstr); - if (ItemId_GetPocket(gBattleMons[gActiveBattler].item) == POCKET_BERRIES) + if (ItemId_GetPocket(gBattleMons[battler].item) == POCKET_BERRIES) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->jumpInstr; @@ -8850,16 +8772,16 @@ static void Cmd_various(void) case VARIOUS_CHECK_IF_GRASSY_TERRAIN_HEALS: { VARIOUS_ARGS(const u8 *failInstr); - if ((gStatuses3[gActiveBattler] & (STATUS3_SEMI_INVULNERABLE | STATUS3_HEAL_BLOCK)) - || BATTLER_MAX_HP(gActiveBattler) - || !gBattleMons[gActiveBattler].hp - || !(IsBattlerGrounded(gActiveBattler))) + if ((gStatuses3[battler] & (STATUS3_SEMI_INVULNERABLE | STATUS3_HEAL_BLOCK)) + || BATTLER_MAX_HP(battler) + || !gBattleMons[battler].hp + || !(IsBattlerGrounded(battler))) { gBattlescriptCurrInstr = cmd->failInstr; } else { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; @@ -8872,10 +8794,10 @@ static void Cmd_various(void) { VARIOUS_ARGS(); // Cancel all multiturn moves of IN_AIR Pokemon except those being targeted by Sky Drop. - if (gStatuses3[gActiveBattler] & STATUS3_ON_AIR && !(gStatuses3[gActiveBattler] & STATUS3_SKY_DROPPED)) - CancelMultiTurnMoves(gActiveBattler); + if (gStatuses3[battler] & STATUS3_ON_AIR && !(gStatuses3[battler] & STATUS3_SKY_DROPPED)) + CancelMultiTurnMoves(battler); - gStatuses3[gActiveBattler] &= ~(STATUS3_MAGNET_RISE | STATUS3_TELEKINESIS | STATUS3_ON_AIR | STATUS3_SKY_DROPPED); + gStatuses3[battler] &= ~(STATUS3_MAGNET_RISE | STATUS3_TELEKINESIS | STATUS3_ON_AIR | STATUS3_SKY_DROPPED); break; } case VARIOUS_SPECTRAL_THIEF: @@ -8901,7 +8823,7 @@ static void Cmd_various(void) case VARIOUS_SET_POWDER: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].status2 |= STATUS2_POWDER; + gBattleMons[battler].status2 |= STATUS2_POWDER; break; } case VARIOUS_ACUPRESSURE: @@ -8910,7 +8832,7 @@ static void Cmd_various(void) bits = 0; for (i = STAT_ATK; i < NUM_BATTLE_STATS; i++) { - if (CompareStat(gActiveBattler, i, MAX_STAT_STAGE, CMP_LESS_THAN)) + if (CompareStat(battler, i, MAX_STAT_STAGE, CMP_LESS_THAN)) bits |= gBitTable[i]; } if (bits) @@ -8933,19 +8855,19 @@ static void Cmd_various(void) case VARIOUS_CANCEL_MULTI_TURN_MOVES: { VARIOUS_ARGS(); - CancelMultiTurnMoves(gActiveBattler); + CancelMultiTurnMoves(battler); break; } case VARIOUS_SET_MAGIC_COAT_TARGET: { VARIOUS_ARGS(); - gBattleStruct->attackerBeforeBounce = gActiveBattler; + gBattleStruct->attackerBeforeBounce = battler; gBattlerAttacker = gBattlerTarget; side = BATTLE_OPPOSITE(GetBattlerSide(gBattlerAttacker)); if (IsAffectedByFollowMe(gBattlerAttacker, side, gCurrentMove)) gBattlerTarget = gSideTimers[side].followmeTarget; else - gBattlerTarget = gActiveBattler; + gBattlerTarget = battler; break; } case VARIOUS_IS_RUNNING_IMPOSSIBLE: @@ -8963,7 +8885,7 @@ static void Cmd_various(void) case VARIOUS_GET_BATTLER_FAINTED: { VARIOUS_ARGS(); - if (gHitMarker & HITMARKER_FAINTED(gActiveBattler)) + if (gHitMarker & HITMARKER_FAINTED(battler)) gBattleCommunication[0] = TRUE; else gBattleCommunication[0] = FALSE; @@ -8972,8 +8894,8 @@ static void Cmd_various(void) case VARIOUS_RESET_SWITCH_IN_ABILITY_BITS: { VARIOUS_ARGS(); - gSpecialStatuses[gActiveBattler].traced = FALSE; - gSpecialStatuses[gActiveBattler].switchInAbilityDone = FALSE; + gSpecialStatuses[battler].traced = FALSE; + gSpecialStatuses[battler].switchInAbilityDone = FALSE; break; } case VARIOUS_UPDATE_CHOICE_MOVE_ON_LVL_UP: @@ -8982,17 +8904,17 @@ static void Cmd_various(void) if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId || gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId) { if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId) - gActiveBattler = 0; + battler = 0; else - gActiveBattler = 2; + battler = 2; for (i = 0; i < MAX_MON_MOVES; i++) { - if (gBattleMons[gActiveBattler].moves[i] == gBattleStruct->choicedMove[gActiveBattler]) + if (gBattleMons[battler].moves[i] == gBattleStruct->choicedMove[battler]) break; } if (i == MAX_MON_MOVES) - gBattleStruct->choicedMove[gActiveBattler] = MOVE_NONE; + gBattleStruct->choicedMove[battler] = MOVE_NONE; } break; } @@ -9013,15 +8935,15 @@ static void Cmd_various(void) VARIOUS_ARGS(); // Try and print end-of-turn Battle Palace flavor text (e.g. "A glint appears in mon's eyes") gBattleCommunication[0] = FALSE; // whether or not msg should be printed - gBattleScripting.battler = gActiveBattler = gBattleCommunication[1]; - if (!(gBattleStruct->palaceFlags & gBitTable[gActiveBattler]) - && gBattleMons[gActiveBattler].maxHP / 2 >= gBattleMons[gActiveBattler].hp - && gBattleMons[gActiveBattler].hp != 0 - && !(gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP)) + gBattleScripting.battler = battler = gBattleCommunication[1]; + if (!(gBattleStruct->palaceFlags & gBitTable[battler]) + && gBattleMons[battler].maxHP / 2 >= gBattleMons[battler].hp + && gBattleMons[battler].hp != 0 + && !(gBattleMons[battler].status1 & STATUS1_SLEEP)) { - gBattleStruct->palaceFlags |= gBitTable[gActiveBattler]; + gBattleStruct->palaceFlags |= gBitTable[battler]; gBattleCommunication[0] = TRUE; - gBattleCommunication[MULTISTRING_CHOOSER] = sBattlePalaceNatureToFlavorTextId[GetNatureFromPersonality(gBattleMons[gActiveBattler].personality)]; + gBattleCommunication[MULTISTRING_CHOOSER] = sBattlePalaceNatureToFlavorTextId[GetNatureFromPersonality(gBattleMons[battler].personality)]; } break; } @@ -9075,8 +8997,8 @@ static void Cmd_various(void) case VARIOUS_EMIT_YESNOBOX: { VARIOUS_ARGS(); - BtlController_EmitYesNoBox(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitYesNoBox(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_DRAW_ARENA_REF_TEXT_BOX: @@ -9115,11 +9037,11 @@ static void Cmd_various(void) case VARIOUS_RETURN_OPPONENT_MON1: { VARIOUS_ARGS(); - gActiveBattler = 1; - if (gBattleMons[gActiveBattler].hp != 0) + battler = 1; + if (gBattleMons[battler].hp != 0) { - BtlController_EmitReturnMonToBall(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitReturnMonToBall(battler, BUFFER_A, FALSE); + MarkBattlerForControllerExec(battler); } break; } @@ -9128,11 +9050,11 @@ static void Cmd_various(void) VARIOUS_ARGS(); if (gBattlersCount > 3) { - gActiveBattler = 3; - if (gBattleMons[gActiveBattler].hp != 0) + battler = 3; + if (gBattleMons[battler].hp != 0) { - BtlController_EmitReturnMonToBall(BUFFER_A, FALSE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitReturnMonToBall(battler, BUFFER_A, FALSE); + MarkBattlerForControllerExec(battler); } } break; @@ -9152,13 +9074,13 @@ static void Cmd_various(void) case VARIOUS_SET_ALREADY_STATUS_MOVE_ATTEMPT: { VARIOUS_ARGS(); - gBattleStruct->alreadyStatusedMoveAttempt |= gBitTable[gActiveBattler]; + gBattleStruct->alreadyStatusedMoveAttempt |= gBitTable[battler]; break; } case VARIOUS_PALACE_TRY_ESCAPE_STATUS: { VARIOUS_ARGS(); - if (BattlePalace_TryEscapeStatus(gActiveBattler)) + if (BattlePalace_TryEscapeStatus(battler)) return; break; } @@ -9167,16 +9089,16 @@ static void Cmd_various(void) VARIOUS_ARGS(); // Don't end the battle if one of the wild mons teleported from the wild double battle // and its partner is still alive. - if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT && IsBattlerAlive(BATTLE_PARTNER(gActiveBattler))) + if (GetBattlerSide(battler) == B_SIDE_OPPONENT && IsBattlerAlive(BATTLE_PARTNER(battler))) { - gAbsentBattlerFlags |= gBitTable[gActiveBattler]; - gHitMarker |= HITMARKER_FAINTED(gActiveBattler); - gBattleMons[gActiveBattler].hp = 0; - SetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP, &gBattleMons[gActiveBattler].hp); - SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]); + gAbsentBattlerFlags |= gBitTable[battler]; + gHitMarker |= HITMARKER_FAINTED(battler); + gBattleMons[battler].hp = 0; + SetMonData(&gEnemyParty[gBattlerPartyIndexes[battler]], MON_DATA_HP, &gBattleMons[battler].hp); + SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); FaintClearSetData(); } - else if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER) + else if (GetBattlerSide(battler) == B_SIDE_PLAYER) { gBattleOutcome = B_OUTCOME_PLAYER_TELEPORTED; } @@ -9189,8 +9111,8 @@ static void Cmd_various(void) case VARIOUS_PLAY_TRAINER_DEFEATED_MUSIC: { VARIOUS_ARGS(); - BtlController_EmitPlayFanfareOrBGM(BUFFER_A, MUS_VICTORY_TRAINER, TRUE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPlayFanfareOrBGM(battler, BUFFER_A, MUS_VICTORY_TRAINER, TRUE); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_STAT_TEXT_BUFFER: @@ -9203,9 +9125,9 @@ static void Cmd_various(void) { VARIOUS_ARGS(); gBattlescriptCurrInstr = cmd->nextInstr; - AbilityBattleEffects(ABILITYEFFECT_NEUTRALIZINGGAS, gActiveBattler, 0, 0, 0); - AbilityBattleEffects(ABILITYEFFECT_ON_SWITCHIN, gActiveBattler, 0, 0, 0); - AbilityBattleEffects(ABILITYEFFECT_TRACE2, gActiveBattler, 0, 0, 0); + AbilityBattleEffects(ABILITYEFFECT_NEUTRALIZINGGAS, battler, 0, 0, 0); + AbilityBattleEffects(ABILITYEFFECT_ON_SWITCHIN, battler, 0, 0, 0); + AbilityBattleEffects(ABILITYEFFECT_TRACE2, battler, 0, 0, 0); return; } case VARIOUS_SAVE_TARGET: @@ -9223,16 +9145,16 @@ static void Cmd_various(void) case VARIOUS_INSTANT_HP_DROP: { VARIOUS_ARGS(); - BtlController_EmitHealthBarUpdate(BUFFER_A, INSTANT_HP_BAR_DROP); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitHealthBarUpdate(battler, BUFFER_A, INSTANT_HP_BAR_DROP); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_CLEAR_STATUS: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].status1 = 0; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMons[battler].status1 = 0; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_RESTORE_PP: @@ -9240,19 +9162,19 @@ static void Cmd_various(void) VARIOUS_ARGS(); for (i = 0; i < 4; i++) { - gBattleMons[gActiveBattler].pp[i] = CalculatePPWithBonus(gBattleMons[gActiveBattler].moves[i], gBattleMons[gActiveBattler].ppBonuses, i); - data[i] = gBattleMons[gActiveBattler].pp[i]; + gBattleMons[battler].pp[i] = CalculatePPWithBonus(gBattleMons[battler].moves[i], gBattleMons[battler].ppBonuses, i); + data[i] = gBattleMons[battler].pp[i]; } - data[i] = gBattleMons[gActiveBattler].ppBonuses; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PP_DATA_BATTLE, 0, 5, data); - MarkBattlerForControllerExec(gActiveBattler); + data[i] = gBattleMons[battler].ppBonuses; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_PP_DATA_BATTLE, 0, 5, data); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_TRY_ACTIVATE_MOXIE: // and chilling neigh + as one ice rider { VARIOUS_ARGS(); - u16 battlerAbility = GetBattlerAbility(gActiveBattler); + u16 battlerAbility = GetBattlerAbility(battler); if ((battlerAbility == ABILITY_MOXIE || battlerAbility == ABILITY_CHILLING_NEIGH @@ -9276,7 +9198,7 @@ static void Cmd_various(void) { VARIOUS_ARGS(); - u16 battlerAbility = GetBattlerAbility(gActiveBattler); + u16 battlerAbility = GetBattlerAbility(battler); if ((battlerAbility == ABILITY_GRIM_NEIGH || battlerAbility == ABILITY_AS_ONE_SHADOW_RIDER) @@ -9298,13 +9220,13 @@ static void Cmd_various(void) case VARIOUS_TRY_ACTIVATE_RECEIVER: // Partner gets fainted's ally ability { VARIOUS_ARGS(); - gBattlerAbility = BATTLE_PARTNER(gActiveBattler); + gBattlerAbility = BATTLE_PARTNER(battler); i = GetBattlerAbility(gBattlerAbility); if (IsBattlerAlive(gBattlerAbility) && (i == ABILITY_RECEIVER || i == ABILITY_POWER_OF_ALCHEMY) - && GetBattlerHoldEffect(gActiveBattler, TRUE) != HOLD_EFFECT_ABILITY_SHIELD) + && GetBattlerHoldEffect(battler, TRUE) != HOLD_EFFECT_ABILITY_SHIELD) { - switch (gBattleMons[gActiveBattler].ability) + switch (gBattleMons[battler].ability) { // Can't copy these abilities. case ABILITY_POWER_OF_ALCHEMY: case ABILITY_RECEIVER: case ABILITY_FORECAST: case ABILITY_MULTITYPE: @@ -9317,8 +9239,8 @@ static void Cmd_various(void) case ABILITY_RKS_SYSTEM: case ABILITY_TRACE: break; default: - gBattleStruct->tracedAbility[gBattlerAbility] = gBattleMons[gActiveBattler].ability; // re-using the variable for trace - gBattleScripting.battler = gActiveBattler; + gBattleStruct->tracedAbility[gBattlerAbility] = gBattleMons[battler].ability; // re-using the variable for trace + gBattleScripting.battler = battler; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = BattleScript_ReceiverActivates; return; @@ -9329,8 +9251,8 @@ static void Cmd_various(void) case VARIOUS_TRY_ACTIVATE_BEAST_BOOST: { VARIOUS_ARGS(); - i = GetHighestStatId(gActiveBattler); - if (GetBattlerAbility(gActiveBattler) == ABILITY_BEAST_BOOST + i = GetHighestStatId(battler); + if (GetBattlerAbility(battler) == ABILITY_BEAST_BOOST && HasAttackerFaintedTarget() && !NoAliveMonsForEitherParty() && CompareStat(gBattlerAttacker, i, MAX_STAT_STAGE, CMP_LESS_THAN)) @@ -9387,19 +9309,19 @@ static void Cmd_various(void) case VARIOUS_PLAY_MOVE_ANIMATION: { VARIOUS_ARGS(u16 move); - BtlController_EmitMoveAnimation(BUFFER_A, cmd->move, gBattleScripting.animTurn, 0, 0, gBattleMons[gActiveBattler].friendship, &gDisableStructs[gActiveBattler], gMultiHitCounter); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitMoveAnimation(battler, BUFFER_A, cmd->move, gBattleScripting.animTurn, 0, 0, gBattleMons[battler].friendship, &gDisableStructs[battler], gMultiHitCounter); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_SET_LUCKY_CHANT: { VARIOUS_ARGS(const u8 *failInstr); - if (!(gSideStatuses[GET_BATTLER_SIDE(gActiveBattler)] & SIDE_STATUS_LUCKY_CHANT)) + if (!(gSideStatuses[GET_BATTLER_SIDE(battler)] & SIDE_STATUS_LUCKY_CHANT)) { - gSideStatuses[GET_BATTLER_SIDE(gActiveBattler)] |= SIDE_STATUS_LUCKY_CHANT; - gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].luckyChantBattlerId = gActiveBattler; - gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].luckyChantTimer = 5; + gSideStatuses[GET_BATTLER_SIDE(battler)] |= SIDE_STATUS_LUCKY_CHANT; + gSideTimers[GET_BATTLER_SIDE(battler)].luckyChantBattlerId = battler; + gSideTimers[GET_BATTLER_SIDE(battler)].luckyChantTimer = 5; gBattlescriptCurrInstr = cmd->nextInstr; } else @@ -9476,22 +9398,22 @@ static void Cmd_various(void) case VARIOUS_SET_LAST_USED_ABILITY: { VARIOUS_ARGS(); - gLastUsedAbility = gBattleMons[gActiveBattler].ability; + gLastUsedAbility = gBattleMons[battler].ability; break; } case VARIOUS_TRY_HEAL_PULSE: { VARIOUS_ARGS(const u8 *failInstr); - if (BATTLER_MAX_HP(gActiveBattler)) + if (BATTLER_MAX_HP(battler)) { gBattlescriptCurrInstr = cmd->failInstr; } else { if (GetBattlerAbility(gBattlerAttacker) == ABILITY_MEGA_LAUNCHER && gBattleMoves[gCurrentMove].pulseMove) - gBattleMoveDamage = -(gBattleMons[gActiveBattler].maxHP * 75 / 100); + gBattleMoveDamage = -(gBattleMons[battler].maxHP * 75 / 100); else - gBattleMoveDamage = -(gBattleMons[gActiveBattler].maxHP / 2); + gBattleMoveDamage = -(gBattleMons[battler].maxHP / 2); if (gBattleMoveDamage == 0) gBattleMoveDamage = -1; @@ -9518,10 +9440,10 @@ static void Cmd_various(void) VARIOUS_ARGS(); for (i = 0; i < NUM_BATTLE_STATS; i++) { - if (gBattleMons[gActiveBattler].statStages[i] < DEFAULT_STAT_STAGE) // Negative becomes positive. - gBattleMons[gActiveBattler].statStages[i] = DEFAULT_STAT_STAGE + (DEFAULT_STAT_STAGE - gBattleMons[gActiveBattler].statStages[i]); - else if (gBattleMons[gActiveBattler].statStages[i] > DEFAULT_STAT_STAGE) // Positive becomes negative. - gBattleMons[gActiveBattler].statStages[i] = DEFAULT_STAT_STAGE - (gBattleMons[gActiveBattler].statStages[i] - DEFAULT_STAT_STAGE); + if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE) // Negative becomes positive. + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE + (DEFAULT_STAT_STAGE - gBattleMons[battler].statStages[i]); + else if (gBattleMons[battler].statStages[i] > DEFAULT_STAT_STAGE) // Positive becomes negative. + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE - (gBattleMons[battler].statStages[i] - DEFAULT_STAT_STAGE); } break; } @@ -9621,42 +9543,42 @@ static void Cmd_various(void) case VARIOUS_HANDLE_MEGA_EVO: { VARIOUS_ARGS(u8 case_); - HandleScriptMegaPrimal(cmd->case_, gActiveBattler, TRUE); + HandleScriptMegaPrimal(cmd->case_, battler, TRUE); gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_HANDLE_PRIMAL_REVERSION: { VARIOUS_ARGS(u8 case_); - HandleScriptMegaPrimal(cmd->case_, gActiveBattler, FALSE); + HandleScriptMegaPrimal(cmd->case_, battler, FALSE); gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_HANDLE_FORM_CHANGE: { VARIOUS_ARGS(u8 case_); - if (GetBattlerSide(gActiveBattler) == B_SIDE_OPPONENT) - mon = &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]; + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + mon = &gEnemyParty[gBattlerPartyIndexes[battler]]; else - mon = &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]; + mon = &gPlayerParty[gBattlerPartyIndexes[battler]]; // Change species. if (cmd->case_ == 0) { if (!gBattleTextBuff1) - PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[gActiveBattler].species); - BtlController_EmitSetMonData(BUFFER_A, REQUEST_SPECIES_BATTLE, gBitTable[gBattlerPartyIndexes[gActiveBattler]], sizeof(gBattleMons[gActiveBattler].species), &gBattleMons[gActiveBattler].species); - MarkBattlerForControllerExec(gActiveBattler); + PREPARE_SPECIES_BUFFER(gBattleTextBuff1, gBattleMons[battler].species); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_SPECIES_BATTLE, gBitTable[gBattlerPartyIndexes[battler]], sizeof(gBattleMons[battler].species), &gBattleMons[battler].species); + MarkBattlerForControllerExec(battler); } // Change stats. else if (cmd->case_ == 1) { - RecalcBattlerStats(gActiveBattler, mon); + RecalcBattlerStats(battler, mon); } // Update healthbox. else { - UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], mon, HEALTHBOX_ALL); + UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], mon, HEALTHBOX_ALL); } gBattlescriptCurrInstr = cmd->nextInstr; return; @@ -9664,7 +9586,7 @@ static void Cmd_various(void) case VARIOUS_TRY_LAST_RESORT: { VARIOUS_ARGS(const u8 *failInstr); - if (CanUseLastResort(gActiveBattler)) + if (CanUseLastResort(battler)) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->failInstr; @@ -9729,9 +9651,9 @@ static void Cmd_various(void) case VARIOUS_TRY_AUTOTOMIZE: { VARIOUS_ARGS(const u8 *failInstr); - if (GetBattlerWeight(gActiveBattler) > 1) + if (GetBattlerWeight(battler) > 1) { - gDisableStructs[gActiveBattler].autotomizeCount++; + gDisableStructs[battler].autotomizeCount++; gBattlescriptCurrInstr = cmd->nextInstr; } else @@ -9784,7 +9706,7 @@ static void Cmd_various(void) { gBattlerTarget = gBattleStruct->lastMoveTarget[gBattlerAttacker]; gHitMarker &= ~HITMARKER_ATTACKSTRING_PRINTED; - PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, gActiveBattler, gBattlerPartyIndexes[gActiveBattler]); + PREPARE_MON_NICK_WITH_PREFIX_BUFFER(gBattleTextBuff1, battler, gBattlerPartyIndexes[battler]); gBattlescriptCurrInstr = cmd->nextInstr; } } @@ -9793,13 +9715,13 @@ static void Cmd_various(void) case VARIOUS_ABILITY_POPUP: { VARIOUS_ARGS(); - CreateAbilityPopUp(gActiveBattler, gBattleMons[gActiveBattler].ability, (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) != 0); + CreateAbilityPopUp(battler, gBattleMons[battler].ability, (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) != 0); break; } case VARIOUS_UPDATE_ABILITY_POPUP: { VARIOUS_ARGS(); - UpdateAbilityPopup(gActiveBattler); + UpdateAbilityPopup(battler); break; } case VARIOUS_DEFOG: @@ -9814,7 +9736,7 @@ static void Cmd_various(void) } else { - if (TryDefogClear(gActiveBattler, FALSE)) + if (TryDefogClear(battler, FALSE)) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->failInstr; @@ -9844,8 +9766,8 @@ static void Cmd_various(void) VARIOUS_ARGS(u8 type); for (i = 0; i < 3; i++) { - if (*(u8 *)(&gBattleMons[gActiveBattler].type1 + i) == cmd->type) - *(u8 *)(&gBattleMons[gActiveBattler].type1 + i) = TYPE_MYSTERY; + if (*(u8 *)(&gBattleMons[battler].type1 + i) == cmd->type) + *(u8 *)(&gBattleMons[battler].type1 + i) = TYPE_MYSTERY; } gBattlescriptCurrInstr = cmd->nextInstr; return; @@ -9872,25 +9794,25 @@ static void Cmd_various(void) return; } gBattleMons[gBattlerTarget].status1 = gBattleMons[gBattlerAttacker].status1 & STATUS1_ANY; - gActiveBattler = gBattlerTarget; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + battler = gBattlerTarget; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; return; } case VARIOUS_CURE_STATUS: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].status1 = 0; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMons[battler].status1 = 0; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[battler].status1), &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_POWER_TRICK: { VARIOUS_ARGS(); - gStatuses3[gActiveBattler] ^= STATUS3_POWER_TRICK; - SWAP(gBattleMons[gActiveBattler].attack, gBattleMons[gActiveBattler].defense, i); + gStatuses3[battler] ^= STATUS3_POWER_TRICK; + SWAP(gBattleMons[battler].attack, gBattleMons[battler].defense, i); break; } case VARIOUS_AFTER_YOU: @@ -9934,7 +9856,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_NOT_GROUNDED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (!IsBattlerGrounded(gActiveBattler)) + if (!IsBattlerGrounded(battler)) gBattlescriptCurrInstr = gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -9946,24 +9868,24 @@ static void Cmd_various(void) if (cmd->case_ == 0) { // Save sprite IDs, because trainer slide in will overwrite gBattlerSpriteIds variable. - gBattleScripting.savedDmg = (gBattlerSpriteIds[gActiveBattler] & 0xFF) | (gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)] << 8); - HideBattlerShadowSprite(gActiveBattler); + gBattleScripting.savedDmg = (gBattlerSpriteIds[battler] & 0xFF) | (gBattlerSpriteIds[BATTLE_PARTNER(battler)] << 8); + HideBattlerShadowSprite(battler); } else if (cmd->case_ == 1) { - BtlController_EmitPrintString(BUFFER_A, STRINGID_TRAINERSLIDE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPrintString(battler, BUFFER_A, STRINGID_TRAINERSLIDE); + MarkBattlerForControllerExec(battler); } else { - gBattlerSpriteIds[BATTLE_PARTNER(gActiveBattler)] = gBattleScripting.savedDmg >> 8; - gBattlerSpriteIds[gActiveBattler] = gBattleScripting.savedDmg & 0xFF; - if (IsBattlerAlive(gActiveBattler)) + gBattlerSpriteIds[BATTLE_PARTNER(battler)] = gBattleScripting.savedDmg >> 8; + gBattlerSpriteIds[battler] = gBattleScripting.savedDmg & 0xFF; + if (IsBattlerAlive(battler)) { - SetBattlerShadowSpriteCallback(gActiveBattler, gBattleMons[gActiveBattler].species); - BattleLoadMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler); + SetBattlerShadowSpriteCallback(battler, gBattleMons[battler].species); + BattleLoadMonSpriteGfx(&gEnemyParty[gBattlerPartyIndexes[battler]], battler); } - i = BATTLE_PARTNER(gActiveBattler); + i = BATTLE_PARTNER(battler); if (IsBattlerAlive(i)) { SetBattlerShadowSpriteCallback(i, gBattleMons[i].species); @@ -9976,9 +9898,9 @@ static void Cmd_various(void) case VARIOUS_TRY_TRAINER_SLIDE_MSG_FIRST_OFF: { VARIOUS_ARGS(); - if ((i = ShouldDoTrainerSlide(gActiveBattler, TRAINER_SLIDE_FIRST_DOWN))) + if ((i = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_FIRST_DOWN))) { - gBattleScripting.battler = gActiveBattler; + gBattleScripting.battler = battler; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = (i == 1 ? BattleScript_TrainerASlideMsgRet : BattleScript_TrainerBSlideMsgRet); return; @@ -9988,9 +9910,9 @@ static void Cmd_various(void) case VARIOUS_TRY_TRAINER_SLIDE_MSG_LAST_ON: { VARIOUS_ARGS(); - if ((i = ShouldDoTrainerSlide(gActiveBattler, TRAINER_SLIDE_LAST_SWITCHIN))) + if ((i = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_LAST_SWITCHIN))) { - gBattleScripting.battler = gActiveBattler; + gBattleScripting.battler = battler; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = (i == 1 ? BattleScript_TrainerASlideMsgRet : BattleScript_TrainerBSlideMsgRet); return; @@ -10000,7 +9922,7 @@ static void Cmd_various(void) case VARIOUS_SET_AURORA_VEIL: { VARIOUS_ARGS(); - if (gSideStatuses[GET_BATTLER_SIDE(gActiveBattler)] & SIDE_STATUS_AURORA_VEIL + if (gSideStatuses[GET_BATTLER_SIDE(battler)] & SIDE_STATUS_AURORA_VEIL || !(WEATHER_HAS_EFFECT && gBattleWeather & (B_WEATHER_HAIL | B_WEATHER_SNOW))) { gMoveResultFlags |= MOVE_RESULT_MISSED; @@ -10008,12 +9930,12 @@ static void Cmd_various(void) } else { - gSideStatuses[GET_BATTLER_SIDE(gActiveBattler)] |= SIDE_STATUS_AURORA_VEIL; - if (GetBattlerHoldEffect(gActiveBattler, TRUE) == HOLD_EFFECT_LIGHT_CLAY) - gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].auroraVeilTimer = 8; + gSideStatuses[GET_BATTLER_SIDE(battler)] |= SIDE_STATUS_AURORA_VEIL; + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_LIGHT_CLAY) + gSideTimers[GET_BATTLER_SIDE(battler)].auroraVeilTimer = 8; else - gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].auroraVeilTimer = 5; - gSideTimers[GET_BATTLER_SIDE(gActiveBattler)].auroraVeilBattlerId = gActiveBattler; + gSideTimers[GET_BATTLER_SIDE(battler)].auroraVeilTimer = 5; + gSideTimers[GET_BATTLER_SIDE(battler)].auroraVeilBattlerId = battler; if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE && CountAliveMonsInBattle(BATTLE_ALIVE_ATK_SIDE) == 2) gBattleCommunication[MULTISTRING_CHOOSER] = 5; @@ -10025,13 +9947,13 @@ static void Cmd_various(void) case VARIOUS_TRY_THIRD_TYPE: { VARIOUS_ARGS(const u8 *failInstr); - if (IS_BATTLER_OF_TYPE(gActiveBattler, gBattleMoves[gCurrentMove].argument)) + if (IS_BATTLER_OF_TYPE(battler, gBattleMoves[gCurrentMove].argument)) { gBattlescriptCurrInstr = cmd->failInstr; } else { - gBattleMons[gActiveBattler].type3 = gBattleMoves[gCurrentMove].argument; + gBattleMons[battler].type3 = gBattleMoves[gCurrentMove].argument; PREPARE_TYPE_BUFFER(gBattleTextBuff1, gBattleMoves[gCurrentMove].argument); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -10040,14 +9962,14 @@ static void Cmd_various(void) case VARIOUS_DESTROY_ABILITY_POPUP: { VARIOUS_ARGS(); - DestroyAbilityPopUp(gActiveBattler); + DestroyAbilityPopUp(battler); break; } case VARIOUS_TOTEM_BOOST: { VARIOUS_ARGS(const u8 *jumpInstr); - gActiveBattler = gBattlerAttacker; - if (gTotemBoosts[gActiveBattler].stats == 0) + battler = gBattlerAttacker; + if (gTotemBoosts[battler].stats == 0) { gBattlescriptCurrInstr = cmd->nextInstr; // stats done, exit } @@ -10055,19 +9977,19 @@ static void Cmd_various(void) { for (i = 0; i < (NUM_BATTLE_STATS - 1); i++) { - if (gTotemBoosts[gActiveBattler].stats & (1 << i)) + if (gTotemBoosts[battler].stats & (1 << i)) { - if (gTotemBoosts[gActiveBattler].statChanges[i] <= -1) - SET_STATCHANGER(i + 1, abs(gTotemBoosts[gActiveBattler].statChanges[i]), TRUE); + if (gTotemBoosts[battler].statChanges[i] <= -1) + SET_STATCHANGER(i + 1, abs(gTotemBoosts[battler].statChanges[i]), TRUE); else - SET_STATCHANGER(i + 1, gTotemBoosts[gActiveBattler].statChanges[i], FALSE); + SET_STATCHANGER(i + 1, gTotemBoosts[battler].statChanges[i], FALSE); - gTotemBoosts[gActiveBattler].stats &= ~(1 << i); - gBattleScripting.battler = gActiveBattler; - gBattlerTarget = gActiveBattler; - if (gTotemBoosts[gActiveBattler].stats & 0x80) + gTotemBoosts[battler].stats &= ~(1 << i); + gBattleScripting.battler = battler; + gBattlerTarget = battler; + if (gTotemBoosts[battler].stats & 0x80) { - gTotemBoosts[gActiveBattler].stats &= ~0x80; // set 'aura flared to life' flag + gTotemBoosts[battler].stats &= ~0x80; // set 'aura flared to life' flag gBattlescriptCurrInstr = BattleScript_TotemFlaredToLife; } else @@ -10084,14 +10006,14 @@ static void Cmd_various(void) case VARIOUS_MOVEEND_ITEM_EFFECTS: { VARIOUS_ARGS(); - if (ItemBattleEffects(ITEMEFFECT_NORMAL, gActiveBattler, FALSE)) + if (ItemBattleEffects(ITEMEFFECT_NORMAL, battler, FALSE)) return; break; } case VARIOUS_ROOM_SERVICE: { VARIOUS_ARGS(const u8 *failInstr); - if (GetBattlerHoldEffect(gActiveBattler, TRUE) == HOLD_EFFECT_ROOM_SERVICE && TryRoomService(gActiveBattler)) + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_ROOM_SERVICE && TryRoomService(battler)) { BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryStatRaiseRet; @@ -10105,23 +10027,23 @@ static void Cmd_various(void) case VARIOUS_TERRAIN_SEED: { VARIOUS_ARGS(const u8 *failInstr); - if (GetBattlerHoldEffect(gActiveBattler, TRUE) == HOLD_EFFECT_SEEDS) + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_SEEDS) { u8 effect = 0; - u16 item = gBattleMons[gActiveBattler].item; - switch (GetBattlerHoldEffectParam(gActiveBattler)) + u16 item = gBattleMons[battler].item; + switch (GetBattlerHoldEffectParam(battler)) { case HOLD_EFFECT_PARAM_ELECTRIC_TERRAIN: - effect = TryHandleSeed(gActiveBattler, STATUS_FIELD_ELECTRIC_TERRAIN, STAT_DEF, item, FALSE); + effect = TryHandleSeed(battler, STATUS_FIELD_ELECTRIC_TERRAIN, STAT_DEF, item, FALSE); break; case HOLD_EFFECT_PARAM_GRASSY_TERRAIN: - effect = TryHandleSeed(gActiveBattler, STATUS_FIELD_GRASSY_TERRAIN, STAT_DEF, item, FALSE); + effect = TryHandleSeed(battler, STATUS_FIELD_GRASSY_TERRAIN, STAT_DEF, item, FALSE); break; case HOLD_EFFECT_PARAM_MISTY_TERRAIN: - effect = TryHandleSeed(gActiveBattler, STATUS_FIELD_MISTY_TERRAIN, STAT_SPDEF, item, FALSE); + effect = TryHandleSeed(battler, STATUS_FIELD_MISTY_TERRAIN, STAT_SPDEF, item, FALSE); break; case HOLD_EFFECT_PARAM_PSYCHIC_TERRAIN: - effect = TryHandleSeed(gActiveBattler, STATUS_FIELD_PSYCHIC_TERRAIN, STAT_SPDEF, item, FALSE); + effect = TryHandleSeed(battler, STATUS_FIELD_PSYCHIC_TERRAIN, STAT_SPDEF, item, FALSE); break; } @@ -10137,15 +10059,15 @@ static void Cmd_various(void) if (gBattleControllerExecFlags) break; - BtlController_EmitSpriteInvisibility(BUFFER_A, TRUE); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSpriteInvisibility(battler, BUFFER_A, TRUE); + MarkBattlerForControllerExec(battler); break; } case VARIOUS_JUMP_IF_TERRAIN_AFFECTED: { VARIOUS_ARGS(u32 flags, const u8 *jumpInstr); u32 flags = cmd->flags; - if (IsBattlerTerrainAffected(gActiveBattler, flags)) + if (IsBattlerTerrainAffected(battler, flags)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10154,36 +10076,36 @@ static void Cmd_various(void) case VARIOUS_EERIE_SPELL_PP_REDUCE: { VARIOUS_ARGS(const u8 *failInstr); - if (gLastMoves[gActiveBattler] != 0 && gLastMoves[gActiveBattler] != 0xFFFF) + if (gLastMoves[battler] != 0 && gLastMoves[battler] != 0xFFFF) { s32 i; for (i = 0; i < MAX_MON_MOVES; i++) { - if (gLastMoves[gActiveBattler] == gBattleMons[gActiveBattler].moves[i]) + if (gLastMoves[battler] == gBattleMons[battler].moves[i]) break; } - if (i != MAX_MON_MOVES && gBattleMons[gActiveBattler].pp[i] != 0) + if (i != MAX_MON_MOVES && gBattleMons[battler].pp[i] != 0) { s32 ppToDeduct = 3; - if (gBattleMons[gActiveBattler].pp[i] < ppToDeduct) - ppToDeduct = gBattleMons[gActiveBattler].pp[i]; + if (gBattleMons[battler].pp[i] < ppToDeduct) + ppToDeduct = gBattleMons[battler].pp[i]; - PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastMoves[gActiveBattler]) + PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastMoves[battler]) ConvertIntToDecimalStringN(gBattleTextBuff2, ppToDeduct, STR_CONV_MODE_LEFT_ALIGN, 1); PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff2, 1, ppToDeduct) - gBattleMons[gActiveBattler].pp[i] -= ppToDeduct; - if (!(gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[i]) - && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED)) + gBattleMons[battler].pp[i] -= ppToDeduct; + if (!(gDisableStructs[battler].mimickedMoves & gBitTable[i]) + && !(gBattleMons[battler].status2 & STATUS2_TRANSFORMED)) { - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gActiveBattler].pp[i]), &gBattleMons[gActiveBattler].pp[i]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[battler].pp[i]), &gBattleMons[battler].pp[i]); + MarkBattlerForControllerExec(battler); } - if (gBattleMons[gActiveBattler].pp[i] == 0 && gBattleStruct->skyDropTargets[gActiveBattler] == 0xFF) - CancelMultiTurnMoves(gActiveBattler); + if (gBattleMons[battler].pp[i] == 0 && gBattleStruct->skyDropTargets[battler] == 0xFF) + CancelMultiTurnMoves(battler); gBattlescriptCurrInstr = cmd->nextInstr; // continue } @@ -10201,10 +10123,10 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_TEAM_HEALTHY: { VARIOUS_ARGS(const u8 *jumpInstr); - if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && IsBattlerAlive(BATTLE_PARTNER(gActiveBattler))) + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && IsBattlerAlive(BATTLE_PARTNER(battler))) { - u8 partner = BATTLE_PARTNER(gActiveBattler); - if ((gBattleMons[gActiveBattler].hp == gBattleMons[gActiveBattler].maxHP && !(gBattleMons[gActiveBattler].status1 & STATUS1_ANY)) + u8 partner = BATTLE_PARTNER(battler); + if ((gBattleMons[battler].hp == gBattleMons[battler].maxHP && !(gBattleMons[battler].status1 & STATUS1_ANY)) && (gBattleMons[partner].hp == gBattleMons[partner].maxHP && !(gBattleMons[partner].status1 & STATUS1_ANY))) gBattlescriptCurrInstr = cmd->jumpInstr; else @@ -10212,7 +10134,7 @@ static void Cmd_various(void) } else // single battle { - if (gBattleMons[gActiveBattler].hp == gBattleMons[gActiveBattler].maxHP && !(gBattleMons[gActiveBattler].status1 & STATUS1_ANY)) + if (gBattleMons[battler].hp == gBattleMons[battler].maxHP && !(gBattleMons[battler].status1 & STATUS1_ANY)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10222,12 +10144,12 @@ static void Cmd_various(void) case VARIOUS_TRY_HEAL_QUARTER_HP: { VARIOUS_ARGS(const u8 *failInstr); - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 4; + gBattleMoveDamage = gBattleMons[battler].maxHP / 4; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; - if (gBattleMons[gActiveBattler].hp == gBattleMons[gActiveBattler].maxHP) + if (gBattleMons[battler].hp == gBattleMons[battler].maxHP) gBattlescriptCurrInstr = cmd->failInstr; // fail else gBattlescriptCurrInstr = cmd->nextInstr; // can heal @@ -10319,7 +10241,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_PRANKSTER_BLOCKED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (BlocksPrankster(gCurrentMove, gBattlerAttacker, gActiveBattler, TRUE)) + if (BlocksPrankster(gCurrentMove, gBattlerAttacker, battler, TRUE)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10341,19 +10263,19 @@ static void Cmd_various(void) if (gBattleWeather & B_WEATHER_SUN_PRIMAL && !shouldNotClear) { gBattleWeather &= ~B_WEATHER_SUN_PRIMAL; - PrepareStringBattle(STRINGID_EXTREMESUNLIGHTFADED, gActiveBattler); + PrepareStringBattle(STRINGID_EXTREMESUNLIGHTFADED, battler); gBattleCommunication[MSG_DISPLAY] = 1; } else if (gBattleWeather & B_WEATHER_RAIN_PRIMAL && !shouldNotClear) { gBattleWeather &= ~B_WEATHER_RAIN_PRIMAL; - PrepareStringBattle(STRINGID_HEAVYRAINLIFTED, gActiveBattler); + PrepareStringBattle(STRINGID_HEAVYRAINLIFTED, battler); gBattleCommunication[MSG_DISPLAY] = 1; } else if (gBattleWeather & B_WEATHER_STRONG_WINDS && !shouldNotClear) { gBattleWeather &= ~B_WEATHER_STRONG_WINDS; - PrepareStringBattle(STRINGID_STRONGWINDSDISSIPATED, gActiveBattler); + PrepareStringBattle(STRINGID_STRONGWINDSDISSIPATED, battler); gBattleCommunication[MSG_DISPLAY] = 1; } break; @@ -10361,9 +10283,9 @@ static void Cmd_various(void) case VARIOUS_TRY_END_NEUTRALIZING_GAS: { VARIOUS_ARGS(); - if (gSpecialStatuses[gActiveBattler].neutralizingGasRemoved) + if (gSpecialStatuses[battler].neutralizingGasRemoved) { - gSpecialStatuses[gActiveBattler].neutralizingGasRemoved = FALSE; + gSpecialStatuses[battler].neutralizingGasRemoved = FALSE; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = BattleScript_NeutralizingGasExits; return; @@ -10396,9 +10318,9 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_NOT_ROTOTILLER_AFFECTED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (gSpecialStatuses[gActiveBattler].rototillerAffected) + if (gSpecialStatuses[battler].rototillerAffected) { - gSpecialStatuses[gActiveBattler].rototillerAffected = FALSE; + gSpecialStatuses[battler].rototillerAffected = FALSE; gBattlescriptCurrInstr = cmd->nextInstr; } else @@ -10435,10 +10357,10 @@ static void Cmd_various(void) } if (cmd->fromBattler) - gLastUsedItem = gBattleMons[gActiveBattler].item; + gLastUsedItem = gBattleMons[battler].item; - gBattleScripting.battler = gEffectBattler = gBattlerTarget = gActiveBattler; // Cover all berry effect battlerId cases. e.g. ChangeStatBuffs uses target ID - if (ItemBattleEffects(ITEMEFFECT_USE_LAST_ITEM, gActiveBattler, FALSE)) + gBattleScripting.battler = gEffectBattler = gBattlerTarget = battler; // Cover all berry effect battlerId cases. e.g. ChangeStatBuffs uses target ID + if (ItemBattleEffects(ITEMEFFECT_USE_LAST_ITEM, battler, FALSE)) return; gBattlescriptCurrInstr = cmd->nextInstr; return; @@ -10446,7 +10368,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_CANT_REVERT_TO_PRIMAL: { VARIOUS_ARGS(const u8 *jumpInstr); - if (GetBattleFormChangeTargetSpecies(gActiveBattler, FORM_CHANGE_BATTLE_PRIMAL_REVERSION) == SPECIES_NONE) + if (GetBattleFormChangeTargetSpecies(battler, FORM_CHANGE_BATTLE_PRIMAL_REVERSION) == SPECIES_NONE) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10456,7 +10378,7 @@ static void Cmd_various(void) { VARIOUS_ARGS(u32 flags, const u8 *jumpInstr); u32 flags = cmd->flags; - if (IsBattlerWeatherAffected(gActiveBattler, flags)) + if (IsBattlerWeatherAffected(battler, flags)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10472,7 +10394,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_SPECIES: { VARIOUS_ARGS(u16 species, const u8 *jumpInstr); - if (gBattleMons[gActiveBattler].species == cmd->species) + if (gBattleMons[battler].species == cmd->species) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10481,7 +10403,7 @@ static void Cmd_various(void) case VARIOUS_PHOTON_GEYSER_CHECK: { VARIOUS_ARGS(); - gBattleStruct->swapDamageCategory = (GetSplitBasedOnStats(gActiveBattler) == SPLIT_SPECIAL); + gBattleStruct->swapDamageCategory = (GetSplitBasedOnStats(battler) == SPLIT_SPECIAL); break; } case VARIOUS_SHELL_SIDE_ARM_CHECK: // 0% chance GameFreak actually checks this way according to DaWobblefet, but this is the only functional explanation at the moment @@ -10525,9 +10447,9 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_LEAF_GUARD_PROTECTED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (IsLeafGuardProtected(gActiveBattler)) + if (IsLeafGuardProtected(battler)) { - gBattlerAbility = gActiveBattler; + gBattlerAbility = battler; gBattlescriptCurrInstr = cmd->jumpInstr; } else @@ -10543,8 +10465,8 @@ static void Cmd_various(void) // If Pokémon which set up Sticky Web is not on the field, no Pokémon have their Speed lowered." gBattlerAttacker = gBattlerTarget; // Initialize 'fail' condition SET_STATCHANGER(STAT_SPEED, 1, TRUE); - if (gSideTimers[GetBattlerSide(gActiveBattler)].stickyWebBattlerId != 0xFF) - gBattlerAttacker = gSideTimers[GetBattlerSide(gActiveBattler)].stickyWebBattlerId; + if (gSideTimers[GetBattlerSide(battler)].stickyWebBattlerId != 0xFF) + gBattlerAttacker = gSideTimers[GetBattlerSide(battler)].stickyWebBattlerId; break; } case VARIOUS_CUT_1_3_HP_RAISE_STATS: @@ -10576,15 +10498,15 @@ static void Cmd_various(void) case VARIOUS_SET_OCTOLOCK: { VARIOUS_ARGS(const u8 *failInstr); - if (gDisableStructs[gActiveBattler].octolock) + if (gDisableStructs[battler].octolock) { gBattlescriptCurrInstr = cmd->failInstr; } else { - gDisableStructs[gActiveBattler].octolock = TRUE; - gBattleMons[gActiveBattler].status2 |= STATUS2_ESCAPE_PREVENTION; - gDisableStructs[gActiveBattler].battlerPreventingEscape = gBattlerAttacker; + gDisableStructs[battler].octolock = TRUE; + gBattleMons[battler].status2 |= STATUS2_ESCAPE_PREVENTION; + gDisableStructs[battler].battlerPreventingEscape = gBattlerAttacker; gBattlescriptCurrInstr = cmd->nextInstr; } return; @@ -10592,16 +10514,16 @@ static void Cmd_various(void) case VARIOUS_CHECK_POLTERGEIST: { VARIOUS_ARGS(const u8 *failInstr); - if (gBattleMons[gActiveBattler].item == ITEM_NONE + if (gBattleMons[battler].item == ITEM_NONE || gFieldStatuses & STATUS_FIELD_MAGIC_ROOM - || GetBattlerAbility(gActiveBattler) == ABILITY_KLUTZ) + || GetBattlerAbility(battler) == ABILITY_KLUTZ) { gBattlescriptCurrInstr = cmd->failInstr; } else { - PREPARE_ITEM_BUFFER(gBattleTextBuff1, gBattleMons[gActiveBattler].item); - gLastUsedItem = gBattleMons[gActiveBattler].item; + PREPARE_ITEM_BUFFER(gBattleTextBuff1, gBattleMons[battler].item); + gLastUsedItem = gBattleMons[battler].item; gBattlescriptCurrInstr = cmd->nextInstr; } return; @@ -10609,14 +10531,14 @@ static void Cmd_various(void) case VARIOUS_TRY_NO_RETREAT: { VARIOUS_ARGS(const u8 *failInstr); - if (gDisableStructs[gActiveBattler].noRetreat) + if (gDisableStructs[battler].noRetreat) { gBattlescriptCurrInstr = cmd->failInstr; } else { - if (!(gBattleMons[gActiveBattler].status2 & STATUS2_ESCAPE_PREVENTION)) - gDisableStructs[gActiveBattler].noRetreat = TRUE; + if (!(gBattleMons[battler].status2 & STATUS2_ESCAPE_PREVENTION)) + gDisableStructs[battler].noRetreat = TRUE; gBattlescriptCurrInstr = cmd->nextInstr; } return; @@ -10624,13 +10546,13 @@ static void Cmd_various(void) case VARIOUS_TRY_TAR_SHOT: { VARIOUS_ARGS(const u8 *failInstr); - if (gDisableStructs[gActiveBattler].tarShot) + if (gDisableStructs[battler].tarShot) { gBattlescriptCurrInstr = cmd->failInstr; } else { - gDisableStructs[gActiveBattler].tarShot = TRUE; + gDisableStructs[battler].tarShot = TRUE; gBattlescriptCurrInstr = cmd->nextInstr; } return; @@ -10639,8 +10561,8 @@ static void Cmd_various(void) { VARIOUS_ARGS(const u8 *failInstr); // Tar Shot will fail if it's already been used on the target and its speed can't be lowered further - if (!gDisableStructs[gActiveBattler].tarShot - && CompareStat(gActiveBattler, STAT_SPEED, MAX_STAT_STAGE, CMP_LESS_THAN)) + if (!gDisableStructs[battler].tarShot + && CompareStat(battler, STAT_SPEED, MAX_STAT_STAGE, CMP_LESS_THAN)) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->failInstr; @@ -10649,7 +10571,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_CANT_FLING: { VARIOUS_ARGS(const u8 *jumpInstr); - if (!CanFling(gActiveBattler)) + if (!CanFling(battler)) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10659,43 +10581,43 @@ static void Cmd_various(void) { VARIOUS_ARGS(); // Check infatuation - if (gBattleMons[gActiveBattler].status2 & STATUS2_INFATUATION) + if (gBattleMons[battler].status2 & STATUS2_INFATUATION) { - gBattleMons[gActiveBattler].status2 &= ~(STATUS2_INFATUATION); + gBattleMons[battler].status2 &= ~(STATUS2_INFATUATION); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_INFATUATION; // STRINGID_TARGETGOTOVERINFATUATION StringCopy(gBattleTextBuff1, gStatusConditionString_LoveJpn); } // Check taunt - if (gDisableStructs[gActiveBattler].tauntTimer != 0) + if (gDisableStructs[battler].tauntTimer != 0) { - gDisableStructs[gActiveBattler].tauntTimer = 0; + gDisableStructs[battler].tauntTimer = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_TAUNT; PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_TAUNT); } // Check encore - if (gDisableStructs[gActiveBattler].encoreTimer != 0) + if (gDisableStructs[battler].encoreTimer != 0) { - gDisableStructs[gActiveBattler].encoredMove = 0; - gDisableStructs[gActiveBattler].encoreTimer = 0; + gDisableStructs[battler].encoredMove = 0; + gDisableStructs[battler].encoreTimer = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_ENCORE; // STRINGID_PKMNENCOREENDED } // Check torment - if (gBattleMons[gActiveBattler].status2 & STATUS2_TORMENT) + if (gBattleMons[battler].status2 & STATUS2_TORMENT) { - gBattleMons[gActiveBattler].status2 &= ~(STATUS2_TORMENT); + gBattleMons[battler].status2 &= ~(STATUS2_TORMENT); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_TORMENT; } // Check heal block - if (gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK) + if (gStatuses3[battler] & STATUS3_HEAL_BLOCK) { - gStatuses3[gActiveBattler] &= ~(STATUS3_HEAL_BLOCK); + gStatuses3[battler] &= ~(STATUS3_HEAL_BLOCK); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_HEALBLOCK; } // Check disable - if (gDisableStructs[gActiveBattler].disableTimer != 0) + if (gDisableStructs[battler].disableTimer != 0) { - gDisableStructs[gActiveBattler].disableTimer = 0; - gDisableStructs[gActiveBattler].disabledMove = 0; + gDisableStructs[battler].disableTimer = 0; + gDisableStructs[battler].disabledMove = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_DISABLE; } gBattlescriptCurrInstr = cmd->nextInstr; @@ -10704,10 +10626,10 @@ static void Cmd_various(void) case VARIOUS_TRY_RESET_NEGATIVE_STAT_STAGES: { VARIOUS_ARGS(); - gActiveBattler = gBattlerTarget; + battler = gBattlerTarget; for (i = 0; i < NUM_BATTLE_STATS; i++) - if (gBattleMons[gActiveBattler].statStages[i] < DEFAULT_STAT_STAGE) - gBattleMons[gActiveBattler].statStages[i] = DEFAULT_STAT_STAGE; + if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE) + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; gBattlescriptCurrInstr = cmd->nextInstr; return; } @@ -10732,25 +10654,25 @@ static void Cmd_various(void) case VARIOUS_SAVE_BATTLER_ITEM: { VARIOUS_ARGS(); - gBattleResources->battleHistory->heldItems[gActiveBattler] = gBattleMons[gActiveBattler].item; + gBattleResources->battleHistory->heldItems[battler] = gBattleMons[battler].item; break; } case VARIOUS_RESTORE_BATTLER_ITEM: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].item = gBattleResources->battleHistory->heldItems[gActiveBattler]; + gBattleMons[battler].item = gBattleResources->battleHistory->heldItems[battler]; break; } case VARIOUS_BATTLER_ITEM_TO_LAST_USED_ITEM: { VARIOUS_ARGS(); - gBattleMons[gActiveBattler].item = gLastUsedItem; + gBattleMons[battler].item = gLastUsedItem; break; } case VARIOUS_SET_BEAK_BLAST: { VARIOUS_ARGS(); - gProtectStructs[gActiveBattler].beakBlastCharge = TRUE; + gProtectStructs[battler].beakBlastCharge = TRUE; break; } case VARIOUS_SWAP_SIDE_STATUSES: @@ -10810,7 +10732,7 @@ static void Cmd_various(void) case VARIOUS_TEATIME_INVUL: { VARIOUS_ARGS(const u8 *jumpInstr); - if (ItemId_GetPocket(gBattleMons[gActiveBattler].item) == POCKET_BERRIES && !(gStatuses3[gBattlerTarget] & (STATUS3_SEMI_INVULNERABLE))) + if (ItemId_GetPocket(gBattleMons[battler].item) == POCKET_BERRIES && !(gStatuses3[gBattlerTarget] & (STATUS3_SEMI_INVULNERABLE))) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->jumpInstr; @@ -10846,13 +10768,13 @@ static void Cmd_various(void) case VARIOUS_TRY_WIND_RIDER_POWER: { VARIOUS_ARGS(const u8 *failInstr); - u16 ability = GetBattlerAbility(gActiveBattler); - if (GetBattlerSide(gActiveBattler) == GetBattlerSide(gBattlerAttacker) + u16 ability = GetBattlerAbility(battler); + if (GetBattlerSide(battler) == GetBattlerSide(gBattlerAttacker) && (ability == ABILITY_WIND_RIDER || ability == ABILITY_WIND_POWER)) { gLastUsedAbility = ability; - RecordAbilityBattle(gActiveBattler, gLastUsedAbility); - gBattlerAbility = gBattleScripting.battler = gActiveBattler; + RecordAbilityBattle(battler, gLastUsedAbility); + gBattlerAbility = gBattleScripting.battler = battler; gBattlescriptCurrInstr = cmd->nextInstr; } else @@ -10865,20 +10787,20 @@ static void Cmd_various(void) { VARIOUS_ARGS(); gBattlescriptCurrInstr = cmd->nextInstr; - AbilityBattleEffects(ABILITYEFFECT_ON_WEATHER, gActiveBattler, 0, 0, 0); + AbilityBattleEffects(ABILITYEFFECT_ON_WEATHER, battler, 0, 0, 0); return; } case VARIOUS_ACTIVATE_TERRAIN_CHANGE_ABILITIES: { VARIOUS_ARGS(); gBattlescriptCurrInstr = cmd->nextInstr; - AbilityBattleEffects(ABILITYEFFECT_ON_TERRAIN, gActiveBattler, 0, 0, 0); + AbilityBattleEffects(ABILITYEFFECT_ON_TERRAIN, battler, 0, 0, 0); return; } case VARIOUS_JUMP_IF_EMERGENCY_EXITED: { VARIOUS_ARGS(const u8 *jumpInstr); - if (gSpecialStatuses[gActiveBattler].emergencyExited) + if (gSpecialStatuses[battler].emergencyExited) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10888,9 +10810,9 @@ static void Cmd_various(void) { VARIOUS_ARGS(); if (gCurrentMove == MOVE_LUNAR_DANCE) - gBattleStruct->storedLunarDance |= gBitTable[gActiveBattler]; + gBattleStruct->storedLunarDance |= gBitTable[battler]; else - gBattleStruct->storedHealingWish |= gBitTable[gActiveBattler]; + gBattleStruct->storedHealingWish |= gBitTable[battler]; break; } case VARIOUS_HIT_SWITCH_TARGET_FAILED: @@ -10903,7 +10825,7 @@ static void Cmd_various(void) case VARIOUS_JUMP_IF_SHELL_TRAP: { VARIOUS_ARGS(const u8 *jumpInstr); - if (gProtectStructs[gActiveBattler].shellTrap) + if (gProtectStructs[battler].shellTrap) gBattlescriptCurrInstr = cmd->jumpInstr; else gBattlescriptCurrInstr = cmd->nextInstr; @@ -10928,7 +10850,7 @@ static void Cmd_various(void) struct Pokemon *party = GetSideParty(side); u16 hp = GetMonData(&party[gSelectedMonPartyId], MON_DATA_MAX_HP) / 2; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HP_BATTLE, gBitTable[gSelectedMonPartyId], sizeof(hp), &hp); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HP_BATTLE, gBitTable[gSelectedMonPartyId], sizeof(hp), &hp); MarkBattlerForControllerExec(gBattlerAttacker); PREPARE_SPECIES_BUFFER(gBattleTextBuff1, GetMonData(&party[gSelectedMonPartyId], MON_DATA_SPECIES)); @@ -10948,7 +10870,7 @@ static void Cmd_various(void) // Open party menu, wait to go to next instruction. else { - BtlController_EmitChoosePokemon(BUFFER_A, PARTY_ACTION_CHOOSE_FAINTED_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]); + BtlController_EmitChoosePokemon(gBattlerAttacker, BUFFER_A, PARTY_ACTION_CHOOSE_FAINTED_MON, PARTY_SIZE, ABILITY_NONE, gBattleStruct->battlerPartyOrders[gBattlerAttacker]); MarkBattlerForControllerExec(gBattlerAttacker); } return; @@ -10956,9 +10878,9 @@ static void Cmd_various(void) case VARIOUS_TRY_TRAINER_SLIDE_MSG_Z_MOVE: { VARIOUS_ARGS(); - if ((i = ShouldDoTrainerSlide(gActiveBattler, TRAINER_SLIDE_Z_MOVE))) + if ((i = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_Z_MOVE))) { - gBattleScripting.battler = gActiveBattler; + gBattleScripting.battler = battler; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = (i == 1 ? BattleScript_TrainerASlideMsgRet : BattleScript_TrainerBSlideMsgRet); return; @@ -10968,9 +10890,9 @@ static void Cmd_various(void) case VARIOUS_TRY_TRAINER_SLIDE_MSG_MEGA_EVOLUTION: { VARIOUS_ARGS(); - if ((i = ShouldDoTrainerSlide(gActiveBattler, TRAINER_SLIDE_MEGA_EVOLUTION))) + if ((i = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_MEGA_EVOLUTION))) { - gBattleScripting.battler = gActiveBattler; + gBattleScripting.battler = battler; BattleScriptPush(cmd->nextInstr); gBattlescriptCurrInstr = (i == 1 ? BattleScript_TrainerASlideMsgRet : BattleScript_TrainerBSlideMsgRet); return; @@ -11098,10 +11020,9 @@ static void Cmd_tryexplosion(void) return; } - gActiveBattler = gBattlerAttacker; - gBattleMoveDamage = gBattleMons[gActiveBattler].hp; - BtlController_EmitHealthBarUpdate(BUFFER_A, INSTANT_HP_BAR_DROP); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMoveDamage = gBattleMons[gBattlerAttacker].hp; + BtlController_EmitHealthBarUpdate(gBattlerAttacker, BUFFER_A, INSTANT_HP_BAR_DROP); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -11112,10 +11033,9 @@ static void Cmd_setatkhptozero(void) if (gBattleControllerExecFlags) return; - gActiveBattler = gBattlerAttacker; - gBattleMons[gActiveBattler].hp = 0; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].hp), &gBattleMons[gActiveBattler].hp); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMons[gBattlerAttacker].hp = 0; + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HP_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].hp), &gBattleMons[gBattlerAttacker].hp); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -11326,7 +11246,7 @@ static void Cmd_trysetrest(void) CMD_ARGS(const u8 *failInstr); const u8 *failInstr = cmd->failInstr; - gActiveBattler = gBattlerTarget = gBattlerAttacker; + gBattlerTarget = gBattlerAttacker; gBattleMoveDamage = gBattleMons[gBattlerTarget].maxHP * (-1); if (gBattleMons[gBattlerTarget].hp == gBattleMons[gBattlerTarget].maxHP) @@ -11349,8 +11269,8 @@ static void Cmd_trysetrest(void) gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_REST; gBattleMons[gBattlerTarget].status1 = STATUS1_SLEEP_TURN(3); - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].status1), &gBattleMons[gBattlerTarget].status1); + MarkBattlerForControllerExec(gBattlerTarget); gBattlescriptCurrInstr = cmd->nextInstr; } } @@ -12521,32 +12441,33 @@ static void Cmd_tryinfatuating(void) static void Cmd_updatestatusicon(void) { CMD_ARGS(u8 battler); + u32 battler; if (gBattleControllerExecFlags) return; if (cmd->battler != BS_ATTACKER_WITH_PARTNER) { - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - BtlController_EmitStatusIconUpdate(BUFFER_A, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2); - MarkBattlerForControllerExec(gActiveBattler); + battler = GetBattlerForBattleScript(cmd->battler); + BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } else { - gActiveBattler = gBattlerAttacker; - if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler])) + battler = gBattlerAttacker; + if (!(gAbsentBattlerFlags & gBitTable[battler])) { - BtlController_EmitStatusIconUpdate(BUFFER_A, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2); + MarkBattlerForControllerExec(battler); } if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) { - gActiveBattler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); - if (!(gAbsentBattlerFlags & gBitTable[gActiveBattler])) + battler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); + if (!(gAbsentBattlerFlags & gBitTable[battler])) { - BtlController_EmitStatusIconUpdate(BUFFER_A, gBattleMons[gActiveBattler].status1, gBattleMons[gActiveBattler].status2); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitStatusIconUpdate(battler, BUFFER_A, gBattleMons[battler].status1, gBattleMons[battler].status2); + MarkBattlerForControllerExec(battler); } } gBattlescriptCurrInstr = cmd->nextInstr; @@ -12632,9 +12553,8 @@ static void Cmd_transformdataexecution(void) gBattleMons[gBattlerAttacker].pp[i] = 5; } - gActiveBattler = gBattlerAttacker; - BtlController_EmitResetActionMoveSelection(BUFFER_A, RESET_MOVE_SELECTION); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitResetActionMoveSelection(gBattlerAttacker, BUFFER_A, RESET_MOVE_SELECTION); + MarkBattlerForControllerExec(gBattlerAttacker); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_TRANSFORMED; } } @@ -13011,7 +12931,6 @@ static void Cmd_copymovepermanently(void) gBattleMons[gBattlerAttacker].moves[gCurrMovePos] = gLastPrintedMoves[gBattlerTarget]; gBattleMons[gBattlerAttacker].pp[gCurrMovePos] = gBattleMoves[gLastPrintedMoves[gBattlerTarget]].pp; - gActiveBattler = gBattlerAttacker; for (i = 0; i < MAX_MON_MOVES; i++) { @@ -13020,8 +12939,8 @@ static void Cmd_copymovepermanently(void) } movePpData.ppBonuses = gBattleMons[gBattlerAttacker].ppBonuses; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_MOVES_PP_BATTLE, 0, sizeof(movePpData), &movePpData); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_MOVES_PP_BATTLE, 0, sizeof(movePpData), &movePpData); + MarkBattlerForControllerExec(gBattlerAttacker); PREPARE_MOVE_BUFFER(gBattleTextBuff1, gLastPrintedMoves[gBattlerTarget]) @@ -13191,14 +13110,13 @@ static void Cmd_tryspiteppreduce(void) PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff2, 1, ppToDeduct) gBattleMons[gBattlerTarget].pp[i] -= ppToDeduct; - gActiveBattler = gBattlerTarget; - // if (MOVE_IS_PERMANENT(gActiveBattler, i)), but backwards - if (!(gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[i]) - && !(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED)) + // if (MOVE_IS_PERMANENT(gBattlerTarget, i)), but backwards + if (!(gDisableStructs[gBattlerTarget].mimickedMoves & gBitTable[i]) + && !(gBattleMons[gBattlerTarget].status2 & STATUS2_TRANSFORMED)) { - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gActiveBattler].pp[i]), &gBattleMons[gActiveBattler].pp[i]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_PPMOVE1_BATTLE + i, 0, sizeof(gBattleMons[gBattlerTarget].pp[i]), &gBattleMons[gBattlerTarget].pp[i]); + MarkBattlerForControllerExec(gBattlerTarget); } gBattlescriptCurrInstr = cmd->nextInstr; @@ -13305,9 +13223,8 @@ static void Cmd_healpartystatus(void) if (toHeal) { - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, toHeal, sizeof(zero), &zero); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, toHeal, sizeof(zero), &zero); + MarkBattlerForControllerExec(gBattlerAttacker); } gBattlescriptCurrInstr = cmd->nextInstr; @@ -13982,10 +13899,9 @@ static void Cmd_trymemento(void) else { // Success, drop user's HP bar to 0 - gActiveBattler = gBattlerAttacker; - gBattleMoveDamage = gBattleMons[gActiveBattler].hp; - BtlController_EmitHealthBarUpdate(BUFFER_A, INSTANT_HP_BAR_DROP); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMoveDamage = gBattleMons[gBattlerAttacker].hp; + BtlController_EmitHealthBarUpdate(gBattlerAttacker, BUFFER_A, INSTANT_HP_BAR_DROP); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } } @@ -14048,9 +13964,8 @@ static void Cmd_cureifburnedparalysedorpoisoned(void) { gBattleMons[gBattlerAttacker].status1 = 0; gBattlescriptCurrInstr = cmd->nextInstr; - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].status1), &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].status1), &gBattleMons[gBattlerAttacker].status1); + MarkBattlerForControllerExec(gBattlerAttacker); } else { @@ -14205,12 +14120,10 @@ static void Cmd_tryswapitems(void) RecordItemEffectBattle(gBattlerAttacker, 0); RecordItemEffectBattle(gBattlerTarget, ItemId_GetHoldEffect(oldItemAtk)); - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(*newItemAtk), newItemAtk); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(*newItemAtk), newItemAtk); MarkBattlerForControllerExec(gBattlerAttacker); - gActiveBattler = gBattlerTarget; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item); + BtlController_EmitSetMonData(gBattlerTarget, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerTarget].item), &gBattleMons[gBattlerTarget].item); MarkBattlerForControllerExec(gBattlerTarget); gBattleStruct->choicedMove[gBattlerTarget] = MOVE_NONE; @@ -14636,35 +14549,35 @@ static void Cmd_switchoutabilities(void) { CMD_ARGS(u8 battler); - gActiveBattler = GetBattlerForBattleScript(cmd->battler); - if (gBattleMons[gActiveBattler].ability == ABILITY_NEUTRALIZING_GAS) + u32 battler = GetBattlerForBattleScript(cmd->battler); + if (gBattleMons[battler].ability == ABILITY_NEUTRALIZING_GAS) { - gBattleMons[gActiveBattler].ability = ABILITY_NONE; + gBattleMons[battler].ability = ABILITY_NONE; BattleScriptPush(gBattlescriptCurrInstr); gBattlescriptCurrInstr = BattleScript_NeutralizingGasExits; } else { - switch (GetBattlerAbility(gActiveBattler)) + switch (GetBattlerAbility(battler)) { case ABILITY_NATURAL_CURE: - gBattleMons[gActiveBattler].status1 = 0; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, - gBitTable[*(gBattleStruct->battlerPartyIndexes + gActiveBattler)], - sizeof(gBattleMons[gActiveBattler].status1), - &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + gBattleMons[battler].status1 = 0; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, + gBitTable[*(gBattleStruct->battlerPartyIndexes + battler)], + sizeof(gBattleMons[battler].status1), + &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); break; case ABILITY_REGENERATOR: - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 3; - gBattleMoveDamage += gBattleMons[gActiveBattler].hp; - if (gBattleMoveDamage > gBattleMons[gActiveBattler].maxHP) - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HP_BATTLE, - gBitTable[*(gBattleStruct->battlerPartyIndexes + gActiveBattler)], + gBattleMoveDamage = gBattleMons[battler].maxHP / 3; + gBattleMoveDamage += gBattleMons[battler].hp; + if (gBattleMoveDamage > gBattleMons[battler].maxHP) + gBattleMoveDamage = gBattleMons[battler].maxHP; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HP_BATTLE, + gBitTable[*(gBattleStruct->battlerPartyIndexes + battler)], sizeof(gBattleMoveDamage), &gBattleMoveDamage); - MarkBattlerForControllerExec(gActiveBattler); + MarkBattlerForControllerExec(battler); break; } @@ -14969,16 +14882,15 @@ static void Cmd_tryrecycleitem(void) u16 *usedHeldItem; - gActiveBattler = gBattlerAttacker; - usedHeldItem = &gBattleStruct->usedHeldItems[gBattlerPartyIndexes[gActiveBattler]][GetBattlerSide(gActiveBattler)]; - if (*usedHeldItem != ITEM_NONE && gBattleMons[gActiveBattler].item == ITEM_NONE) + usedHeldItem = &gBattleStruct->usedHeldItems[gBattlerPartyIndexes[gBattlerAttacker]][GetBattlerSide(gBattlerAttacker)]; + if (*usedHeldItem != ITEM_NONE && gBattleMons[gBattlerAttacker].item == ITEM_NONE) { gLastUsedItem = *usedHeldItem; *usedHeldItem = ITEM_NONE; - gBattleMons[gActiveBattler].item = gLastUsedItem; + gBattleMons[gBattlerAttacker].item = gLastUsedItem; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gActiveBattler].item), &gBattleMons[gActiveBattler].item); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, sizeof(gBattleMons[gBattlerAttacker].item), &gBattleMons[gBattlerAttacker].item); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -15134,19 +15046,18 @@ static void Cmd_handleballthrow(void) if (gBattleControllerExecFlags) return; - gActiveBattler = gBattlerAttacker; gBattlerTarget = GetCatchingBattler(); if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) { - BtlController_EmitBallThrowAnim(BUFFER_A, BALL_TRAINER_BLOCK); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_TRAINER_BLOCK); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = BattleScript_TrainerBallBlock; } else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) { - BtlController_EmitBallThrowAnim(BUFFER_A, BALL_3_SHAKES_SUCCESS); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_3_SHAKES_SUCCESS); + MarkBattlerForControllerExec(gBattlerAttacker); gBattlescriptCurrInstr = BattleScript_WallyBallThrow; } else @@ -15356,8 +15267,8 @@ static void Cmd_handleballthrow(void) if (odds > 254) // mon caught { - BtlController_EmitBallThrowAnim(BUFFER_A, BALL_3_SHAKES_SUCCESS); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, BALL_3_SHAKES_SUCCESS); + MarkBattlerForControllerExec(gBattlerAttacker); TryBattleFormChange(gBattlerTarget, FORM_CHANGE_END_BATTLE); gBattlescriptCurrInstr = BattleScript_SuccessBallThrow; SetMonData(&gEnemyParty[gBattlerPartyIndexes[gBattlerTarget]], MON_DATA_POKEBALL, &gLastUsedItem); @@ -15404,8 +15315,8 @@ static void Cmd_handleballthrow(void) for (shakes = 0; shakes < maxShakes && Random() < odds; shakes++); } - BtlController_EmitBallThrowAnim(BUFFER_A, shakes); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitBallThrowAnim(gBattlerAttacker, BUFFER_A, shakes); + MarkBattlerForControllerExec(gBattlerAttacker); if (shakes == maxShakes) // mon caught, copy of the code above { @@ -15727,9 +15638,9 @@ static void Cmd_trainerslideout(void) { CMD_ARGS(u8 position); - gActiveBattler = GetBattlerAtPosition(cmd->position); - BtlController_EmitTrainerSlideBack(BUFFER_A); - MarkBattlerForControllerExec(gActiveBattler); + u32 battler = GetBattlerAtPosition(cmd->position); + BtlController_EmitTrainerSlideBack(battler, BUFFER_A); + MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } diff --git a/src/battle_util.c b/src/battle_util.c index d98d48db43..486f9d6334 100644 --- a/src/battle_util.c +++ b/src/battle_util.c @@ -58,13 +58,13 @@ functions instead of at the top of the file with the other declarations. */ static bool32 TryRemoveScreens(u8 battler); -static bool32 IsUnnerveAbilityOnOpposingSide(u8 battlerId); +static bool32 IsUnnerveAbilityOnOpposingSide(u8 battler); static u8 GetFlingPowerFromItemId(u16 itemId); static void SetRandomMultiHitCounter(); -static u32 GetBattlerItemHoldEffectParam(u8 battlerId, u16 item); +static u32 GetBattlerItemHoldEffectParam(u8 battler, u16 item); static uq4_12_t GetInverseTypeMultiplier(uq4_12_t multiplier); -static uq4_12_t GetSupremeOverlordModifier(u8 battlerId); -static bool8 CanBeInfinitelyConfused(u8 battlerId); +static uq4_12_t GetSupremeOverlordModifier(u8 battler); +static bool8 CanBeInfinitelyConfused(u8 battler); extern const u8 *const gBattleScriptsForMoveEffects[]; extern const u8 *const gBattlescriptsForRunningByItem[]; @@ -257,7 +257,7 @@ bool32 IsAffectedByFollowMe(u32 battlerAtk, u32 defSide, u32 move) // Functions void HandleAction_UseMove(void) { - u32 i, side, moveType, var = 4; + u32 battler, i, side, moveType, var = 4; u16 moveTarget; gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber]; @@ -352,18 +352,18 @@ void HandleAction_UseMove(void) || (GetBattlerAbility(*(gBattleStruct->moveTarget + gBattlerAttacker)) != ABILITY_STORM_DRAIN && moveType == TYPE_WATER))) { side = GetBattlerSide(gBattlerAttacker); - for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++) + for (battler = 0; battler < gBattlersCount; battler++) { - if (side != GetBattlerSide(gActiveBattler) - && *(gBattleStruct->moveTarget + gBattlerAttacker) != gActiveBattler - && ((GetBattlerAbility(gActiveBattler) == ABILITY_LIGHTNING_ROD && moveType == TYPE_ELECTRIC) - || (GetBattlerAbility(gActiveBattler) == ABILITY_STORM_DRAIN && moveType == TYPE_WATER)) - && GetBattlerTurnOrderNum(gActiveBattler) < var + if (side != GetBattlerSide(battler) + && *(gBattleStruct->moveTarget + gBattlerAttacker) != battler + && ((GetBattlerAbility(battler) == ABILITY_LIGHTNING_ROD && moveType == TYPE_ELECTRIC) + || (GetBattlerAbility(battler) == ABILITY_STORM_DRAIN && moveType == TYPE_WATER)) + && GetBattlerTurnOrderNum(battler) < var && gBattleMoves[gCurrentMove].effect != EFFECT_SNIPE_SHOT && (GetBattlerAbility(gBattlerAttacker) != ABILITY_PROPELLER_TAIL || GetBattlerAbility(gBattlerAttacker) != ABILITY_STALWART)) { - var = GetBattlerTurnOrderNum(gActiveBattler); + var = GetBattlerTurnOrderNum(battler); } } if (var == 4) @@ -417,15 +417,15 @@ void HandleAction_UseMove(void) else { u16 battlerAbility; - gActiveBattler = gBattlerByTurnOrder[var]; - battlerAbility = GetBattlerAbility(gActiveBattler); + battler = gBattlerByTurnOrder[var]; + battlerAbility = GetBattlerAbility(battler); - RecordAbilityBattle(gActiveBattler, gBattleMons[gActiveBattler].ability); + RecordAbilityBattle(battler, gBattleMons[battler].ability); if (battlerAbility == ABILITY_LIGHTNING_ROD && gCurrentMove != MOVE_TEATIME) - gSpecialStatuses[gActiveBattler].lightningRodRedirected = TRUE; + gSpecialStatuses[battler].lightningRodRedirected = TRUE; else if (battlerAbility == ABILITY_STORM_DRAIN) - gSpecialStatuses[gActiveBattler].stormDrainRedirected = TRUE; - gBattlerTarget = gActiveBattler; + gSpecialStatuses[battler].stormDrainRedirected = TRUE; + gBattlerTarget = battler; } } else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE @@ -1232,9 +1232,8 @@ void PressurePPLose(u8 target, u8 attacker, u16 move) if (MOVE_IS_PERMANENT(attacker, moveIndex)) { - gActiveBattler = attacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + moveIndex, 0, 1, &gBattleMons[gActiveBattler].pp[moveIndex]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(attacker, BUFFER_A, REQUEST_PPMOVE1_BATTLE + moveIndex, 0, 1, &gBattleMons[attacker].pp[moveIndex]); + MarkBattlerForControllerExec(attacker); } } @@ -1264,9 +1263,8 @@ void PressurePPLoseOnUsingImprison(u8 attacker) if (imprisonPos != MAX_MON_MOVES && MOVE_IS_PERMANENT(attacker, imprisonPos)) { - gActiveBattler = attacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + imprisonPos, 0, 1, &gBattleMons[gActiveBattler].pp[imprisonPos]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(attacker, BUFFER_A, REQUEST_PPMOVE1_BATTLE + imprisonPos, 0, 1, &gBattleMons[attacker].pp[imprisonPos]); + MarkBattlerForControllerExec(attacker); } } @@ -1295,9 +1293,8 @@ void PressurePPLoseOnUsingPerishSong(u8 attacker) if (perishSongPos != MAX_MON_MOVES && MOVE_IS_PERMANENT(attacker, perishSongPos)) { - gActiveBattler = attacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_PPMOVE1_BATTLE + perishSongPos, 0, 1, &gBattleMons[gActiveBattler].pp[perishSongPos]); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(attacker, BUFFER_A, REQUEST_PPMOVE1_BATTLE + perishSongPos, 0, 1, &gBattleMons[attacker].pp[perishSongPos]); + MarkBattlerForControllerExec(attacker); } } @@ -1318,30 +1315,30 @@ static void MarkAllBattlersForControllerExec(void) } } -bool32 IsBattlerMarkedForControllerExec(u8 battlerId) +bool32 IsBattlerMarkedForControllerExec(u8 battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK) - return (gBattleControllerExecFlags & (gBitTable[battlerId] << 0x1C)) != 0; + return (gBattleControllerExecFlags & (gBitTable[battler] << 0x1C)) != 0; else - return (gBattleControllerExecFlags & (gBitTable[battlerId])) != 0; + return (gBattleControllerExecFlags & (gBitTable[battler])) != 0; } -void MarkBattlerForControllerExec(u8 battlerId) +void MarkBattlerForControllerExec(u8 battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK) - gBattleControllerExecFlags |= gBitTable[battlerId] << (32 - MAX_BATTLERS_COUNT); + gBattleControllerExecFlags |= gBitTable[battler] << (32 - MAX_BATTLERS_COUNT); else - gBattleControllerExecFlags |= gBitTable[battlerId]; + gBattleControllerExecFlags |= gBitTable[battler]; } -void MarkBattlerReceivedLinkData(u8 battlerId) +void MarkBattlerReceivedLinkData(u8 battler) { s32 i; for (i = 0; i < GetLinkPlayerCount(); i++) - gBattleControllerExecFlags |= gBitTable[battlerId] << (i << 2); + gBattleControllerExecFlags |= gBitTable[battler] << (i << 2); - gBattleControllerExecFlags &= ~((1 << 28) << battlerId); + gBattleControllerExecFlags &= ~((1 << 28) << battler); } void CancelMultiTurnMoves(u8 battler) @@ -1496,9 +1493,8 @@ void PrepareStringBattle(u16 stringId, u8 battler) && gBattleStruct->trainerSlidePlayerMonUnaffectedMsgState != 2) gBattleStruct->trainerSlidePlayerMonUnaffectedMsgState = 1; - gActiveBattler = battler; - BtlController_EmitPrintString(BUFFER_A, stringId); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitPrintString(battler, BUFFER_A, stringId); + MarkBattlerForControllerExec(battler); } void ResetSentPokesToOpponentValue(void) @@ -1831,63 +1827,63 @@ u8 TrySetCantSelectMoveBattleScript(void) return limitations; } -u8 CheckMoveLimitations(u8 battlerId, u8 unusableMoves, u16 check) +u8 CheckMoveLimitations(u8 battler, u8 unusableMoves, u16 check) { - u8 holdEffect = GetBattlerHoldEffect(battlerId, TRUE); - u16 *choicedMove = &gBattleStruct->choicedMove[battlerId]; + u8 holdEffect = GetBattlerHoldEffect(battler, TRUE); + u16 *choicedMove = &gBattleStruct->choicedMove[battler]; s32 i; - gPotentialItemEffectBattler = battlerId; + gPotentialItemEffectBattler = battler; for (i = 0; i < MAX_MON_MOVES; i++) { // No move - if (check & MOVE_LIMITATION_ZEROMOVE && gBattleMons[battlerId].moves[i] == MOVE_NONE) + if (check & MOVE_LIMITATION_ZEROMOVE && gBattleMons[battler].moves[i] == MOVE_NONE) unusableMoves |= gBitTable[i]; // No PP - else if (check & MOVE_LIMITATION_PP && gBattleMons[battlerId].pp[i] == 0) + else if (check & MOVE_LIMITATION_PP && gBattleMons[battler].pp[i] == 0) unusableMoves |= gBitTable[i]; // Placeholder - else if (check & MOVE_LIMITATION_PLACEHOLDER && gBattleMoves[gBattleMons[battlerId].moves[i]].effect == EFFECT_PLACEHOLDER) + else if (check & MOVE_LIMITATION_PLACEHOLDER && gBattleMoves[gBattleMons[battler].moves[i]].effect == EFFECT_PLACEHOLDER) unusableMoves |= gBitTable[i]; // Disable - else if (check & MOVE_LIMITATION_DISABLED && gBattleMons[battlerId].moves[i] == gDisableStructs[battlerId].disabledMove) + else if (check & MOVE_LIMITATION_DISABLED && gBattleMons[battler].moves[i] == gDisableStructs[battler].disabledMove) unusableMoves |= gBitTable[i]; // Torment - else if (check & MOVE_LIMITATION_TORMENTED && gBattleMons[battlerId].moves[i] == gLastMoves[battlerId] && gBattleMons[battlerId].status2 & STATUS2_TORMENT) + else if (check & MOVE_LIMITATION_TORMENTED && gBattleMons[battler].moves[i] == gLastMoves[battler] && gBattleMons[battler].status2 & STATUS2_TORMENT) unusableMoves |= gBitTable[i]; // Taunt - else if (check & MOVE_LIMITATION_TAUNT && gDisableStructs[battlerId].tauntTimer && IS_MOVE_STATUS(gBattleMons[battlerId].moves[i])) + else if (check & MOVE_LIMITATION_TAUNT && gDisableStructs[battler].tauntTimer && IS_MOVE_STATUS(gBattleMons[battler].moves[i])) unusableMoves |= gBitTable[i]; // Imprison - else if (check & MOVE_LIMITATION_IMPRISON && GetImprisonedMovesCount(battlerId, gBattleMons[battlerId].moves[i])) + else if (check & MOVE_LIMITATION_IMPRISON && GetImprisonedMovesCount(battler, gBattleMons[battler].moves[i])) unusableMoves |= gBitTable[i]; // Encore - else if (check & MOVE_LIMITATION_ENCORE && gDisableStructs[battlerId].encoreTimer && gDisableStructs[battlerId].encoredMove != gBattleMons[battlerId].moves[i]) + else if (check & MOVE_LIMITATION_ENCORE && gDisableStructs[battler].encoreTimer && gDisableStructs[battler].encoredMove != gBattleMons[battler].moves[i]) unusableMoves |= gBitTable[i]; // Choice Items - else if (check & MOVE_LIMITATION_CHOICE_ITEM && HOLD_EFFECT_CHOICE(holdEffect) && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battlerId].moves[i]) + else if (check & MOVE_LIMITATION_CHOICE_ITEM && HOLD_EFFECT_CHOICE(holdEffect) && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battler].moves[i]) unusableMoves |= gBitTable[i]; // Assault Vest - else if (check & MOVE_LIMITATION_ASSAULT_VEST && holdEffect == HOLD_EFFECT_ASSAULT_VEST && IS_MOVE_STATUS(gBattleMons[battlerId].moves[i]) && gBattleMons[battlerId].moves[i] != MOVE_ME_FIRST) + else if (check & MOVE_LIMITATION_ASSAULT_VEST && holdEffect == HOLD_EFFECT_ASSAULT_VEST && IS_MOVE_STATUS(gBattleMons[battler].moves[i]) && gBattleMons[battler].moves[i] != MOVE_ME_FIRST) unusableMoves |= gBitTable[i]; // Gravity - else if (check & MOVE_LIMITATION_GRAVITY && IsGravityPreventingMove(gBattleMons[battlerId].moves[i])) + else if (check & MOVE_LIMITATION_GRAVITY && IsGravityPreventingMove(gBattleMons[battler].moves[i])) unusableMoves |= gBitTable[i]; // Heal Block - else if (check & MOVE_LIMITATION_HEAL_BLOCK && IsHealBlockPreventingMove(battlerId, gBattleMons[battlerId].moves[i])) + else if (check & MOVE_LIMITATION_HEAL_BLOCK && IsHealBlockPreventingMove(battler, gBattleMons[battler].moves[i])) unusableMoves |= gBitTable[i]; // Belch - else if (check & MOVE_LIMITATION_BELCH && IsBelchPreventingMove(battlerId, gBattleMons[battlerId].moves[i])) + else if (check & MOVE_LIMITATION_BELCH && IsBelchPreventingMove(battler, gBattleMons[battler].moves[i])) unusableMoves |= gBitTable[i]; // Throat Chop - else if (check & MOVE_LIMITATION_THROAT_CHOP && gDisableStructs[battlerId].throatChopTimer && gBattleMoves[gBattleMons[battlerId].moves[i]].soundMove) + else if (check & MOVE_LIMITATION_THROAT_CHOP && gDisableStructs[battler].throatChopTimer && gBattleMoves[gBattleMons[battler].moves[i]].soundMove) unusableMoves |= gBitTable[i]; // Stuff Cheeks - else if (check & MOVE_LIMITATION_STUFF_CHEEKS && gBattleMons[battlerId].moves[i] == MOVE_STUFF_CHEEKS && ItemId_GetPocket(gBattleMons[battlerId].item) != POCKET_BERRIES) + else if (check & MOVE_LIMITATION_STUFF_CHEEKS && gBattleMons[battler].moves[i] == MOVE_STUFF_CHEEKS && ItemId_GetPocket(gBattleMons[battler].item) != POCKET_BERRIES) unusableMoves |= gBitTable[i]; // Gorilla Tactics - else if (check & MOVE_LIMITATION_CHOICE_ITEM && GetBattlerAbility(battlerId) == ABILITY_GORILLA_TACTICS && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battlerId].moves[i]) + else if (check & MOVE_LIMITATION_CHOICE_ITEM && GetBattlerAbility(battler) == ABILITY_GORILLA_TACTICS && *choicedMove != MOVE_NONE && *choicedMove != MOVE_UNAVAILABLE && *choicedMove != gBattleMons[battler].moves[i]) unusableMoves |= gBitTable[i]; } return unusableMoves; @@ -1912,11 +1908,11 @@ bool8 AreAllMovesUnusable(void) } #undef ALL_MOVES_MASK -u8 GetImprisonedMovesCount(u8 battlerId, u16 move) +u8 GetImprisonedMovesCount(u8 battler, u16 move) { s32 i; u8 imprisonedMoves = 0; - u8 battlerSide = GetBattlerSide(battlerId); + u8 battlerSide = GetBattlerSide(battler); for (i = 0; i < gBattlersCount; i++) { @@ -1936,11 +1932,11 @@ u8 GetImprisonedMovesCount(u8 battlerId, u16 move) return imprisonedMoves; } -u32 GetBattlerFriendshipScore(u8 battlerId) +u32 GetBattlerFriendshipScore(u8 battler) { - u8 side = GetBattlerSide(battlerId); + u8 side = GetBattlerSide(battler); struct Pokemon *party = GetSideParty(side); - u16 species = GetMonData(&party[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + u16 species = GetMonData(&party[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES); if (side != B_SIDE_PLAYER) return FRIENDSHIP_NONE; @@ -1952,7 +1948,7 @@ u32 GetBattlerFriendshipScore(u8 battlerId) | BATTLE_TYPE_SECRET_BASE))) return FRIENDSHIP_NONE; - return GetMonFriendshipScore(&party[gBattlerPartyIndexes[battlerId]]); + return GetMonFriendshipScore(&party[gBattlerPartyIndexes[battler]]); } static void TryToRevertMimicry(void) @@ -2545,7 +2541,7 @@ s32 GetDrainedBigRootHp(u32 battler, s32 hp) #define MAGIC_GUARD_CHECK \ if (ability == ABILITY_MAGIC_GUARD) \ {\ - RecordAbilityBattle(gActiveBattler, ability);\ + RecordAbilityBattle(battler, ability);\ gBattleStruct->turnEffectsTracker++;\ break;\ } @@ -2553,74 +2549,74 @@ if (ability == ABILITY_MAGIC_GUARD) \ u8 DoBattlerEndTurnEffects(void) { - u32 ability, i, effect = 0; + u32 battler, ability, i, effect = 0; gHitMarker |= (HITMARKER_GRUDGE | HITMARKER_SKIP_DMG_TRACK); while (gBattleStruct->turnEffectsBattlerId < gBattlersCount && gBattleStruct->turnEffectsTracker <= ENDTURN_BATTLER_COUNT) { - gActiveBattler = gBattlerAttacker = gBattlerByTurnOrder[gBattleStruct->turnEffectsBattlerId]; - if (gAbsentBattlerFlags & gBitTable[gActiveBattler]) + battler = gBattlerAttacker = gBattlerByTurnOrder[gBattleStruct->turnEffectsBattlerId]; + if (gAbsentBattlerFlags & gBitTable[battler]) { gBattleStruct->turnEffectsBattlerId++; continue; } - ability = GetBattlerAbility(gActiveBattler); + ability = GetBattlerAbility(battler); switch (gBattleStruct->turnEffectsTracker) { case ENDTURN_INGRAIN: // ingrain - if ((gStatuses3[gActiveBattler] & STATUS3_ROOTED) - && !BATTLER_MAX_HP(gActiveBattler) - && !(gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK) - && gBattleMons[gActiveBattler].hp != 0) + if ((gStatuses3[battler] & STATUS3_ROOTED) + && !BATTLER_MAX_HP(battler) + && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK) + && gBattleMons[battler].hp != 0) { - gBattleMoveDamage = GetDrainedBigRootHp(gActiveBattler, gBattleMons[gActiveBattler].maxHP / 16); + gBattleMoveDamage = GetDrainedBigRootHp(battler, gBattleMons[battler].maxHP / 16); BattleScriptExecute(BattleScript_IngrainTurnHeal); effect++; } gBattleStruct->turnEffectsTracker++; break; case ENDTURN_AQUA_RING: // aqua ring - if ((gStatuses3[gActiveBattler] & STATUS3_AQUA_RING) - && !BATTLER_MAX_HP(gActiveBattler) - && !(gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK) - && gBattleMons[gActiveBattler].hp != 0) + if ((gStatuses3[battler] & STATUS3_AQUA_RING) + && !BATTLER_MAX_HP(battler) + && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK) + && gBattleMons[battler].hp != 0) { - gBattleMoveDamage = GetDrainedBigRootHp(gActiveBattler, gBattleMons[gActiveBattler].maxHP / 16); + gBattleMoveDamage = GetDrainedBigRootHp(battler, gBattleMons[battler].maxHP / 16); BattleScriptExecute(BattleScript_AquaRingHeal); effect++; } gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ABILITIES: // end turn abilities - if (AbilityBattleEffects(ABILITYEFFECT_ENDTURN, gActiveBattler, 0, 0, 0)) + if (AbilityBattleEffects(ABILITYEFFECT_ENDTURN, battler, 0, 0, 0)) effect++; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ITEMS1: // item effects - if (ItemBattleEffects(ITEMEFFECT_NORMAL, gActiveBattler, FALSE)) + if (ItemBattleEffects(ITEMEFFECT_NORMAL, battler, FALSE)) effect++; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ITEMS2: // item effects again - if (ItemBattleEffects(ITEMEFFECT_NORMAL, gActiveBattler, TRUE)) + if (ItemBattleEffects(ITEMEFFECT_NORMAL, battler, TRUE)) effect++; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ORBS: - if (IsBattlerAlive(gActiveBattler) && ItemBattleEffects(ITEMEFFECT_ORBS, gActiveBattler, FALSE)) + if (IsBattlerAlive(battler) && ItemBattleEffects(ITEMEFFECT_ORBS, battler, FALSE)) effect++; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_LEECH_SEED: // leech seed - if ((gStatuses3[gActiveBattler] & STATUS3_LEECHSEED) - && gBattleMons[gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BATTLER].hp != 0 - && gBattleMons[gActiveBattler].hp != 0) + if ((gStatuses3[battler] & STATUS3_LEECHSEED) + && gBattleMons[gStatuses3[battler] & STATUS3_LEECHSEED_BATTLER].hp != 0 + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; - gBattlerTarget = gStatuses3[gActiveBattler] & STATUS3_LEECHSEED_BATTLER; // Notice gBattlerTarget is actually the HP receiver. - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattlerTarget = gStatuses3[battler] & STATUS3_LEECHSEED_BATTLER; // Notice gBattlerTarget is actually the HP receiver. + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleScripting.animArg1 = gBattlerTarget; @@ -2631,16 +2627,16 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_POISON: // poison - if ((gBattleMons[gActiveBattler].status1 & STATUS1_POISON) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status1 & STATUS1_POISON) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; if (ability == ABILITY_POISON_HEAL) { - if (!BATTLER_MAX_HP(gActiveBattler) && !(gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK)) + if (!BATTLER_MAX_HP(battler) && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK)) { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; @@ -2650,7 +2646,7 @@ u8 DoBattlerEndTurnEffects(void) } else { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; BattleScriptExecute(BattleScript_PoisonTurnDmg); @@ -2660,16 +2656,16 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_BAD_POISON: // toxic poison - if ((gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_POISON) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status1 & STATUS1_TOXIC_POISON) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; if (ability == ABILITY_POISON_HEAL) { - if (!BATTLER_MAX_HP(gActiveBattler) && !(gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK)) + if (!BATTLER_MAX_HP(battler) && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK)) { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; @@ -2679,12 +2675,12 @@ u8 DoBattlerEndTurnEffects(void) } else { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; - if ((gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_COUNTER) != STATUS1_TOXIC_TURN(15)) // not 16 turns - gBattleMons[gActiveBattler].status1 += STATUS1_TOXIC_TURN(1); - gBattleMoveDamage *= (gBattleMons[gActiveBattler].status1 & STATUS1_TOXIC_COUNTER) >> 8; + if ((gBattleMons[battler].status1 & STATUS1_TOXIC_COUNTER) != STATUS1_TOXIC_TURN(15)) // not 16 turns + gBattleMons[battler].status1 += STATUS1_TOXIC_TURN(1); + gBattleMoveDamage *= (gBattleMons[battler].status1 & STATUS1_TOXIC_COUNTER) >> 8; BattleScriptExecute(BattleScript_PoisonTurnDmg); effect++; } @@ -2692,19 +2688,19 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_BURN: // burn - if ((gBattleMons[gActiveBattler].status1 & STATUS1_BURN) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status1 & STATUS1_BURN) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; #if B_BURN_DAMAGE >= GEN_7 - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; #else - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; #endif if (ability == ABILITY_HEATPROOF) { if (gBattleMoveDamage > (gBattleMoveDamage / 2) + 1) // Record ability if the burn takes less damage than it normally would. - RecordAbilityBattle(gActiveBattler, ABILITY_HEATPROOF); + RecordAbilityBattle(battler, ABILITY_HEATPROOF); gBattleMoveDamage /= 2; } if (gBattleMoveDamage == 0) @@ -2715,14 +2711,14 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_FROSTBITE: // burn - if ((gBattleMons[gActiveBattler].status1 & STATUS1_FROSTBITE) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status1 & STATUS1_FROSTBITE) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; #if B_BURN_DAMAGE >= GEN_7 - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; #else - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; #endif if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; @@ -2732,15 +2728,15 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_NIGHTMARES: // spooky nightmares - if ((gBattleMons[gActiveBattler].status2 & STATUS2_NIGHTMARE) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status2 & STATUS2_NIGHTMARE) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; // R/S does not perform this sleep check, which causes the nightmare effect to // persist even after the affected Pokemon has been awakened by Shed Skin. - if (gBattleMons[gActiveBattler].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 4; + gBattleMoveDamage = gBattleMons[battler].maxHP / 4; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; BattleScriptExecute(BattleScript_NightmareTurnDmg); @@ -2748,17 +2744,17 @@ u8 DoBattlerEndTurnEffects(void) } else { - gBattleMons[gActiveBattler].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; } } gBattleStruct->turnEffectsTracker++; break; case ENDTURN_CURSE: // curse - if ((gBattleMons[gActiveBattler].status2 & STATUS2_CURSED) - && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status2 & STATUS2_CURSED) + && gBattleMons[battler].hp != 0) { MAGIC_GUARD_CHECK; - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 4; + gBattleMoveDamage = gBattleMons[battler].maxHP / 4; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; BattleScriptExecute(BattleScript_CurseTurnDmg); @@ -2767,25 +2763,25 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_WRAP: // wrap - if ((gBattleMons[gActiveBattler].status2 & STATUS2_WRAPPED) && gBattleMons[gActiveBattler].hp != 0) + if ((gBattleMons[battler].status2 & STATUS2_WRAPPED) && gBattleMons[battler].hp != 0) { - if (--gDisableStructs[gActiveBattler].wrapTurns != 0) // damaged by wrap + if (--gDisableStructs[battler].wrapTurns != 0) // damaged by wrap { MAGIC_GUARD_CHECK; - gBattleScripting.animArg1 = gBattleStruct->wrappedMove[gActiveBattler]; - gBattleScripting.animArg2 = gBattleStruct->wrappedMove[gActiveBattler] >> 8; - PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleStruct->wrappedMove[gActiveBattler]); + gBattleScripting.animArg1 = gBattleStruct->wrappedMove[battler]; + gBattleScripting.animArg2 = gBattleStruct->wrappedMove[battler] >> 8; + PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleStruct->wrappedMove[battler]); gBattlescriptCurrInstr = BattleScript_WrapTurnDmg; - if (GetBattlerHoldEffect(gBattleStruct->wrappedBy[gActiveBattler], TRUE) == HOLD_EFFECT_BINDING_BAND) + if (GetBattlerHoldEffect(gBattleStruct->wrappedBy[battler], TRUE) == HOLD_EFFECT_BINDING_BAND) #if B_BINDING_DAMAGE >= GEN_6 - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 6; + gBattleMoveDamage = gBattleMons[battler].maxHP / 6; else - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; #else - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; else - gBattleMoveDamage = gBattleMons[gActiveBattler].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; #endif if (gBattleMoveDamage == 0) @@ -2793,8 +2789,8 @@ u8 DoBattlerEndTurnEffects(void) } else // broke free { - gBattleMons[gActiveBattler].status2 &= ~STATUS2_WRAPPED; - PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleStruct->wrappedMove[gActiveBattler]); + gBattleMons[battler].status2 &= ~STATUS2_WRAPPED; + PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleStruct->wrappedMove[battler]); gBattlescriptCurrInstr = BattleScript_WrapEnds; } BattleScriptExecute(gBattlescriptCurrInstr); @@ -2804,14 +2800,14 @@ u8 DoBattlerEndTurnEffects(void) break; case ENDTURN_OCTOLOCK: { - u16 battlerAbility = GetBattlerAbility(gActiveBattler); - if (gDisableStructs[gActiveBattler].octolock - && !(GetBattlerHoldEffect(gActiveBattler, TRUE) == HOLD_EFFECT_CLEAR_AMULET + u16 battlerAbility = GetBattlerAbility(battler); + if (gDisableStructs[battler].octolock + && !(GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_CLEAR_AMULET || battlerAbility == ABILITY_CLEAR_BODY || battlerAbility == ABILITY_FULL_METAL_BODY || battlerAbility == ABILITY_WHITE_SMOKE)) { - gBattlerTarget = gActiveBattler; + gBattlerTarget = battler; BattleScriptExecute(BattleScript_OctolockEndTurn); effect++; } @@ -2819,7 +2815,7 @@ u8 DoBattlerEndTurnEffects(void) } break; case ENDTURN_UPROAR: // uproar - if (gBattleMons[gActiveBattler].status2 & STATUS2_UPROAR) + if (gBattleMons[battler].status2 & STATUS2_UPROAR) { for (gBattlerAttacker = 0; gBattlerAttacker < gBattlersCount; gBattlerAttacker++) { @@ -2830,9 +2826,8 @@ u8 DoBattlerEndTurnEffects(void) gBattleMons[gBattlerAttacker].status2 &= ~STATUS2_NIGHTMARE; gBattleCommunication[MULTISTRING_CHOOSER] = 1; BattleScriptExecute(BattleScript_MonWokeUpInUproar); - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1); + MarkBattlerForControllerExec(gBattlerAttacker); break; } } @@ -2843,22 +2838,22 @@ u8 DoBattlerEndTurnEffects(void) } else { - gBattlerAttacker = gActiveBattler; - gBattleMons[gActiveBattler].status2 -= STATUS2_UPROAR_TURN(1); // uproar timer goes down - if (WasUnableToUseMove(gActiveBattler)) + gBattlerAttacker = battler; + gBattleMons[battler].status2 -= STATUS2_UPROAR_TURN(1); // uproar timer goes down + if (WasUnableToUseMove(battler)) { - CancelMultiTurnMoves(gActiveBattler); + CancelMultiTurnMoves(battler); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_UPROAR_ENDS; } - else if (gBattleMons[gActiveBattler].status2 & STATUS2_UPROAR) + else if (gBattleMons[battler].status2 & STATUS2_UPROAR) { gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_UPROAR_CONTINUES; - gBattleMons[gActiveBattler].status2 |= STATUS2_MULTIPLETURNS; + gBattleMons[battler].status2 |= STATUS2_MULTIPLETURNS; } else { gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_UPROAR_ENDS; - CancelMultiTurnMoves(gActiveBattler); + CancelMultiTurnMoves(battler); } BattleScriptExecute(BattleScript_PrintUproarOverTurns); effect = 1; @@ -2869,20 +2864,20 @@ u8 DoBattlerEndTurnEffects(void) break; case ENDTURN_THRASH: // thrash // Don't decrement STATUS2_LOCK_CONFUSE if the target is held by Sky Drop - if (gBattleMons[gActiveBattler].status2 & STATUS2_LOCK_CONFUSE && !(gStatuses3[gActiveBattler] & STATUS3_SKY_DROPPED)) + if (gBattleMons[battler].status2 & STATUS2_LOCK_CONFUSE && !(gStatuses3[battler] & STATUS3_SKY_DROPPED)) { - gBattleMons[gActiveBattler].status2 -= STATUS2_LOCK_CONFUSE_TURN(1); - if (WasUnableToUseMove(gActiveBattler)) - CancelMultiTurnMoves(gActiveBattler); - else if (!(gBattleMons[gActiveBattler].status2 & STATUS2_LOCK_CONFUSE) - && (gBattleMons[gActiveBattler].status2 & STATUS2_MULTIPLETURNS)) + gBattleMons[battler].status2 -= STATUS2_LOCK_CONFUSE_TURN(1); + if (WasUnableToUseMove(battler)) + CancelMultiTurnMoves(battler); + else if (!(gBattleMons[battler].status2 & STATUS2_LOCK_CONFUSE) + && (gBattleMons[battler].status2 & STATUS2_MULTIPLETURNS)) { - gBattleMons[gActiveBattler].status2 &= ~STATUS2_MULTIPLETURNS; - if (!(gBattleMons[gActiveBattler].status2 & STATUS2_CONFUSION)) + gBattleMons[battler].status2 &= ~STATUS2_MULTIPLETURNS; + if (!(gBattleMons[battler].status2 & STATUS2_CONFUSION)) { gBattleScripting.moveEffect = MOVE_EFFECT_CONFUSION | MOVE_EFFECT_AFFECTS_USER; SetMoveEffect(TRUE, 0); - if (gBattleMons[gActiveBattler].status2 & STATUS2_CONFUSION) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION) BattleScriptExecute(BattleScript_ThrashConfuses); effect++; } @@ -2891,25 +2886,25 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_FLINCH: // reset flinch - gBattleMons[gActiveBattler].status2 &= ~STATUS2_FLINCHED; + gBattleMons[battler].status2 &= ~STATUS2_FLINCHED; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_DISABLE: // disable - if (gDisableStructs[gActiveBattler].disableTimer != 0) + if (gDisableStructs[battler].disableTimer != 0) { for (i = 0; i < MAX_MON_MOVES; i++) { - if (gDisableStructs[gActiveBattler].disabledMove == gBattleMons[gActiveBattler].moves[i]) + if (gDisableStructs[battler].disabledMove == gBattleMons[battler].moves[i]) break; } if (i == MAX_MON_MOVES) // pokemon does not have the disabled move anymore { - gDisableStructs[gActiveBattler].disabledMove = 0; - gDisableStructs[gActiveBattler].disableTimer = 0; + gDisableStructs[battler].disabledMove = 0; + gDisableStructs[battler].disableTimer = 0; } - else if (--gDisableStructs[gActiveBattler].disableTimer == 0) // disable ends + else if (--gDisableStructs[battler].disableTimer == 0) // disable ends { - gDisableStructs[gActiveBattler].disabledMove = 0; + gDisableStructs[battler].disabledMove = 0; BattleScriptExecute(BattleScript_DisabledNoMore); effect++; } @@ -2917,18 +2912,18 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ENCORE: // encore - if (gDisableStructs[gActiveBattler].encoreTimer != 0) + if (gDisableStructs[battler].encoreTimer != 0) { - if (gBattleMons[gActiveBattler].moves[gDisableStructs[gActiveBattler].encoredMovePos] != gDisableStructs[gActiveBattler].encoredMove) // pokemon does not have the encored move anymore + if (gBattleMons[battler].moves[gDisableStructs[battler].encoredMovePos] != gDisableStructs[battler].encoredMove) // pokemon does not have the encored move anymore { - gDisableStructs[gActiveBattler].encoredMove = 0; - gDisableStructs[gActiveBattler].encoreTimer = 0; + gDisableStructs[battler].encoredMove = 0; + gDisableStructs[battler].encoreTimer = 0; } - else if (--gDisableStructs[gActiveBattler].encoreTimer == 0 - || gBattleMons[gActiveBattler].pp[gDisableStructs[gActiveBattler].encoredMovePos] == 0) + else if (--gDisableStructs[battler].encoreTimer == 0 + || gBattleMons[battler].pp[gDisableStructs[battler].encoredMovePos] == 0) { - gDisableStructs[gActiveBattler].encoredMove = 0; - gDisableStructs[gActiveBattler].encoreTimer = 0; + gDisableStructs[battler].encoredMove = 0; + gDisableStructs[battler].encoreTimer = 0; BattleScriptExecute(BattleScript_EncoredNoMore); effect++; } @@ -2936,17 +2931,17 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_LOCK_ON: // lock-on decrement - if (gStatuses3[gActiveBattler] & STATUS3_ALWAYS_HITS) - gStatuses3[gActiveBattler] -= STATUS3_ALWAYS_HITS_TURN(1); + if (gStatuses3[battler] & STATUS3_ALWAYS_HITS) + gStatuses3[battler] -= STATUS3_ALWAYS_HITS_TURN(1); gBattleStruct->turnEffectsTracker++; break; case ENDTURN_CHARGE: // charge - if (gDisableStructs[gActiveBattler].chargeTimer && --gDisableStructs[gActiveBattler].chargeTimer == 0) - gStatuses3[gActiveBattler] &= ~STATUS3_CHARGED_UP; + if (gDisableStructs[battler].chargeTimer && --gDisableStructs[battler].chargeTimer == 0) + gStatuses3[battler] &= ~STATUS3_CHARGED_UP; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_TAUNT: // taunt - if (gDisableStructs[gActiveBattler].tauntTimer && --gDisableStructs[gActiveBattler].tauntTimer == 0) + if (gDisableStructs[battler].tauntTimer && --gDisableStructs[battler].tauntTimer == 0) { BattleScriptExecute(BattleScript_BufferEndTurn); PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_TAUNT); @@ -2955,23 +2950,23 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_YAWN: // yawn - if (gStatuses3[gActiveBattler] & STATUS3_YAWN) + if (gStatuses3[battler] & STATUS3_YAWN) { - u16 battlerAbility = GetBattlerAbility(gActiveBattler); - gStatuses3[gActiveBattler] -= STATUS3_YAWN_TURN(1); - if (!(gStatuses3[gActiveBattler] & STATUS3_YAWN) && !(gBattleMons[gActiveBattler].status1 & STATUS1_ANY) + u16 battlerAbility = GetBattlerAbility(battler); + gStatuses3[battler] -= STATUS3_YAWN_TURN(1); + if (!(gStatuses3[battler] & STATUS3_YAWN) && !(gBattleMons[battler].status1 & STATUS1_ANY) && battlerAbility != ABILITY_VITAL_SPIRIT - && battlerAbility != ABILITY_INSOMNIA && !UproarWakeUpCheck(gActiveBattler) - && !IsLeafGuardProtected(gActiveBattler)) + && battlerAbility != ABILITY_INSOMNIA && !UproarWakeUpCheck(battler) + && !IsLeafGuardProtected(battler)) { - CancelMultiTurnMoves(gActiveBattler); - gEffectBattler = gActiveBattler; - if (IsBattlerTerrainAffected(gActiveBattler, STATUS_FIELD_ELECTRIC_TERRAIN)) + CancelMultiTurnMoves(battler); + gEffectBattler = battler; + if (IsBattlerTerrainAffected(battler, STATUS_FIELD_ELECTRIC_TERRAIN)) { gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_TERRAINPREVENTS_ELECTRIC; BattleScriptExecute(BattleScript_TerrainPreventsEnd2); } - else if (IsBattlerTerrainAffected(gActiveBattler, STATUS_FIELD_MISTY_TERRAIN)) + else if (IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) { gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_TERRAINPREVENTS_MISTY; BattleScriptExecute(BattleScript_TerrainPreventsEnd2); @@ -2979,12 +2974,12 @@ u8 DoBattlerEndTurnEffects(void) else { #if B_SLEEP_TURNS >= GEN_5 - gBattleMons[gActiveBattler].status1 |= ((Random() % 3) + 2); + gBattleMons[battler].status1 |= ((Random() % 3) + 2); #else - gBattleMons[gActiveBattler].status1 |= ((Random() % 4) + 3); + gBattleMons[battler].status1 |= ((Random() % 4) + 3); #endif - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); BattleScriptExecute(BattleScript_YawnMakesAsleep); } effect++; @@ -2993,19 +2988,19 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_LASER_FOCUS: - if (gStatuses3[gActiveBattler] & STATUS3_LASER_FOCUS) + if (gStatuses3[battler] & STATUS3_LASER_FOCUS) { - if (gDisableStructs[gActiveBattler].laserFocusTimer == 0 || --gDisableStructs[gActiveBattler].laserFocusTimer == 0) - gStatuses3[gActiveBattler] &= ~STATUS3_LASER_FOCUS; + if (gDisableStructs[battler].laserFocusTimer == 0 || --gDisableStructs[battler].laserFocusTimer == 0) + gStatuses3[battler] &= ~STATUS3_LASER_FOCUS; } gBattleStruct->turnEffectsTracker++; break; case ENDTURN_EMBARGO: - if (gStatuses3[gActiveBattler] & STATUS3_EMBARGO) + if (gStatuses3[battler] & STATUS3_EMBARGO) { - if (gDisableStructs[gActiveBattler].embargoTimer == 0 || --gDisableStructs[gActiveBattler].embargoTimer == 0) + if (gDisableStructs[battler].embargoTimer == 0 || --gDisableStructs[battler].embargoTimer == 0) { - gStatuses3[gActiveBattler] &= ~STATUS3_EMBARGO; + gStatuses3[battler] &= ~STATUS3_EMBARGO; BattleScriptExecute(BattleScript_EmbargoEndTurn); effect++; } @@ -3013,11 +3008,11 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_MAGNET_RISE: - if (gStatuses3[gActiveBattler] & STATUS3_MAGNET_RISE) + if (gStatuses3[battler] & STATUS3_MAGNET_RISE) { - if (gDisableStructs[gActiveBattler].magnetRiseTimer == 0 || --gDisableStructs[gActiveBattler].magnetRiseTimer == 0) + if (gDisableStructs[battler].magnetRiseTimer == 0 || --gDisableStructs[battler].magnetRiseTimer == 0) { - gStatuses3[gActiveBattler] &= ~STATUS3_MAGNET_RISE; + gStatuses3[battler] &= ~STATUS3_MAGNET_RISE; BattleScriptExecute(BattleScript_BufferEndTurn); PREPARE_STRING_BUFFER(gBattleTextBuff1, STRINGID_ELECTROMAGNETISM); effect++; @@ -3026,11 +3021,11 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_TELEKINESIS: - if (gStatuses3[gActiveBattler] & STATUS3_TELEKINESIS) + if (gStatuses3[battler] & STATUS3_TELEKINESIS) { - if (gDisableStructs[gActiveBattler].telekinesisTimer == 0 || --gDisableStructs[gActiveBattler].telekinesisTimer == 0) + if (gDisableStructs[battler].telekinesisTimer == 0 || --gDisableStructs[battler].telekinesisTimer == 0) { - gStatuses3[gActiveBattler] &= ~STATUS3_TELEKINESIS; + gStatuses3[battler] &= ~STATUS3_TELEKINESIS; BattleScriptExecute(BattleScript_TelekinesisEndTurn); effect++; } @@ -3038,11 +3033,11 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_HEALBLOCK: - if (gStatuses3[gActiveBattler] & STATUS3_HEAL_BLOCK) + if (gStatuses3[battler] & STATUS3_HEAL_BLOCK) { - if (gDisableStructs[gActiveBattler].healBlockTimer == 0 || --gDisableStructs[gActiveBattler].healBlockTimer == 0) + if (gDisableStructs[battler].healBlockTimer == 0 || --gDisableStructs[battler].healBlockTimer == 0) { - gStatuses3[gActiveBattler] &= ~STATUS3_HEAL_BLOCK; + gStatuses3[battler] &= ~STATUS3_HEAL_BLOCK; BattleScriptExecute(BattleScript_BufferEndTurn); PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_HEAL_BLOCK); effect++; @@ -3051,22 +3046,22 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ROOST: // Return flying type. - if (gBattleResources->flags->flags[gActiveBattler] & RESOURCE_FLAG_ROOST) + if (gBattleResources->flags->flags[battler] & RESOURCE_FLAG_ROOST) { - gBattleResources->flags->flags[gActiveBattler] &= ~RESOURCE_FLAG_ROOST; - gBattleMons[gActiveBattler].type1 = gBattleStruct->roostTypes[gActiveBattler][0]; - gBattleMons[gActiveBattler].type2 = gBattleStruct->roostTypes[gActiveBattler][1]; + gBattleResources->flags->flags[battler] &= ~RESOURCE_FLAG_ROOST; + gBattleMons[battler].type1 = gBattleStruct->roostTypes[battler][0]; + gBattleMons[battler].type2 = gBattleStruct->roostTypes[battler][1]; } gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ELECTRIFY: - gStatuses4[gActiveBattler] &= ~STATUS4_ELECTRIFIED; + gStatuses4[battler] &= ~STATUS4_ELECTRIFIED; gBattleStruct->turnEffectsTracker++; case ENDTURN_POWDER: - gBattleMons[gActiveBattler].status2 &= ~STATUS2_POWDER; + gBattleMons[battler].status2 &= ~STATUS2_POWDER; gBattleStruct->turnEffectsTracker++; case ENDTURN_THROAT_CHOP: - if (gDisableStructs[gActiveBattler].throatChopTimer && --gDisableStructs[gActiveBattler].throatChopTimer == 0) + if (gDisableStructs[battler].throatChopTimer && --gDisableStructs[battler].throatChopTimer == 0) { BattleScriptExecute(BattleScript_ThroatChopEndTurn); effect++; @@ -3074,8 +3069,8 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_SLOW_START: - if (gDisableStructs[gActiveBattler].slowStartTimer - && --gDisableStructs[gActiveBattler].slowStartTimer == 0 + if (gDisableStructs[battler].slowStartTimer + && --gDisableStructs[battler].slowStartTimer == 0 && ability == ABILITY_SLOW_START) { BattleScriptExecute(BattleScript_SlowStartEnds); @@ -3084,12 +3079,12 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_PLASMA_FISTS: - gStatuses4[gActiveBattler] &= ~STATUS4_PLASMA_FISTS; + gStatuses4[battler] &= ~STATUS4_PLASMA_FISTS; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_CUD_CHEW: - if (GetBattlerAbility(gActiveBattler) == ABILITY_CUD_CHEW && !gDisableStructs[gActiveBattler].cudChew && ItemId_GetPocket(GetUsedHeldItem(gActiveBattler)) == POCKET_BERRIES) - gDisableStructs[gActiveBattler].cudChew = TRUE; + if (GetBattlerAbility(battler) == ABILITY_CUD_CHEW && !gDisableStructs[battler].cudChew && ItemId_GetPocket(GetUsedHeldItem(battler)) == POCKET_BERRIES) + gDisableStructs[battler].cudChew = TRUE; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_BATTLER_COUNT: // done @@ -3781,9 +3776,8 @@ u8 AtkCanceller_UnableToUseMove(u32 moveType) if (effect == 2) { - gActiveBattler = gBattlerAttacker; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(gBattlerAttacker, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gBattlerAttacker].status1); + MarkBattlerForControllerExec(gBattlerAttacker); } return effect; } @@ -4044,7 +4038,7 @@ static bool32 TryChangeBattleTerrain(u32 battler, u32 statusFlag, u8 *timer) static u8 ForewarnChooseMove(u32 battler) { struct Forewarn { - u8 battlerId; + u8 battler; u8 power; u16 moveId; }; @@ -4061,7 +4055,7 @@ static u8 ForewarnChooseMove(u32 battler) if (gBattleMons[i].moves[j] == MOVE_NONE) continue; data[count].moveId = gBattleMons[i].moves[j]; - data[count].battlerId = i; + data[count].battler = i; switch (gBattleMoves[data[count].moveId].effect) { case EFFECT_OHKO: @@ -4092,14 +4086,14 @@ static u8 ForewarnChooseMove(u32 battler) bestId = i; } - gBattlerTarget = data[bestId].battlerId; + gBattlerTarget = data[bestId].battler; PREPARE_MOVE_BUFFER(gBattleTextBuff1, data[bestId].moveId) RecordKnownMove(gBattlerTarget, data[bestId].moveId); Free(data); } -bool8 ChangeTypeBasedOnTerrain(u8 battlerId) +bool8 ChangeTypeBasedOnTerrain(u8 battler) { u8 battlerType; @@ -4114,17 +4108,17 @@ bool8 ChangeTypeBasedOnTerrain(u8 battlerId) else // failsafe return FALSE; - SET_BATTLER_TYPE(battlerId, battlerType); + SET_BATTLER_TYPE(battler, battlerType); PREPARE_TYPE_BUFFER(gBattleTextBuff1, battlerType); return TRUE; } // Supreme Overlord adds a damage boost for each fainted ally. // The first ally adds a x1.2 boost, and subsequent allies add an extra x0.1 boost each. -static uq4_12_t GetSupremeOverlordModifier(u8 battlerId) +static uq4_12_t GetSupremeOverlordModifier(u8 battler) { u32 i; - struct Pokemon *party = GetBattlerParty(battlerId); + struct Pokemon *party = GetBattlerParty(battler); uq4_12_t modifier = UQ_4_12(1.0); bool8 appliedFirstBoost = FALSE; @@ -4774,10 +4768,10 @@ u8 AbilityBattleEffects(u8 caseID, u8 battler, u16 ability, u8 special, u16 move gBattleMons[battler].status1 = 0; gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; - gBattleScripting.battler = gActiveBattler = battler; + gBattleScripting.battler = battler; BattleScriptPushCursorAndCallback(BattleScript_ShedSkinActivates); - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); effect++; } break; @@ -4879,8 +4873,8 @@ u8 AbilityBattleEffects(u8 caseID, u8 battler, u16 ability, u8 special, u16 move && gBattleResults.catchAttempts[gLastUsedBall - ITEM_ULTRA_BALL] >= 1 && !gHasFetchedBall) { - gBattleScripting.battler = gActiveBattler = battler; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedBall); + gBattleScripting.battler = battler; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_HELDITEM_BATTLE, 0, 2, &gLastUsedBall); MarkBattlerForControllerExec(battler); gHasFetchedBall = TRUE; gLastUsedItem = gLastUsedBall; @@ -5830,9 +5824,9 @@ u8 AbilityBattleEffects(u8 caseID, u8 battler, u16 ability, u8 special, u16 move break; } - gBattleScripting.battler = gActiveBattler = gBattlerAbility = battler; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + gBattleScripting.battler = gBattlerAbility = battler; + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); return effect; } } @@ -6050,12 +6044,12 @@ u8 AbilityBattleEffects(u8 caseID, u8 battler, u16 ability, u8 special, u16 move return effect; } -bool32 TryPrimalReversion(u8 battlerId) +bool32 TryPrimalReversion(u8 battler) { - if (GetBattlerHoldEffect(battlerId, FALSE) == HOLD_EFFECT_PRIMAL_ORB - && GetBattleFormChangeTargetSpecies(battlerId, FORM_CHANGE_BATTLE_PRIMAL_REVERSION) != SPECIES_NONE) + if (GetBattlerHoldEffect(battler, FALSE) == HOLD_EFFECT_PRIMAL_ORB + && GetBattleFormChangeTargetSpecies(battler, FORM_CHANGE_BATTLE_PRIMAL_REVERSION) != SPECIES_NONE) { - if (gBattlerAttacker == battlerId) + if (gBattlerAttacker == battler) { BattleScriptExecute(BattleScript_PrimalReversion); } @@ -6063,7 +6057,7 @@ bool32 TryPrimalReversion(u8 battlerId) { // edge case for scenarios like a switch-in after activated eject button gBattleScripting.savedBattler = gBattlerAttacker; - gBattlerAttacker = battlerId; + gBattlerAttacker = battler; BattleScriptExecute(BattleScript_PrimalReversionRestoreAttacker); } return TRUE; @@ -6120,12 +6114,12 @@ bool32 IsMyceliumMightOnField(void) return FALSE; } -u32 GetBattlerAbility(u8 battlerId) +u32 GetBattlerAbility(u8 battler) { - if (gStatuses3[battlerId] & STATUS3_GASTRO_ACID) + if (gStatuses3[battler] & STATUS3_GASTRO_ACID) return ABILITY_NONE; - if (IsNeutralizingGasOnField() && !IsNeutralizingGasBannedAbility(gBattleMons[battlerId].ability)) + if (IsNeutralizingGasOnField() && !IsNeutralizingGasBannedAbility(gBattleMons[battler].ability)) return ABILITY_NONE; if (IsMyceliumMightOnField()) @@ -6136,28 +6130,28 @@ u32 GetBattlerAbility(u8 battlerId) || gBattleMons[gBattlerAttacker].ability == ABILITY_TURBOBLAZE) && !(gStatuses3[gBattlerAttacker] & STATUS3_GASTRO_ACID)) || gBattleMoves[gCurrentMove].ignoresTargetAbility) - && sAbilitiesAffectedByMoldBreaker[gBattleMons[battlerId].ability] + && sAbilitiesAffectedByMoldBreaker[gBattleMons[battler].ability] && gBattlerByTurnOrder[gCurrentTurnActionNumber] == gBattlerAttacker && gActionsByTurnOrder[gBattlerByTurnOrder[gBattlerAttacker]] == B_ACTION_USE_MOVE && gCurrentTurnActionNumber < gBattlersCount) return ABILITY_NONE; - return gBattleMons[battlerId].ability; + return gBattleMons[battler].ability; } -u32 IsAbilityOnSide(u32 battlerId, u32 ability) +u32 IsAbilityOnSide(u32 battler, u32 ability) { - if (IsBattlerAlive(battlerId) && GetBattlerAbility(battlerId) == ability) - return battlerId + 1; - else if (IsBattlerAlive(BATTLE_PARTNER(battlerId)) && GetBattlerAbility(BATTLE_PARTNER(battlerId)) == ability) - return BATTLE_PARTNER(battlerId) + 1; + if (IsBattlerAlive(battler) && GetBattlerAbility(battler) == ability) + return battler + 1; + else if (IsBattlerAlive(BATTLE_PARTNER(battler)) && GetBattlerAbility(BATTLE_PARTNER(battler)) == ability) + return BATTLE_PARTNER(battler) + 1; else return 0; } -u32 IsAbilityOnOpposingSide(u32 battlerId, u32 ability) +u32 IsAbilityOnOpposingSide(u32 battler, u32 ability) { - return IsAbilityOnSide(BATTLE_OPPOSITE(battlerId), ability); + return IsAbilityOnSide(BATTLE_OPPOSITE(battler), ability); } u32 IsAbilityOnField(u32 ability) @@ -6173,55 +6167,55 @@ u32 IsAbilityOnField(u32 ability) return 0; } -u32 IsAbilityOnFieldExcept(u32 battlerId, u32 ability) +u32 IsAbilityOnFieldExcept(u32 battler, u32 ability) { u32 i; for (i = 0; i < gBattlersCount; i++) { - if (i != battlerId && IsBattlerAlive(i) && GetBattlerAbility(i) == ability) + if (i != battler && IsBattlerAlive(i) && GetBattlerAbility(i) == ability) return i + 1; } return 0; } -u32 IsAbilityPreventingEscape(u32 battlerId) +u32 IsAbilityPreventingEscape(u32 battler) { u32 id; #if B_GHOSTS_ESCAPE >= GEN_6 - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_GHOST)) + if (IS_BATTLER_OF_TYPE(battler, TYPE_GHOST)) return 0; #endif #if B_SHADOW_TAG_ESCAPE >= GEN_4 - if ((id = IsAbilityOnOpposingSide(battlerId, ABILITY_SHADOW_TAG)) && GetBattlerAbility(battlerId) != ABILITY_SHADOW_TAG) + if ((id = IsAbilityOnOpposingSide(battler, ABILITY_SHADOW_TAG)) && GetBattlerAbility(battler) != ABILITY_SHADOW_TAG) #else - if ((id = IsAbilityOnOpposingSide(battlerId, ABILITY_SHADOW_TAG))) + if ((id = IsAbilityOnOpposingSide(battler, ABILITY_SHADOW_TAG))) #endif return id; - if ((id = IsAbilityOnOpposingSide(battlerId, ABILITY_ARENA_TRAP)) && IsBattlerGrounded(battlerId)) + if ((id = IsAbilityOnOpposingSide(battler, ABILITY_ARENA_TRAP)) && IsBattlerGrounded(battler)) return id; - if ((id = IsAbilityOnOpposingSide(battlerId, ABILITY_MAGNET_PULL)) && IS_BATTLER_OF_TYPE(battlerId, TYPE_STEEL)) + if ((id = IsAbilityOnOpposingSide(battler, ABILITY_MAGNET_PULL)) && IS_BATTLER_OF_TYPE(battler, TYPE_STEEL)) return id; return 0; } -bool32 CanBattlerEscape(u32 battlerId) // no ability check +bool32 CanBattlerEscape(u32 battler) // no ability check { - if (GetBattlerHoldEffect(battlerId, TRUE) == HOLD_EFFECT_SHED_SHELL) + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_SHED_SHELL) return TRUE; #if B_GHOSTS_ESCAPE >= GEN_6 - else if (IS_BATTLER_OF_TYPE(battlerId, TYPE_GHOST)) + else if (IS_BATTLER_OF_TYPE(battler, TYPE_GHOST)) return TRUE; #endif - else if (gBattleMons[battlerId].status2 & (STATUS2_ESCAPE_PREVENTION | STATUS2_WRAPPED)) + else if (gBattleMons[battler].status2 & (STATUS2_ESCAPE_PREVENTION | STATUS2_WRAPPED)) return FALSE; - else if (gStatuses3[battlerId] & STATUS3_ROOTED) + else if (gStatuses3[battler] & STATUS3_ROOTED) return FALSE; else if (gFieldStatuses & STATUS_FIELD_FAIRY_LOCK) return FALSE; - else if (gStatuses3[battlerId] & STATUS3_SKY_DROPPED) + else if (gStatuses3[battler] & STATUS3_SKY_DROPPED) return FALSE; else return TRUE; @@ -6253,27 +6247,27 @@ enum ITEM_STATS_CHANGE, }; -bool32 IsBattlerTerrainAffected(u8 battlerId, u32 terrainFlag) +bool32 IsBattlerTerrainAffected(u8 battler, u32 terrainFlag) { if (!(gFieldStatuses & terrainFlag)) return FALSE; - else if (gStatuses3[battlerId] & STATUS3_SEMI_INVULNERABLE) + else if (gStatuses3[battler] & STATUS3_SEMI_INVULNERABLE) return FALSE; - return IsBattlerGrounded(battlerId); + return IsBattlerGrounded(battler); } -bool32 CanSleep(u8 battlerId) +bool32 CanSleep(u8 battler) { - u16 ability = GetBattlerAbility(battlerId); + u16 ability = GetBattlerAbility(battler); if (ability == ABILITY_INSOMNIA || ability == ABILITY_VITAL_SPIRIT || ability == ABILITY_COMATOSE - || gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD - || gBattleMons[battlerId].status1 & STATUS1_ANY - || IsAbilityOnSide(battlerId, ABILITY_SWEET_VEIL) - || IsAbilityStatusProtected(battlerId) - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_ELECTRIC_TERRAIN | STATUS_FIELD_MISTY_TERRAIN)) + || gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD + || gBattleMons[battler].status1 & STATUS1_ANY + || IsAbilityOnSide(battler, ABILITY_SWEET_VEIL) + || IsAbilityStatusProtected(battler) + || IsBattlerTerrainAffected(battler, STATUS_FIELD_ELECTRIC_TERRAIN | STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } @@ -6294,96 +6288,96 @@ bool32 CanBePoisoned(u8 battlerAttacker, u8 battlerTarget) return TRUE; } -bool32 CanBeBurned(u8 battlerId) +bool32 CanBeBurned(u8 battler) { - u16 ability = GetBattlerAbility(battlerId); - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_FIRE) - || gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD - || gBattleMons[battlerId].status1 & STATUS1_ANY + u16 ability = GetBattlerAbility(battler); + if (IS_BATTLER_OF_TYPE(battler, TYPE_FIRE) + || gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD + || gBattleMons[battler].status1 & STATUS1_ANY || ability == ABILITY_WATER_VEIL || ability == ABILITY_WATER_BUBBLE || ability == ABILITY_COMATOSE || ability == ABILITY_THERMAL_EXCHANGE - || IsAbilityStatusProtected(battlerId) - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN)) + || IsAbilityStatusProtected(battler) + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } -bool32 CanBeParalyzed(u8 battlerId) +bool32 CanBeParalyzed(u8 battler) { - u16 ability = GetBattlerAbility(battlerId); + u16 ability = GetBattlerAbility(battler); if ( #if B_PARALYZE_ELECTRIC >= GEN_6 - IS_BATTLER_OF_TYPE(battlerId, TYPE_ELECTRIC) || + IS_BATTLER_OF_TYPE(battler, TYPE_ELECTRIC) || #endif - gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD + gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD || ability == ABILITY_LIMBER || ability == ABILITY_COMATOSE - || gBattleMons[battlerId].status1 & STATUS1_ANY - || IsAbilityStatusProtected(battlerId) - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN)) + || gBattleMons[battler].status1 & STATUS1_ANY + || IsAbilityStatusProtected(battler) + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } -bool32 CanBeFrozen(u8 battlerId) +bool32 CanBeFrozen(u8 battler) { - u16 ability = GetBattlerAbility(battlerId); - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_ICE) - || IsBattlerWeatherAffected(battlerId, B_WEATHER_SUN) - || gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD + u16 ability = GetBattlerAbility(battler); + if (IS_BATTLER_OF_TYPE(battler, TYPE_ICE) + || IsBattlerWeatherAffected(battler, B_WEATHER_SUN) + || gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD || ability == ABILITY_MAGMA_ARMOR || ability == ABILITY_COMATOSE - || gBattleMons[battlerId].status1 & STATUS1_ANY - || IsAbilityStatusProtected(battlerId) - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN)) + || gBattleMons[battler].status1 & STATUS1_ANY + || IsAbilityStatusProtected(battler) + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } -bool32 CanGetFrostbite(u8 battlerId) +bool32 CanGetFrostbite(u8 battler) { - u16 ability = GetBattlerAbility(battlerId); - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_ICE) - || gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD + u16 ability = GetBattlerAbility(battler); + if (IS_BATTLER_OF_TYPE(battler, TYPE_ICE) + || gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD || ability == ABILITY_MAGMA_ARMOR || ability == ABILITY_COMATOSE - || gBattleMons[battlerId].status1 & STATUS1_ANY - || IsAbilityStatusProtected(battlerId) - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN)) + || gBattleMons[battler].status1 & STATUS1_ANY + || IsAbilityStatusProtected(battler) + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } -bool32 CanBeConfused(u8 battlerId) +bool32 CanBeConfused(u8 battler) { - if (GetBattlerAbility(battlerId) == ABILITY_OWN_TEMPO - || gBattleMons[battlerId].status2 & STATUS2_CONFUSION - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN)) + if (GetBattlerAbility(battler) == ABILITY_OWN_TEMPO + || gBattleMons[battler].status2 & STATUS2_CONFUSION + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN)) return FALSE; return TRUE; } // second argument is 1/X of current hp compared to max hp -bool32 HasEnoughHpToEatBerry(u32 battlerId, u32 hpFraction, u32 itemId) +bool32 HasEnoughHpToEatBerry(u32 battler, u32 hpFraction, u32 itemId) { bool32 isBerry = (ItemId_GetPocket(itemId) == POCKET_BERRIES); - if (gBattleMons[battlerId].hp == 0) + if (gBattleMons[battler].hp == 0) return FALSE; if (gBattleScripting.overrideBerryRequirements) return TRUE; // Unnerve prevents consumption of opponents' berries. - if (isBerry && IsUnnerveAbilityOnOpposingSide(battlerId)) + if (isBerry && IsUnnerveAbilityOnOpposingSide(battler)) return FALSE; - if (gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / hpFraction) + if (gBattleMons[battler].hp <= gBattleMons[battler].maxHP / hpFraction) return TRUE; - if (hpFraction <= 4 && GetBattlerAbility(battlerId) == ABILITY_GLUTTONY && isBerry - && gBattleMons[battlerId].hp <= gBattleMons[battlerId].maxHP / 2) + if (hpFraction <= 4 && GetBattlerAbility(battler) == ABILITY_GLUTTONY && isBerry + && gBattleMons[battler].hp <= gBattleMons[battler].maxHP / 2) { - RecordAbilityBattle(battlerId, ABILITY_GLUTTONY); + RecordAbilityBattle(battler, ABILITY_GLUTTONY); return TRUE; } @@ -6396,30 +6390,30 @@ bool32 HasEnoughHpToEatBerry(u32 battlerId, u32 hpFraction, u32 itemId) #define CONFUSE_BERRY_HP_FRACTION 2 #endif -static u8 HealConfuseBerry(u32 battlerId, u32 itemId, u8 flavorId, bool32 end2) +static u8 HealConfuseBerry(u32 battler, u32 itemId, u8 flavorId, bool32 end2) { - if (HasEnoughHpToEatBerry(battlerId, CONFUSE_BERRY_HP_FRACTION, itemId) + if (HasEnoughHpToEatBerry(battler, CONFUSE_BERRY_HP_FRACTION, itemId) #if B_HEAL_BLOCKING >= GEN_5 - && !(gStatuses3[battlerId] & STATUS3_HEAL_BLOCK) + && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK) #endif ) { PREPARE_FLAVOR_BUFFER(gBattleTextBuff1, flavorId); - gBattleMoveDamage = gBattleMons[battlerId].maxHP / GetBattlerItemHoldEffectParam(battlerId, itemId); + gBattleMoveDamage = gBattleMons[battler].maxHP / GetBattlerItemHoldEffectParam(battler, itemId); if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + if (GetBattlerAbility(battler) == ABILITY_RIPEN) { gBattleMoveDamage *= 2; - gBattlerAbility = battlerId; + gBattlerAbility = battler; } - gBattleScripting.battler = battlerId; + gBattleScripting.battler = battler; if (end2) { - if (GetFlavorRelationByPersonality(gBattleMons[battlerId].personality, flavorId) < 0) + if (GetFlavorRelationByPersonality(gBattleMons[battler].personality, flavorId) < 0) BattleScriptExecute(BattleScript_BerryConfuseHealEnd2); else BattleScriptExecute(BattleScript_ItemHealHP_RemoveItemEnd2); @@ -6427,7 +6421,7 @@ static u8 HealConfuseBerry(u32 battlerId, u32 itemId, u8 flavorId, bool32 end2) else { BattleScriptPushCursor(); - if (GetFlavorRelationByPersonality(gBattleMons[battlerId].personality, flavorId) < 0) + if (GetFlavorRelationByPersonality(gBattleMons[battler].personality, flavorId) < 0) gBattlescriptCurrInstr = BattleScript_BerryConfuseHealRet; else gBattlescriptCurrInstr = BattleScript_ItemHealHP_RemoveItemRet; @@ -6440,13 +6434,13 @@ static u8 HealConfuseBerry(u32 battlerId, u32 itemId, u8 flavorId, bool32 end2) #undef CONFUSE_BERRY_HP_FRACTION -static u8 StatRaiseBerry(u32 battlerId, u32 itemId, u32 statId, bool32 end2) +static u8 StatRaiseBerry(u32 battler, u32 itemId, u32 statId, bool32 end2) { - if (CompareStat(battlerId, statId, MAX_STAT_STAGE, CMP_LESS_THAN) && HasEnoughHpToEatBerry(battlerId, GetBattlerItemHoldEffectParam(battlerId, itemId), itemId)) + if (CompareStat(battler, statId, MAX_STAT_STAGE, CMP_LESS_THAN) && HasEnoughHpToEatBerry(battler, GetBattlerItemHoldEffectParam(battler, itemId), itemId)) { - BufferStatChange(battlerId, statId, STRINGID_STATROSE); - gEffectBattler = battlerId; - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + BufferStatChange(battler, statId, STRINGID_STATROSE); + gEffectBattler = battler; + if (GetBattlerAbility(battler) == ABILITY_RIPEN) SET_STATCHANGER(statId, 2, FALSE); else SET_STATCHANGER(statId, 1, FALSE); @@ -6468,23 +6462,23 @@ static u8 StatRaiseBerry(u32 battlerId, u32 itemId, u32 statId, bool32 end2) return 0; } -static u8 RandomStatRaiseBerry(u32 battlerId, u32 itemId, bool32 end2) +static u8 RandomStatRaiseBerry(u32 battler, u32 itemId, bool32 end2) { s32 i; u16 stringId; for (i = 0; i < NUM_STATS - 1; i++) { - if (CompareStat(battlerId, STAT_ATK + i, MAX_STAT_STAGE, CMP_LESS_THAN)) + if (CompareStat(battler, STAT_ATK + i, MAX_STAT_STAGE, CMP_LESS_THAN)) break; } - if (i != NUM_STATS - 1 && HasEnoughHpToEatBerry(battlerId, GetBattlerItemHoldEffectParam(battlerId, itemId), itemId)) + if (i != NUM_STATS - 1 && HasEnoughHpToEatBerry(battler, GetBattlerItemHoldEffectParam(battler, itemId), itemId)) { - u16 battlerAbility = GetBattlerAbility(battlerId); + u16 battlerAbility = GetBattlerAbility(battler); do { i = Random() % (NUM_STATS - 1); - } while (!CompareStat(battlerId, STAT_ATK + i, MAX_STAT_STAGE, CMP_LESS_THAN)); + } while (!CompareStat(battler, STAT_ATK + i, MAX_STAT_STAGE, CMP_LESS_THAN)); PREPARE_STAT_BUFFER(gBattleTextBuff1, i + 1); stringId = (battlerAbility == ABILITY_CONTRARY) ? STRINGID_STATFELL : STRINGID_STATROSE; @@ -6496,7 +6490,7 @@ static u8 RandomStatRaiseBerry(u32 battlerId, u32 itemId, bool32 end2) gBattleTextBuff2[5] = stringId; gBattleTextBuff2[6] = stringId >> 8; gBattleTextBuff2[7] = EOS; - gEffectBattler = battlerId; + gEffectBattler = battler; if (battlerAbility == ABILITY_RIPEN) SET_STATCHANGER(i + 1, 4, FALSE); else @@ -6519,11 +6513,11 @@ static u8 RandomStatRaiseBerry(u32 battlerId, u32 itemId, bool32 end2) return 0; } -static u8 TrySetMicleBerry(u32 battlerId, u32 itemId, bool32 end2) +static u8 TrySetMicleBerry(u32 battler, u32 itemId, bool32 end2) { - if (HasEnoughHpToEatBerry(battlerId, 4, itemId)) + if (HasEnoughHpToEatBerry(battler, 4, itemId)) { - gProtectStructs[battlerId].usedMicleBerry = TRUE; // battler's next attack has increased accuracy + gProtectStructs[battler].usedMicleBerry = TRUE; // battler's next attack has increased accuracy if (end2) { @@ -6539,18 +6533,18 @@ static u8 TrySetMicleBerry(u32 battlerId, u32 itemId, bool32 end2) return 0; } -static u8 DamagedStatBoostBerryEffect(u8 battlerId, u8 statId, u8 split) +static u8 DamagedStatBoostBerryEffect(u8 battler, u8 statId, u8 split) { - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED - && CompareStat(battlerId, statId, MAX_STAT_STAGE, CMP_LESS_THAN) - && !DoesSubstituteBlockMove(gBattlerAttacker, battlerId, gCurrentMove) + && CompareStat(battler, statId, MAX_STAT_STAGE, CMP_LESS_THAN) + && !DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && GetBattleMoveSplit(gCurrentMove) == split) { - BufferStatChange(battlerId, statId, STRINGID_STATROSE); + BufferStatChange(battler, statId, STRINGID_STATROSE); - gEffectBattler = battlerId; - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + gEffectBattler = battler; + if (GetBattlerAbility(battler) == ABILITY_RIPEN) SET_STATCHANGER(statId, 2, FALSE); else SET_STATCHANGER(statId, 1, FALSE); @@ -6588,24 +6582,24 @@ u8 TryHandleSeed(u8 battler, u32 terrainFlag, u8 statId, u16 itemId, bool32 exec return 0; } -static u8 ItemHealHp(u32 battlerId, u32 itemId, bool32 end2, bool32 percentHeal) +static u8 ItemHealHp(u32 battler, u32 itemId, bool32 end2, bool32 percentHeal) { - if (!(gBattleScripting.overrideBerryRequirements && gBattleMons[battlerId].hp == gBattleMons[battlerId].maxHP) + if (!(gBattleScripting.overrideBerryRequirements && gBattleMons[battler].hp == gBattleMons[battler].maxHP) #if B_HEAL_BLOCKING >= GEN_5 - && !(gStatuses3[battlerId] & STATUS3_HEAL_BLOCK) + && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK) #endif - && HasEnoughHpToEatBerry(battlerId, 2, itemId)) + && HasEnoughHpToEatBerry(battler, 2, itemId)) { if (percentHeal) - gBattleMoveDamage = (gBattleMons[battlerId].maxHP * GetBattlerItemHoldEffectParam(battlerId, itemId) / 100) * -1; + gBattleMoveDamage = (gBattleMons[battler].maxHP * GetBattlerItemHoldEffectParam(battler, itemId) / 100) * -1; else - gBattleMoveDamage = GetBattlerItemHoldEffectParam(battlerId, itemId) * -1; + gBattleMoveDamage = GetBattlerItemHoldEffectParam(battler, itemId) * -1; // check ripen - if (ItemId_GetPocket(itemId) == POCKET_BERRIES && GetBattlerAbility(battlerId) == ABILITY_RIPEN) + if (ItemId_GetPocket(itemId) == POCKET_BERRIES && GetBattlerAbility(battler) == ABILITY_RIPEN) gBattleMoveDamage *= 2; - gBattlerAbility = battlerId; // in SWSH, berry juice shows ability pop up but has no effect. This is mimicked here + gBattlerAbility = battler; // in SWSH, berry juice shows ability pop up but has no effect. This is mimicked here if (end2) { BattleScriptExecute(BattleScript_ItemHealHP_RemoveItemEnd2); @@ -6620,61 +6614,61 @@ static u8 ItemHealHp(u32 battlerId, u32 itemId, bool32 end2, bool32 percentHeal) return 0; } -static bool32 UnnerveOn(u32 battlerId, u32 itemId) +static bool32 UnnerveOn(u32 battler, u32 itemId) { - if (ItemId_GetPocket(itemId) == POCKET_BERRIES && IsUnnerveAbilityOnOpposingSide(battlerId)) + if (ItemId_GetPocket(itemId) == POCKET_BERRIES && IsUnnerveAbilityOnOpposingSide(battler)) return TRUE; return FALSE; } -static bool32 GetMentalHerbEffect(u8 battlerId) +static bool32 GetMentalHerbEffect(u8 battler) { bool32 ret = FALSE; // Check infatuation - if (gBattleMons[battlerId].status2 & STATUS2_INFATUATION) + if (gBattleMons[battler].status2 & STATUS2_INFATUATION) { - gBattleMons[battlerId].status2 &= ~STATUS2_INFATUATION; + gBattleMons[battler].status2 &= ~STATUS2_INFATUATION; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_INFATUATION; // STRINGID_TARGETGOTOVERINFATUATION StringCopy(gBattleTextBuff1, gStatusConditionString_LoveJpn); ret = TRUE; } #if B_MENTAL_HERB >= GEN_5 // Check taunt - if (gDisableStructs[battlerId].tauntTimer != 0) + if (gDisableStructs[battler].tauntTimer != 0) { - gDisableStructs[battlerId].tauntTimer = 0; + gDisableStructs[battler].tauntTimer = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_TAUNT; PREPARE_MOVE_BUFFER(gBattleTextBuff1, MOVE_TAUNT); ret = TRUE; } // Check encore - if (gDisableStructs[battlerId].encoreTimer != 0) + if (gDisableStructs[battler].encoreTimer != 0) { - gDisableStructs[battlerId].encoredMove = 0; - gDisableStructs[battlerId].encoreTimer = 0; + gDisableStructs[battler].encoredMove = 0; + gDisableStructs[battler].encoreTimer = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_ENCORE; // STRINGID_PKMNENCOREENDED ret = TRUE; } // Check torment - if (gBattleMons[battlerId].status2 & STATUS2_TORMENT) + if (gBattleMons[battler].status2 & STATUS2_TORMENT) { - gBattleMons[battlerId].status2 &= ~STATUS2_TORMENT; + gBattleMons[battler].status2 &= ~STATUS2_TORMENT; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_TORMENT; ret = TRUE; } // Check heal block - if (gStatuses3[battlerId] & STATUS3_HEAL_BLOCK) + if (gStatuses3[battler] & STATUS3_HEAL_BLOCK) { - gStatuses3[battlerId] &= ~STATUS3_HEAL_BLOCK; + gStatuses3[battler] &= ~STATUS3_HEAL_BLOCK; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_HEALBLOCK; ret = TRUE; } // Check disable - if (gDisableStructs[battlerId].disableTimer != 0) + if (gDisableStructs[battler].disableTimer != 0) { - gDisableStructs[battlerId].disableTimer = 0; - gDisableStructs[battlerId].disabledMove = 0; + gDisableStructs[battler].disableTimer = 0; + gDisableStructs[battler].disabledMove = 0; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_MENTALHERBCURE_DISABLE; ret = TRUE; } @@ -6682,15 +6676,15 @@ static bool32 GetMentalHerbEffect(u8 battlerId) return ret; } -static u8 TryConsumeMirrorHerb(u8 battlerId, bool32 execute) +static u8 TryConsumeMirrorHerb(u8 battler, bool32 execute) { u8 effect = 0; - if (gProtectStructs[battlerId].eatMirrorHerb) { - gLastUsedItem = gBattleMons[battlerId].item; + if (gProtectStructs[battler].eatMirrorHerb) { + gLastUsedItem = gBattleMons[battler].item; gBattleScripting.savedBattler = gBattlerAttacker; - gBattleScripting.battler = gBattlerAttacker = battlerId; - gProtectStructs[battlerId].eatMirrorHerb = 0; + gBattleScripting.battler = gBattlerAttacker = battler; + gProtectStructs[battler].eatMirrorHerb = 0; if (execute) { BattleScriptExecute(BattleScript_MirrorHerbCopyStatChangeEnd2); } else { @@ -6702,7 +6696,7 @@ static u8 TryConsumeMirrorHerb(u8 battlerId, bool32 execute) return effect; } -static u8 ItemEffectMoveEnd(u32 battlerId, u16 holdEffect) +static u8 ItemEffectMoveEnd(u32 battler, u16 holdEffect) { u8 effect = 0; u32 i; @@ -6711,148 +6705,148 @@ static u8 ItemEffectMoveEnd(u32 battlerId, u16 holdEffect) { #if B_HP_BERRIES >= GEN_4 case HOLD_EFFECT_MICLE_BERRY: - effect = TrySetMicleBerry(battlerId, gLastUsedItem, FALSE); + effect = TrySetMicleBerry(battler, gLastUsedItem, FALSE); break; case HOLD_EFFECT_RESTORE_HP: - effect = ItemHealHp(battlerId, gLastUsedItem, FALSE, FALSE); + effect = ItemHealHp(battler, gLastUsedItem, FALSE, FALSE); break; #endif #if B_BERRIES_INSTANT >= GEN_4 case HOLD_EFFECT_RESTORE_PCT_HP: - effect = ItemHealHp(battlerId, gLastUsedItem, FALSE, TRUE); + effect = ItemHealHp(battler, gLastUsedItem, FALSE, TRUE); break; case HOLD_EFFECT_CONFUSE_SPICY: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SPICY, FALSE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SPICY, FALSE); break; case HOLD_EFFECT_CONFUSE_DRY: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_DRY, FALSE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_DRY, FALSE); break; case HOLD_EFFECT_CONFUSE_SWEET: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SWEET, FALSE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SWEET, FALSE); break; case HOLD_EFFECT_CONFUSE_BITTER: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_BITTER, FALSE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_BITTER, FALSE); break; case HOLD_EFFECT_CONFUSE_SOUR: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SOUR, FALSE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SOUR, FALSE); break; case HOLD_EFFECT_ATTACK_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_ATK, FALSE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_ATK, FALSE); break; case HOLD_EFFECT_DEFENSE_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_DEF, FALSE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_DEF, FALSE); break; case HOLD_EFFECT_SPEED_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPEED, FALSE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPEED, FALSE); break; case HOLD_EFFECT_SP_ATTACK_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPATK, FALSE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPATK, FALSE); break; case HOLD_EFFECT_SP_DEFENSE_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPDEF, FALSE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPDEF, FALSE); break; case HOLD_EFFECT_RANDOM_STAT_UP: - effect = RandomStatRaiseBerry(battlerId, gLastUsedItem, FALSE); + effect = RandomStatRaiseBerry(battler, gLastUsedItem, FALSE); break; #endif case HOLD_EFFECT_CURE_PAR: - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_PARALYSIS; + gBattleMons[battler].status1 &= ~STATUS1_PARALYSIS; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureParRet; effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_PSN: - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); + gBattleMons[battler].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCurePsnRet; effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_BRN: - if (gBattleMons[battlerId].status1 & STATUS1_BURN && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_BURN && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_BURN; + gBattleMons[battler].status1 &= ~STATUS1_BURN; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureBrnRet; effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_FRZ: - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FREEZE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FREEZE; + gBattleMons[battler].status1 &= ~STATUS1_FREEZE; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureFrzRet; effect = ITEM_STATUS_CHANGE; } - if (gBattleMons[battlerId].status1 & STATUS1_FROSTBITE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FROSTBITE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FROSTBITE; + gBattleMons[battler].status1 &= ~STATUS1_FROSTBITE; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureFsbRet; effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_SLP: - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_SLEEP && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_SLEEP; - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status1 &= ~STATUS1_SLEEP; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureSlpRet; effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_CONFUSION: - if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION && !UnnerveOn(battler, gLastUsedItem)) { - RemoveConfusionStatus(battlerId); + RemoveConfusionStatus(battler); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryCureConfusionRet; effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_MENTAL_HERB: - if (GetMentalHerbEffect(battlerId)) + if (GetMentalHerbEffect(battler)) { gBattleScripting.savedBattler = gBattlerAttacker; - gBattlerAttacker = battlerId; + gBattlerAttacker = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_MentalHerbCureRet; effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_CURE_STATUS: - if ((gBattleMons[battlerId].status1 & STATUS1_ANY || gBattleMons[battlerId].status2 & STATUS2_CONFUSION) && !UnnerveOn(battlerId, gLastUsedItem)) + if ((gBattleMons[battler].status1 & STATUS1_ANY || gBattleMons[battler].status2 & STATUS2_CONFUSION) && !UnnerveOn(battler, gLastUsedItem)) { - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY) StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn); - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn); } - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS) StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn); - if (gBattleMons[battlerId].status1 & STATUS1_BURN) + if (gBattleMons[battler].status1 & STATUS1_BURN) StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn); - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE || gBattleMons[battlerId].status1 & STATUS1_FROSTBITE) + if (gBattleMons[battler].status1 & STATUS1_FREEZE || gBattleMons[battler].status1 & STATUS1_FROSTBITE) StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn); - if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION) StringCopy(gBattleTextBuff1, gStatusConditionString_ConfusionJpn); - gBattleMons[battlerId].status1 = 0; - RemoveConfusionStatus(battlerId); + gBattleMons[battler].status1 = 0; + RemoveConfusionStatus(battler); BattleScriptPushCursor(); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM; gBattlescriptCurrInstr = BattleScript_BerryCureChosenStatusRet; @@ -6862,16 +6856,16 @@ static u8 ItemEffectMoveEnd(u32 battlerId, u16 holdEffect) case HOLD_EFFECT_RESTORE_STATS: for (i = 0; i < NUM_BATTLE_STATS; i++) { - if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE) + if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE) { - gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE; + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; effect = ITEM_STATS_CHANGE; } } if (effect != 0) { - gBattleScripting.battler = battlerId; - gPotentialItemEffectBattler = battlerId; + gBattleScripting.battler = battler; + gPotentialItemEffectBattler = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_WhiteHerbRet; return effect; @@ -6879,20 +6873,20 @@ static u8 ItemEffectMoveEnd(u32 battlerId, u16 holdEffect) break; case HOLD_EFFECT_CRITICAL_UP: // lansat berry if (B_BERRIES_INSTANT >= GEN_4 - && !(gBattleMons[battlerId].status2 & STATUS2_FOCUS_ENERGY) - && HasEnoughHpToEatBerry(battlerId, GetBattlerItemHoldEffectParam(battlerId, gLastUsedItem), gLastUsedItem)) + && !(gBattleMons[battler].status2 & STATUS2_FOCUS_ENERGY) + && HasEnoughHpToEatBerry(battler, GetBattlerItemHoldEffectParam(battler, gLastUsedItem), gLastUsedItem)) { - gBattleMons[battlerId].status2 |= STATUS2_FOCUS_ENERGY; - gBattleScripting.battler = battlerId; - gPotentialItemEffectBattler = battlerId; + gBattleMons[battler].status2 |= STATUS2_FOCUS_ENERGY; + gBattleScripting.battler = battler; + gPotentialItemEffectBattler = battler; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_BerryFocusEnergyRet; effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_BERSERK_GENE: - BufferStatChange(battlerId, STAT_ATK, STRINGID_STATROSE); - gEffectBattler = battlerId; + BufferStatChange(battler, STAT_ATK, STRINGID_STATROSE); + gEffectBattler = battler; if (CanBeInfinitelyConfused(gEffectBattler)) { gStatuses4[gEffectBattler] |= STATUS4_INFINITE_CONFUSION; @@ -6906,14 +6900,14 @@ static u8 ItemEffectMoveEnd(u32 battlerId, u16 holdEffect) effect = ITEM_STATS_CHANGE; break; case HOLD_EFFECT_MIRROR_HERB: - effect = TryConsumeMirrorHerb(battlerId, FALSE); + effect = TryConsumeMirrorHerb(battler, FALSE); break; } return effect; } -u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) +u8 ItemBattleEffects(u8 caseID, u8 battler, bool8 moveTurn) { int i = 0, moveType; u8 effect = ITEM_NO_EFFECT; @@ -6923,8 +6917,8 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) u16 atkItem; if (caseID != ITEMEFFECT_USE_LAST_ITEM) { - gLastUsedItem = gBattleMons[battlerId].item; - battlerHoldEffect = GetBattlerHoldEffect(battlerId, TRUE); + gLastUsedItem = gBattleMons[battler].item; + battlerHoldEffect = GetBattlerHoldEffect(battler, TRUE); } atkItem = gBattleMons[gBattlerAttacker].item; @@ -6934,12 +6928,12 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) switch (caseID) { case ITEMEFFECT_ON_SWITCH_IN: - if (!gSpecialStatuses[battlerId].switchInItemDone) + if (!gSpecialStatuses[battler].switchInItemDone) { switch (battlerHoldEffect) { case HOLD_EFFECT_DOUBLE_PRIZE: - if (GetBattlerSide(battlerId) == B_SIDE_PLAYER && !gBattleStruct->moneyMultiplierItem) + if (GetBattlerSide(battler) == B_SIDE_PLAYER && !gBattleStruct->moneyMultiplierItem) { gBattleStruct->moneyMultiplier *= 2; gBattleStruct->moneyMultiplierItem = 1; @@ -6948,141 +6942,141 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) case HOLD_EFFECT_RESTORE_STATS: for (i = 0; i < NUM_BATTLE_STATS; i++) { - if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE) + if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE) { - gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE; + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; effect = ITEM_STATS_CHANGE; } } if (effect != 0) { - gBattleScripting.battler = battlerId; - gPotentialItemEffectBattler = battlerId; - gActiveBattler = gBattlerAttacker = battlerId; + gBattleScripting.battler = battler; + gPotentialItemEffectBattler = battler; + gActiveBattler = gBattlerAttacker = battler; BattleScriptExecute(BattleScript_WhiteHerbEnd2); } break; #if B_BERRIES_INSTANT >= GEN_4 case HOLD_EFFECT_CONFUSE_SPICY: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SPICY, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SPICY, TRUE); break; case HOLD_EFFECT_CONFUSE_DRY: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_DRY, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_DRY, TRUE); break; case HOLD_EFFECT_CONFUSE_SWEET: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SWEET, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SWEET, TRUE); break; case HOLD_EFFECT_CONFUSE_BITTER: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_BITTER, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_BITTER, TRUE); break; case HOLD_EFFECT_CONFUSE_SOUR: - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SOUR, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SOUR, TRUE); break; case HOLD_EFFECT_ATTACK_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_ATK, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_ATK, TRUE); break; case HOLD_EFFECT_DEFENSE_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_DEF, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_DEF, TRUE); break; case HOLD_EFFECT_SPEED_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPEED, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPEED, TRUE); break; case HOLD_EFFECT_SP_ATTACK_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPATK, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPATK, TRUE); break; case HOLD_EFFECT_SP_DEFENSE_UP: - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPDEF, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPDEF, TRUE); break; case HOLD_EFFECT_CRITICAL_UP: - if (!(gBattleMons[battlerId].status2 & STATUS2_FOCUS_ENERGY) && HasEnoughHpToEatBerry(battlerId, GetBattlerItemHoldEffectParam(battlerId, gLastUsedItem), gLastUsedItem)) + if (!(gBattleMons[battler].status2 & STATUS2_FOCUS_ENERGY) && HasEnoughHpToEatBerry(battler, GetBattlerItemHoldEffectParam(battler, gLastUsedItem), gLastUsedItem)) { - gBattleMons[battlerId].status2 |= STATUS2_FOCUS_ENERGY; - gBattleScripting.battler = battlerId; + gBattleMons[battler].status2 |= STATUS2_FOCUS_ENERGY; + gBattleScripting.battler = battler; BattleScriptExecute(BattleScript_BerryFocusEnergyEnd2); effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_RANDOM_STAT_UP: - effect = RandomStatRaiseBerry(battlerId, gLastUsedItem, TRUE); + effect = RandomStatRaiseBerry(battler, gLastUsedItem, TRUE); break; case HOLD_EFFECT_CURE_PAR: - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_PARALYSIS; + gBattleMons[battler].status1 &= ~STATUS1_PARALYSIS; BattleScriptExecute(BattleScript_BerryCurePrlzEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_PSN: - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); + gBattleMons[battler].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); BattleScriptExecute(BattleScript_BerryCurePsnEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_BRN: - if (gBattleMons[battlerId].status1 & STATUS1_BURN && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_BURN && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_BURN; + gBattleMons[battler].status1 &= ~STATUS1_BURN; BattleScriptExecute(BattleScript_BerryCureBrnEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_FRZ: - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FREEZE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FREEZE; + gBattleMons[battler].status1 &= ~STATUS1_FREEZE; BattleScriptExecute(BattleScript_BerryCureFrzEnd2); effect = ITEM_STATUS_CHANGE; } - if (gBattleMons[battlerId].status1 & STATUS1_FROSTBITE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FROSTBITE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FROSTBITE; + gBattleMons[battler].status1 &= ~STATUS1_FROSTBITE; BattleScriptExecute(BattleScript_BerryCureFsbEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_SLP: - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_SLEEP && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_SLEEP; - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status1 &= ~STATUS1_SLEEP; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; BattleScriptExecute(BattleScript_BerryCureSlpEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_STATUS: - if ((gBattleMons[battlerId].status1 & STATUS1_ANY || gBattleMons[battlerId].status2 & STATUS2_CONFUSION) && !UnnerveOn(battlerId, gLastUsedItem)) + if ((gBattleMons[battler].status1 & STATUS1_ANY || gBattleMons[battler].status2 & STATUS2_CONFUSION) && !UnnerveOn(battler, gLastUsedItem)) { i = 0; - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY) { StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS) { StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_BURN) + if (gBattleMons[battler].status1 & STATUS1_BURN) { StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE || gBattleMons[battlerId].status1 & STATUS1_FROSTBITE) + if (gBattleMons[battler].status1 & STATUS1_FREEZE || gBattleMons[battler].status1 & STATUS1_FROSTBITE) { StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn); i++; } - if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION) { StringCopy(gBattleTextBuff1, gStatusConditionString_ConfusionJpn); i++; @@ -7091,56 +7085,56 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM; else gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_NORMALIZED_STATUS; - gBattleMons[battlerId].status1 = 0; - RemoveConfusionStatus(battlerId); + gBattleMons[battler].status1 = 0; + RemoveConfusionStatus(battler); BattleScriptExecute(BattleScript_BerryCureChosenStatusEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_RESTORE_HP: - effect = ItemHealHp(battlerId, gLastUsedItem, TRUE, FALSE); + effect = ItemHealHp(battler, gLastUsedItem, TRUE, FALSE); break; case HOLD_EFFECT_RESTORE_PCT_HP: - effect = ItemHealHp(battlerId, gLastUsedItem, TRUE, TRUE); + effect = ItemHealHp(battler, gLastUsedItem, TRUE, TRUE); break; #endif case HOLD_EFFECT_AIR_BALLOON: effect = ITEM_EFFECT_OTHER; - gBattleScripting.battler = battlerId; + gBattleScripting.battler = battler; BattleScriptPushCursorAndCallback(BattleScript_AirBaloonMsgIn); - RecordItemEffectBattle(battlerId, HOLD_EFFECT_AIR_BALLOON); + RecordItemEffectBattle(battler, HOLD_EFFECT_AIR_BALLOON); break; case HOLD_EFFECT_ROOM_SERVICE: - if (TryRoomService(battlerId)) + if (TryRoomService(battler)) { BattleScriptExecute(BattleScript_BerryStatRaiseEnd2); effect = ITEM_STATS_CHANGE; } break; case HOLD_EFFECT_SEEDS: - switch (GetBattlerHoldEffectParam(battlerId)) + switch (GetBattlerHoldEffectParam(battler)) { case HOLD_EFFECT_PARAM_ELECTRIC_TERRAIN: - effect = TryHandleSeed(battlerId, STATUS_FIELD_ELECTRIC_TERRAIN, STAT_DEF, gLastUsedItem, TRUE); + effect = TryHandleSeed(battler, STATUS_FIELD_ELECTRIC_TERRAIN, STAT_DEF, gLastUsedItem, TRUE); break; case HOLD_EFFECT_PARAM_GRASSY_TERRAIN: - effect = TryHandleSeed(battlerId, STATUS_FIELD_GRASSY_TERRAIN, STAT_DEF, gLastUsedItem, TRUE); + effect = TryHandleSeed(battler, STATUS_FIELD_GRASSY_TERRAIN, STAT_DEF, gLastUsedItem, TRUE); break; case HOLD_EFFECT_PARAM_MISTY_TERRAIN: - effect = TryHandleSeed(battlerId, STATUS_FIELD_MISTY_TERRAIN, STAT_SPDEF, gLastUsedItem, TRUE); + effect = TryHandleSeed(battler, STATUS_FIELD_MISTY_TERRAIN, STAT_SPDEF, gLastUsedItem, TRUE); break; case HOLD_EFFECT_PARAM_PSYCHIC_TERRAIN: - effect = TryHandleSeed(battlerId, STATUS_FIELD_PSYCHIC_TERRAIN, STAT_SPDEF, gLastUsedItem, TRUE); + effect = TryHandleSeed(battler, STATUS_FIELD_PSYCHIC_TERRAIN, STAT_SPDEF, gLastUsedItem, TRUE); break; } break; case HOLD_EFFECT_EJECT_PACK: - if (gProtectStructs[battlerId].statFell - && gProtectStructs[battlerId].disableEjectPack == 0 + if (gProtectStructs[battler].statFell + && gProtectStructs[battler].disableEjectPack == 0 && !(gCurrentMove == MOVE_PARTING_SHOT && CanBattlerSwitch(gBattlerAttacker))) // Does not activate if attacker used Parting Shot and can switch out { - gProtectStructs[battlerId].statFell = FALSE; - gActiveBattler = gBattleScripting.battler = battlerId; + gProtectStructs[battler].statFell = FALSE; + gActiveBattler = gBattleScripting.battler = battler; effect = ITEM_STATS_CHANGE; if (moveTurn) { @@ -7154,8 +7148,8 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_BERSERK_GENE: - BufferStatChange(battlerId, STAT_ATK, STRINGID_STATROSE); - gEffectBattler = battlerId; + BufferStatChange(battler, STAT_ATK, STRINGID_STATROSE); + gEffectBattler = battler; if (CanBeInfinitelyConfused(gEffectBattler)) { gStatuses4[gEffectBattler] |= STATUS4_INFINITE_CONFUSION; @@ -7171,40 +7165,40 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } if (effect != 0) { - gSpecialStatuses[battlerId].switchInItemDone = TRUE; - gActiveBattler = gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battlerId; + gSpecialStatuses[battler].switchInItemDone = TRUE; + gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battler; switch (effect) { case ITEM_STATUS_CHANGE: - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battlerId].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); break; case ITEM_PP_CHANGE: - if (MOVE_IS_PERMANENT(battlerId, i)) - gBattleMons[battlerId].pp[i] = changedPP; + if (MOVE_IS_PERMANENT(battler, i)) + gBattleMons[battler].pp[i] = changedPP; break; } } } break; case ITEMEFFECT_NORMAL: - if (gBattleMons[battlerId].hp) + if (gBattleMons[battler].hp) { switch (battlerHoldEffect) { case HOLD_EFFECT_RESTORE_HP: if (!moveTurn) - effect = ItemHealHp(battlerId, gLastUsedItem, TRUE, FALSE); + effect = ItemHealHp(battler, gLastUsedItem, TRUE, FALSE); break; case HOLD_EFFECT_RESTORE_PCT_HP: if (!moveTurn) - effect = ItemHealHp(battlerId, gLastUsedItem, TRUE, TRUE); + effect = ItemHealHp(battler, gLastUsedItem, TRUE, TRUE); break; case HOLD_EFFECT_RESTORE_PP: if (!moveTurn) { - struct Pokemon *party = GetBattlerParty(battlerId); - struct Pokemon *mon = &party[gBattlerPartyIndexes[battlerId]]; + struct Pokemon *party = GetBattlerParty(battler); + struct Pokemon *mon = &party[gBattlerPartyIndexes[battler]]; u8 ppBonuses; u16 move; @@ -7219,12 +7213,12 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) if (i != MAX_MON_MOVES) { u8 maxPP = CalculatePPWithBonus(move, ppBonuses, i); - u8 ppRestored = GetBattlerHoldEffectParam(battlerId); + u8 ppRestored = GetBattlerHoldEffectParam(battler); - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + if (GetBattlerAbility(battler) == ABILITY_RIPEN) { ppRestored *= 2; - gBattlerAbility = battlerId; + gBattlerAbility = battler; } if (changedPP + ppRestored > maxPP) changedPP = maxPP; @@ -7234,8 +7228,8 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) PREPARE_MOVE_BUFFER(gBattleTextBuff1, move); BattleScriptExecute(BattleScript_BerryPPHealEnd2); - BtlController_EmitSetMonData(BUFFER_A, i + REQUEST_PPMOVE1_BATTLE, 0, 1, &changedPP); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, i + REQUEST_PPMOVE1_BATTLE, 0, 1, &changedPP); + MarkBattlerForControllerExec(battler); effect = ITEM_PP_CHANGE; } } @@ -7243,193 +7237,193 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) case HOLD_EFFECT_RESTORE_STATS: for (i = 0; i < NUM_BATTLE_STATS; i++) { - if (gBattleMons[battlerId].statStages[i] < DEFAULT_STAT_STAGE) + if (gBattleMons[battler].statStages[i] < DEFAULT_STAT_STAGE) { - gBattleMons[battlerId].statStages[i] = DEFAULT_STAT_STAGE; + gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; effect = ITEM_STATS_CHANGE; } } if (effect != 0) { - gBattleScripting.battler = battlerId; - gPotentialItemEffectBattler = battlerId; - gActiveBattler = gBattlerAttacker = battlerId; + gBattleScripting.battler = battler; + gPotentialItemEffectBattler = battler; + gActiveBattler = gBattlerAttacker = battler; BattleScriptExecute(BattleScript_WhiteHerbEnd2); } break; case HOLD_EFFECT_BLACK_SLUDGE: - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_POISON)) + if (IS_BATTLER_OF_TYPE(battler, TYPE_POISON)) { goto LEFTOVERS; } - else if (GetBattlerAbility(battlerId) != ABILITY_MAGIC_GUARD && !moveTurn) + else if (GetBattlerAbility(battler) != ABILITY_MAGIC_GUARD && !moveTurn) { - gBattleMoveDamage = gBattleMons[battlerId].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; BattleScriptExecute(BattleScript_ItemHurtEnd2); effect = ITEM_HP_CHANGE; - RecordItemEffectBattle(battlerId, battlerHoldEffect); + RecordItemEffectBattle(battler, battlerHoldEffect); PREPARE_ITEM_BUFFER(gBattleTextBuff1, gLastUsedItem); } break; case HOLD_EFFECT_LEFTOVERS: LEFTOVERS: #if B_HEAL_BLOCKING >= GEN_5 - if (gBattleMons[battlerId].hp < gBattleMons[battlerId].maxHP && !moveTurn && !(gStatuses3[battlerId] & STATUS3_HEAL_BLOCK)) + if (gBattleMons[battler].hp < gBattleMons[battler].maxHP && !moveTurn && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK)) #else - if (gBattleMons[battlerId].hp < gBattleMons[battlerId].maxHP && !moveTurn) + if (gBattleMons[battler].hp < gBattleMons[battler].maxHP && !moveTurn) #endif { - gBattleMoveDamage = gBattleMons[battlerId].maxHP / 16; + gBattleMoveDamage = gBattleMons[battler].maxHP / 16; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; gBattleMoveDamage *= -1; BattleScriptExecute(BattleScript_ItemHealHP_End2); effect = ITEM_HP_CHANGE; - RecordItemEffectBattle(battlerId, battlerHoldEffect); + RecordItemEffectBattle(battler, battlerHoldEffect); } break; case HOLD_EFFECT_CONFUSE_SPICY: if (!moveTurn) - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SPICY, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SPICY, TRUE); break; case HOLD_EFFECT_CONFUSE_DRY: if (!moveTurn) - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_DRY, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_DRY, TRUE); break; case HOLD_EFFECT_CONFUSE_SWEET: if (!moveTurn) - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SWEET, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SWEET, TRUE); break; case HOLD_EFFECT_CONFUSE_BITTER: if (!moveTurn) - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_BITTER, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_BITTER, TRUE); break; case HOLD_EFFECT_CONFUSE_SOUR: if (!moveTurn) - effect = HealConfuseBerry(battlerId, gLastUsedItem, FLAVOR_SOUR, TRUE); + effect = HealConfuseBerry(battler, gLastUsedItem, FLAVOR_SOUR, TRUE); break; case HOLD_EFFECT_ATTACK_UP: if (!moveTurn) - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_ATK, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_ATK, TRUE); break; case HOLD_EFFECT_DEFENSE_UP: if (!moveTurn) - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_DEF, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_DEF, TRUE); break; case HOLD_EFFECT_SPEED_UP: if (!moveTurn) - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPEED, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPEED, TRUE); break; case HOLD_EFFECT_SP_ATTACK_UP: if (!moveTurn) - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPATK, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPATK, TRUE); break; case HOLD_EFFECT_SP_DEFENSE_UP: if (!moveTurn) - effect = StatRaiseBerry(battlerId, gLastUsedItem, STAT_SPDEF, TRUE); + effect = StatRaiseBerry(battler, gLastUsedItem, STAT_SPDEF, TRUE); break; case HOLD_EFFECT_CRITICAL_UP: - if (!moveTurn && !(gBattleMons[battlerId].status2 & STATUS2_FOCUS_ENERGY) - && HasEnoughHpToEatBerry(battlerId, GetBattlerItemHoldEffectParam(battlerId, gLastUsedItem), gLastUsedItem)) + if (!moveTurn && !(gBattleMons[battler].status2 & STATUS2_FOCUS_ENERGY) + && HasEnoughHpToEatBerry(battler, GetBattlerItemHoldEffectParam(battler, gLastUsedItem), gLastUsedItem)) { - gBattleMons[battlerId].status2 |= STATUS2_FOCUS_ENERGY; - gBattleScripting.battler = battlerId; + gBattleMons[battler].status2 |= STATUS2_FOCUS_ENERGY; + gBattleScripting.battler = battler; BattleScriptExecute(BattleScript_BerryFocusEnergyEnd2); effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_RANDOM_STAT_UP: if (!moveTurn) - effect = RandomStatRaiseBerry(battlerId, gLastUsedItem, TRUE); + effect = RandomStatRaiseBerry(battler, gLastUsedItem, TRUE); break; case HOLD_EFFECT_CURE_PAR: - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_PARALYSIS; + gBattleMons[battler].status1 &= ~STATUS1_PARALYSIS; BattleScriptExecute(BattleScript_BerryCurePrlzEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_PSN: - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); + gBattleMons[battler].status1 &= ~(STATUS1_PSN_ANY | STATUS1_TOXIC_COUNTER); BattleScriptExecute(BattleScript_BerryCurePsnEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_BRN: - if (gBattleMons[battlerId].status1 & STATUS1_BURN && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_BURN && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_BURN; + gBattleMons[battler].status1 &= ~STATUS1_BURN; BattleScriptExecute(BattleScript_BerryCureBrnEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_FRZ: - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FREEZE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FREEZE; + gBattleMons[battler].status1 &= ~STATUS1_FREEZE; BattleScriptExecute(BattleScript_BerryCureFrzEnd2); effect = ITEM_STATUS_CHANGE; } - if (gBattleMons[battlerId].status1 & STATUS1_FROSTBITE && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_FROSTBITE && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_FROSTBITE; + gBattleMons[battler].status1 &= ~STATUS1_FROSTBITE; BattleScriptExecute(BattleScript_BerryCureFsbEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_SLP: - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status1 & STATUS1_SLEEP && !UnnerveOn(battler, gLastUsedItem)) { - gBattleMons[battlerId].status1 &= ~STATUS1_SLEEP; - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status1 &= ~STATUS1_SLEEP; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; BattleScriptExecute(BattleScript_BerryCureSlpEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_CURE_CONFUSION: - if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION && !UnnerveOn(battlerId, gLastUsedItem)) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION && !UnnerveOn(battler, gLastUsedItem)) { - RemoveConfusionStatus(battlerId); + RemoveConfusionStatus(battler); BattleScriptExecute(BattleScript_BerryCureConfusionEnd2); effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_CURE_STATUS: - if ((gBattleMons[battlerId].status1 & STATUS1_ANY || gBattleMons[battlerId].status2 & STATUS2_CONFUSION) && !UnnerveOn(battlerId, gLastUsedItem)) + if ((gBattleMons[battler].status1 & STATUS1_ANY || gBattleMons[battler].status2 & STATUS2_CONFUSION) && !UnnerveOn(battler, gLastUsedItem)) { i = 0; - if (gBattleMons[battlerId].status1 & STATUS1_PSN_ANY) + if (gBattleMons[battler].status1 & STATUS1_PSN_ANY) { StringCopy(gBattleTextBuff1, gStatusConditionString_PoisonJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { - gBattleMons[battlerId].status2 &= ~STATUS2_NIGHTMARE; + gBattleMons[battler].status2 &= ~STATUS2_NIGHTMARE; StringCopy(gBattleTextBuff1, gStatusConditionString_SleepJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_PARALYSIS) + if (gBattleMons[battler].status1 & STATUS1_PARALYSIS) { StringCopy(gBattleTextBuff1, gStatusConditionString_ParalysisJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_BURN) + if (gBattleMons[battler].status1 & STATUS1_BURN) { StringCopy(gBattleTextBuff1, gStatusConditionString_BurnJpn); i++; } - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE || gBattleMons[battlerId].status1 & STATUS1_FROSTBITE) + if (gBattleMons[battler].status1 & STATUS1_FREEZE || gBattleMons[battler].status1 & STATUS1_FROSTBITE) { StringCopy(gBattleTextBuff1, gStatusConditionString_IceJpn); i++; } - if (gBattleMons[battlerId].status2 & STATUS2_CONFUSION) + if (gBattleMons[battler].status2 & STATUS2_CONFUSION) { StringCopy(gBattleTextBuff1, gStatusConditionString_ConfusionJpn); i++; @@ -7438,28 +7432,28 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_CURED_PROBLEM; else gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_NORMALIZED_STATUS; - gBattleMons[battlerId].status1 = 0; - RemoveConfusionStatus(battlerId); + gBattleMons[battler].status1 = 0; + RemoveConfusionStatus(battler); BattleScriptExecute(BattleScript_BerryCureChosenStatusEnd2); effect = ITEM_STATUS_CHANGE; } break; case HOLD_EFFECT_MENTAL_HERB: - if (GetMentalHerbEffect(battlerId)) + if (GetMentalHerbEffect(battler)) { gBattleScripting.savedBattler = gBattlerAttacker; - gBattlerAttacker = battlerId; + gBattlerAttacker = battler; BattleScriptExecute(BattleScript_MentalHerbCureEnd2); effect = ITEM_EFFECT_OTHER; } break; case HOLD_EFFECT_MICLE_BERRY: if (!moveTurn) - effect = TrySetMicleBerry(battlerId, gLastUsedItem, TRUE); + effect = TrySetMicleBerry(battler, gLastUsedItem, TRUE); break; case HOLD_EFFECT_BERSERK_GENE: - BufferStatChange(battlerId, STAT_ATK, STRINGID_STATROSE); - gEffectBattler = battlerId; + BufferStatChange(battler, STAT_ATK, STRINGID_STATROSE); + gEffectBattler = battler; if (CanBeInfinitelyConfused(gEffectBattler)) { gStatuses4[gEffectBattler] |= STATUS4_INFINITE_CONFUSION; @@ -7473,53 +7467,53 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) effect = ITEM_STATS_CHANGE; break; case HOLD_EFFECT_MIRROR_HERB: - effect = TryConsumeMirrorHerb(battlerId, TRUE); + effect = TryConsumeMirrorHerb(battler, TRUE); break; } if (effect != 0) { - gActiveBattler = gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battlerId; + gBattlerAttacker = gPotentialItemEffectBattler = gBattleScripting.battler = battler; switch (effect) { case ITEM_STATUS_CHANGE: - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battlerId].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); break; case ITEM_PP_CHANGE: - if (MOVE_IS_PERMANENT(battlerId, i)) - gBattleMons[battlerId].pp[i] = changedPP; + if (MOVE_IS_PERMANENT(battler, i)) + gBattleMons[battler].pp[i] = changedPP; break; } } } break; case ITEMEFFECT_USE_LAST_ITEM: - effect = ItemEffectMoveEnd(battlerId, ItemId_GetHoldEffect(gLastUsedItem)); + effect = ItemEffectMoveEnd(battler, ItemId_GetHoldEffect(gLastUsedItem)); gBattleScripting.overrideBerryRequirements = 2; // to exit VARIOUS_CONSUME_BERRIES if (effect) { - gActiveBattler = gPotentialItemEffectBattler = gBattleScripting.battler = battlerId; + gPotentialItemEffectBattler = gBattleScripting.battler = battler; if (effect == ITEM_STATUS_CHANGE) { - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } break; } break; case ITEMEFFECT_MOVE_END: - for (battlerId = 0; battlerId < gBattlersCount; battlerId++) + for (battler = 0; battler < gBattlersCount; battler++) { - gLastUsedItem = gBattleMons[battlerId].item; - effect = ItemEffectMoveEnd(battlerId, GetBattlerHoldEffect(battlerId, TRUE)); + gLastUsedItem = gBattleMons[battler].item; + effect = ItemEffectMoveEnd(battler, GetBattlerHoldEffect(battler, TRUE)); if (effect) { - gActiveBattler = gPotentialItemEffectBattler = gBattleScripting.battler = battlerId; + gPotentialItemEffectBattler = gBattleScripting.battler = battler; if (effect == ITEM_STATUS_CHANGE) { - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } break; } @@ -7575,7 +7569,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) && gBattlerAttacker != gBattlerTarget && gBattleMons[gBattlerAttacker].hp != gBattleMons[gBattlerAttacker].maxHP #if B_HEAL_BLOCKING >= GEN_5 - && gBattleMons[gBattlerAttacker].hp != 0 && !(gStatuses3[battlerId] & STATUS3_HEAL_BLOCK)) + && gBattleMons[gBattlerAttacker].hp != 0 && !(gStatuses3[battler] & STATUS3_HEAL_BLOCK)) #else && gBattleMons[gBattlerAttacker].hp != 0) #endif @@ -7651,11 +7645,11 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_RockyHelmetActivates; PREPARE_ITEM_BUFFER(gBattleTextBuff1, gLastUsedItem); - RecordItemEffectBattle(battlerId, HOLD_EFFECT_ROCKY_HELMET); + RecordItemEffectBattle(battler, HOLD_EFFECT_ROCKY_HELMET); } break; case HOLD_EFFECT_WEAKNESS_POLICY: - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED && gMoveResultFlags & MOVE_RESULT_SUPER_EFFECTIVE) { @@ -7665,7 +7659,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_SNOWBALL: - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED && moveType == TYPE_ICE) { @@ -7676,7 +7670,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_LUMINOUS_MOSS: - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED && moveType == TYPE_WATER) { @@ -7687,7 +7681,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_CELL_BATTERY: - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED && moveType == TYPE_ELECTRIC) { @@ -7698,7 +7692,7 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_ABSORB_BULB: - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED && moveType == TYPE_WATER) { @@ -7709,62 +7703,62 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) } break; case HOLD_EFFECT_JABOCA_BERRY: // consume and damage attacker if used physical move - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED - && !DoesSubstituteBlockMove(gBattlerAttacker, battlerId, gCurrentMove) + && !DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && IS_MOVE_PHYSICAL(gCurrentMove) && GetBattlerAbility(gBattlerAttacker) != ABILITY_MAGIC_GUARD) { gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + if (GetBattlerAbility(battler) == ABILITY_RIPEN) gBattleMoveDamage *= 2; effect = ITEM_HP_CHANGE; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_JabocaRowapBerryActivates; PREPARE_ITEM_BUFFER(gBattleTextBuff1, gLastUsedItem); - RecordItemEffectBattle(battlerId, HOLD_EFFECT_ROCKY_HELMET); + RecordItemEffectBattle(battler, HOLD_EFFECT_ROCKY_HELMET); } break; case HOLD_EFFECT_ROWAP_BERRY: // consume and damage attacker if used special move - if (IsBattlerAlive(battlerId) + if (IsBattlerAlive(battler) && TARGET_TURN_DAMAGED - && !DoesSubstituteBlockMove(gBattlerAttacker, battlerId, gCurrentMove) + && !DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && IS_MOVE_SPECIAL(gCurrentMove) && GetBattlerAbility(gBattlerAttacker) != ABILITY_MAGIC_GUARD) { gBattleMoveDamage = gBattleMons[gBattlerAttacker].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; - if (GetBattlerAbility(battlerId) == ABILITY_RIPEN) + if (GetBattlerAbility(battler) == ABILITY_RIPEN) gBattleMoveDamage *= 2; effect = ITEM_HP_CHANGE; BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_JabocaRowapBerryActivates; PREPARE_ITEM_BUFFER(gBattleTextBuff1, gLastUsedItem); - RecordItemEffectBattle(battlerId, HOLD_EFFECT_ROCKY_HELMET); + RecordItemEffectBattle(battler, HOLD_EFFECT_ROCKY_HELMET); } break; case HOLD_EFFECT_KEE_BERRY: // consume and boost defense if used physical move - effect = DamagedStatBoostBerryEffect(battlerId, STAT_DEF, SPLIT_PHYSICAL); + effect = DamagedStatBoostBerryEffect(battler, STAT_DEF, SPLIT_PHYSICAL); break; case HOLD_EFFECT_MARANGA_BERRY: // consume and boost sp. defense if used special move - effect = DamagedStatBoostBerryEffect(battlerId, STAT_SPDEF, SPLIT_SPECIAL); + effect = DamagedStatBoostBerryEffect(battler, STAT_SPDEF, SPLIT_SPECIAL); break; case HOLD_EFFECT_STICKY_BARB: if (TARGET_TURN_DAMAGED && (!(gMoveResultFlags & MOVE_RESULT_NO_EFFECT)) && IsMoveMakingContact(gCurrentMove, gBattlerAttacker) - && !DoesSubstituteBlockMove(gBattlerAttacker, battlerId, gCurrentMove) + && !DoesSubstituteBlockMove(gBattlerAttacker, battler, gCurrentMove) && IsBattlerAlive(gBattlerAttacker) && CanStealItem(gBattlerAttacker, gBattlerTarget, gBattleMons[gBattlerTarget].item) && gBattleMons[gBattlerAttacker].item == ITEM_NONE) { // No sticky hold checks. - gEffectBattler = battlerId; // gEffectBattler = target + gEffectBattler = battler; // gEffectBattler = target StealTargetItem(gBattlerAttacker, gBattlerTarget); // Attacker takes target's barb BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_StickyBarbTransfer; @@ -7776,36 +7770,36 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) break; case ITEMEFFECT_ORBS: { - u16 battlerAbility = GetBattlerAbility(battlerId); + u16 battlerAbility = GetBattlerAbility(battler); switch (battlerHoldEffect) { case HOLD_EFFECT_TOXIC_ORB: - if (CanBePoisoned(battlerId, battlerId)) + if (CanBePoisoned(battler, battler)) { effect = ITEM_STATUS_CHANGE; - gBattleMons[battlerId].status1 = STATUS1_TOXIC_POISON; + gBattleMons[battler].status1 = STATUS1_TOXIC_POISON; BattleScriptExecute(BattleScript_ToxicOrb); - RecordItemEffectBattle(battlerId, battlerHoldEffect); + RecordItemEffectBattle(battler, battlerHoldEffect); } break; case HOLD_EFFECT_FLAME_ORB: - if (CanBeBurned(battlerId)) + if (CanBeBurned(battler)) { effect = ITEM_STATUS_CHANGE; - gBattleMons[battlerId].status1 = STATUS1_BURN; + gBattleMons[battler].status1 = STATUS1_BURN; BattleScriptExecute(BattleScript_FlameOrb); - RecordItemEffectBattle(battlerId, battlerHoldEffect); + RecordItemEffectBattle(battler, battlerHoldEffect); } break; case HOLD_EFFECT_STICKY_BARB: // Not an orb per se, but similar effect, and needs to NOT activate with pickpocket if (battlerAbility != ABILITY_MAGIC_GUARD) { - gBattleMoveDamage = gBattleMons[battlerId].maxHP / 8; + gBattleMoveDamage = gBattleMons[battler].maxHP / 8; if (gBattleMoveDamage == 0) gBattleMoveDamage = 1; BattleScriptExecute(BattleScript_ItemHurtEnd2); effect = ITEM_HP_CHANGE; - RecordItemEffectBattle(battlerId, battlerHoldEffect); + RecordItemEffectBattle(battler, battlerHoldEffect); PREPARE_ITEM_BUFFER(gBattleTextBuff1, gLastUsedItem); } break; @@ -7813,9 +7807,8 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) if (effect == ITEM_STATUS_CHANGE) { - gActiveBattler = battlerId; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battlerId].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } } break; @@ -7823,16 +7816,16 @@ u8 ItemBattleEffects(u8 caseID, u8 battlerId, bool8 moveTurn) // Berry was successfully used on a Pokemon. if (effect && (gLastUsedItem >= FIRST_BERRY_INDEX && gLastUsedItem <= LAST_BERRY_INDEX)) - gBattleStruct->ateBerry[battlerId & BIT_SIDE] |= gBitTable[gBattlerPartyIndexes[battlerId]]; + gBattleStruct->ateBerry[battler & BIT_SIDE] |= gBitTable[gBattlerPartyIndexes[battler]]; return effect; } -void ClearFuryCutterDestinyBondGrudge(u8 battlerId) +void ClearFuryCutterDestinyBondGrudge(u8 battler) { - gDisableStructs[battlerId].furyCutterCounter = 0; - gBattleMons[battlerId].status2 &= ~STATUS2_DESTINY_BOND; - gStatuses3[battlerId] &= ~STATUS3_GRUDGE; + gDisableStructs[battler].furyCutterCounter = 0; + gBattleMons[battler].status2 &= ~STATUS2_DESTINY_BOND; + gStatuses3[battler] &= ~STATUS3_GRUDGE; } void HandleAction_RunBattleScript(void) // identical to RunBattleScriptCommands @@ -7841,7 +7834,7 @@ void HandleAction_RunBattleScript(void) // identical to RunBattleScriptCommands gBattleScriptingCommandsTable[*gBattlescriptCurrInstr](); } -u32 SetRandomTarget(u32 battlerId) +u32 SetRandomTarget(u32 battler) { u32 target; static const u8 targets[2][2] = @@ -7852,13 +7845,13 @@ u32 SetRandomTarget(u32 battlerId) if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) { - target = GetBattlerAtPosition(targets[GetBattlerSide(battlerId)][Random() % 2]); + target = GetBattlerAtPosition(targets[GetBattlerSide(battler)][Random() % 2]); if (!IsBattlerAlive(target)) target ^= BIT_FLANK; } else { - target = GetBattlerAtPosition(targets[GetBattlerSide(battlerId)][0]); + target = GetBattlerAtPosition(targets[GetBattlerSide(battler)][0]); } return target; @@ -7942,14 +7935,14 @@ u32 GetMoveTarget(u16 move, u8 setTarget) return targetBattler; } -static bool32 IsBattlerModernFatefulEncounter(u8 battlerId) +static bool32 IsBattlerModernFatefulEncounter(u8 battler) { - if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT) + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) return TRUE; - if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES, NULL) != SPECIES_DEOXYS - && GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES, NULL) != SPECIES_MEW) + if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL) != SPECIES_DEOXYS + && GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES, NULL) != SPECIES_MEW) return TRUE; - return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_MODERN_FATEFUL_ENCOUNTER, NULL); + return GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MODERN_FATEFUL_ENCOUNTER, NULL); } u8 IsMonDisobedient(void) @@ -8079,40 +8072,40 @@ u8 IsMonDisobedient(void) } } -u32 GetBattlerHoldEffect(u8 battlerId, bool32 checkNegating) +u32 GetBattlerHoldEffect(u8 battler, bool32 checkNegating) { if (checkNegating) { - if (gStatuses3[battlerId] & STATUS3_EMBARGO) + if (gStatuses3[battler] & STATUS3_EMBARGO) return HOLD_EFFECT_NONE; if (gFieldStatuses & STATUS_FIELD_MAGIC_ROOM) return HOLD_EFFECT_NONE; - if (GetBattlerAbility(battlerId) == ABILITY_KLUTZ) + if (GetBattlerAbility(battler) == ABILITY_KLUTZ) return HOLD_EFFECT_NONE; } - gPotentialItemEffectBattler = battlerId; + gPotentialItemEffectBattler = battler; - if (gBattleMons[battlerId].item == ITEM_ENIGMA_BERRY_E_READER) - return gEnigmaBerries[battlerId].holdEffect; + if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY_E_READER) + return gEnigmaBerries[battler].holdEffect; else - return ItemId_GetHoldEffect(gBattleMons[battlerId].item); + return ItemId_GetHoldEffect(gBattleMons[battler].item); } -static u32 GetBattlerItemHoldEffectParam(u8 battlerId, u16 item) +static u32 GetBattlerItemHoldEffectParam(u8 battler, u16 item) { if (item == ITEM_ENIGMA_BERRY_E_READER) - return gEnigmaBerries[battlerId].holdEffectParam; + return gEnigmaBerries[battler].holdEffectParam; else return ItemId_GetHoldEffectParam(item); } -u32 GetBattlerHoldEffectParam(u8 battlerId) +u32 GetBattlerHoldEffectParam(u8 battler) { - if (gBattleMons[battlerId].item == ITEM_ENIGMA_BERRY_E_READER) - return gEnigmaBerries[battlerId].holdEffectParam; + if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY_E_READER) + return gEnigmaBerries[battler].holdEffectParam; else - return ItemId_GetHoldEffectParam(gBattleMons[battlerId].item); + return ItemId_GetHoldEffectParam(gBattleMons[battler].item); } bool32 IsMoveMakingContact(u16 move, u8 battlerAtk) @@ -8138,14 +8131,14 @@ bool32 IsMoveMakingContact(u16 move, u8 battlerAtk) } } -bool32 IsBattlerProtected(u8 battlerId, u16 move) +bool32 IsBattlerProtected(u8 battler, u16 move) { // Decorate bypasses protect and detect, but not crafty shield if (move == MOVE_DECORATE) { - if (gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_CRAFTY_SHIELD) + if (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_CRAFTY_SHIELD) return TRUE; - else if (gProtectStructs[battlerId].protected) + else if (gProtectStructs[battler].protected) return FALSE; } @@ -8169,26 +8162,26 @@ bool32 IsBattlerProtected(u8 battlerId, u16 move) return FALSE; else if (gBattleMoves[move].effect == EFFECT_FEINT) return FALSE; - else if (gProtectStructs[battlerId].protected) + else if (gProtectStructs[battler].protected) return TRUE; - else if (gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_WIDE_GUARD + else if (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_WIDE_GUARD && GetBattlerMoveTargetType(gBattlerAttacker, move) & (MOVE_TARGET_BOTH | MOVE_TARGET_FOES_AND_ALLY)) return TRUE; - else if (gProtectStructs[battlerId].banefulBunkered) + else if (gProtectStructs[battler].banefulBunkered) return TRUE; - else if ((gProtectStructs[battlerId].obstructed || gProtectStructs[battlerId].silkTrapped) && !IS_MOVE_STATUS(move)) + else if ((gProtectStructs[battler].obstructed || gProtectStructs[battler].silkTrapped) && !IS_MOVE_STATUS(move)) return TRUE; - else if (gProtectStructs[battlerId].spikyShielded) + else if (gProtectStructs[battler].spikyShielded) return TRUE; - else if (gProtectStructs[battlerId].kingsShielded && gBattleMoves[move].power != 0) + else if (gProtectStructs[battler].kingsShielded && gBattleMoves[move].power != 0) return TRUE; - else if (gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_QUICK_GUARD + else if (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_QUICK_GUARD && GetChosenMovePriority(gBattlerAttacker) > 0) return TRUE; - else if (gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_CRAFTY_SHIELD + else if (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_CRAFTY_SHIELD && IS_MOVE_STATUS(move)) return TRUE; - else if (gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_MAT_BLOCK + else if (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_MAT_BLOCK && !IS_MOVE_STATUS(move)) return TRUE; else @@ -8196,43 +8189,43 @@ bool32 IsBattlerProtected(u8 battlerId, u16 move) } // Only called directly when calculating damage type effectiveness -static bool32 IsBattlerGrounded2(u8 battlerId, bool32 considerInverse) +static bool32 IsBattlerGrounded2(u8 battler, bool32 considerInverse) { - if (GetBattlerHoldEffect(battlerId, TRUE) == HOLD_EFFECT_IRON_BALL) + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_IRON_BALL) return TRUE; if (gFieldStatuses & STATUS_FIELD_GRAVITY) return TRUE; #if B_ROOTED_GROUNDING >= GEN_4 - if (gStatuses3[battlerId] & STATUS3_ROOTED) + if (gStatuses3[battler] & STATUS3_ROOTED) return TRUE; #endif - if (gStatuses3[battlerId] & STATUS3_SMACKED_DOWN) + if (gStatuses3[battler] & STATUS3_SMACKED_DOWN) return TRUE; - if (gStatuses3[battlerId] & STATUS3_TELEKINESIS) + if (gStatuses3[battler] & STATUS3_TELEKINESIS) return FALSE; - if (gStatuses3[battlerId] & STATUS3_MAGNET_RISE) + if (gStatuses3[battler] & STATUS3_MAGNET_RISE) return FALSE; - if (GetBattlerHoldEffect(battlerId, TRUE) == HOLD_EFFECT_AIR_BALLOON) + if (GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_AIR_BALLOON) return FALSE; - if (GetBattlerAbility(battlerId) == ABILITY_LEVITATE) + if (GetBattlerAbility(battler) == ABILITY_LEVITATE) return FALSE; - if (IS_BATTLER_OF_TYPE(battlerId, TYPE_FLYING) && (!considerInverse || !FlagGet(B_FLAG_INVERSE_BATTLE))) + if (IS_BATTLER_OF_TYPE(battler, TYPE_FLYING) && (!considerInverse || !FlagGet(B_FLAG_INVERSE_BATTLE))) return FALSE; return TRUE; } -bool32 IsBattlerGrounded(u8 battlerId) +bool32 IsBattlerGrounded(u8 battler) { - IsBattlerGrounded2(battlerId, FALSE); + IsBattlerGrounded2(battler, FALSE); } -bool32 IsBattlerAlive(u8 battlerId) +bool32 IsBattlerAlive(u8 battler) { - if (gBattleMons[battlerId].hp == 0) + if (gBattleMons[battler].hp == 0) return FALSE; - else if (battlerId >= gBattlersCount) + else if (battler >= gBattlersCount) return FALSE; - else if (gAbsentBattlerFlags & gBitTable[battlerId]) + else if (gAbsentBattlerFlags & gBitTable[battler]) return FALSE; else return TRUE; @@ -8250,12 +8243,12 @@ u8 GetBattleMonMoveSlot(struct BattlePokemon *battleMon, u16 move) return i; } -u32 GetBattlerWeight(u8 battlerId) +u32 GetBattlerWeight(u8 battler) { u32 i; - u32 weight = GetPokedexHeightWeight(SpeciesToNationalPokedexNum(gBattleMons[battlerId].species), 1); - u32 ability = GetBattlerAbility(battlerId); - u32 holdEffect = GetBattlerHoldEffect(battlerId, TRUE); + u32 weight = GetPokedexHeightWeight(SpeciesToNationalPokedexNum(gBattleMons[battler].species), 1); + u32 ability = GetBattlerAbility(battler); + u32 holdEffect = GetBattlerHoldEffect(battler, TRUE); if (ability == ABILITY_HEAVY_METAL) weight *= 2; @@ -8265,7 +8258,7 @@ u32 GetBattlerWeight(u8 battlerId) if (holdEffect == HOLD_EFFECT_FLOAT_STONE) weight /= 2; - for (i = 0; i < gDisableStructs[battlerId].autotomizeCount; i++) + for (i = 0; i < gDisableStructs[battler].autotomizeCount; i++) { if (weight > 1000) { @@ -8284,7 +8277,7 @@ u32 GetBattlerWeight(u8 battlerId) return weight; } -u32 CountBattlerStatIncreases(u8 battlerId, bool32 countEvasionAcc) +u32 CountBattlerStatIncreases(u8 battler, bool32 countEvasionAcc) { u32 i; u32 count = 0; @@ -8293,8 +8286,8 @@ u32 CountBattlerStatIncreases(u8 battlerId, bool32 countEvasionAcc) { if ((i == STAT_ACC || i == STAT_EVASION) && !countEvasionAcc) continue; - if (gBattleMons[battlerId].statStages[i] > DEFAULT_STAT_STAGE) // Stat is increased. - count += gBattleMons[battlerId].statStages[i] - DEFAULT_STAT_STAGE; + if (gBattleMons[battler].statStages[i] > DEFAULT_STAT_STAGE) // Stat is increased. + count += gBattleMons[battler].statStages[i] - DEFAULT_STAT_STAGE; } return count; @@ -9573,7 +9566,7 @@ static inline uq4_12_t GetScreensModifier(u32 move, u32 battlerAtk, u32 battlerD return UQ_4_12(1.0); if (reflect || lightScreen || auroraVeil) return (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) ? UQ_4_12(0.667) : UQ_4_12(0.5); - return UQ_4_12(1.0); + return UQ_4_12(1.0); } static inline uq4_12_t GetCollisionCourseElectroDriftModifier(u32 move, uq4_12_t typeEffectivenessModifier) @@ -10058,20 +10051,20 @@ s32 GetStealthHazardDamageByTypesAndHP(u8 hazardType, u8 type1, u8 type2, u32 ma return dmg; } -s32 GetStealthHazardDamage(u8 hazardType, u8 battlerId) +s32 GetStealthHazardDamage(u8 hazardType, u8 battler) { - u8 type1 = gBattleMons[battlerId].type1; - u8 type2 = gBattleMons[battlerId].type2; - u32 maxHp = gBattleMons[battlerId].maxHP; + u8 type1 = gBattleMons[battler].type1; + u8 type2 = gBattleMons[battler].type2; + u32 maxHp = gBattleMons[battler].maxHP; return GetStealthHazardDamageByTypesAndHP(hazardType, type1, type2, maxHp); } -bool32 IsPartnerMonFromSameTrainer(u8 battlerId) +bool32 IsPartnerMonFromSameTrainer(u8 battler) { - if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT && gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) + if (GetBattlerSide(battler) == B_SIDE_OPPONENT && gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS) return FALSE; - else if (GetBattlerSide(battlerId) == B_SIDE_PLAYER && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) + else if (GetBattlerSide(battler) == B_SIDE_PLAYER && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) return FALSE; else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) return FALSE; @@ -10102,16 +10095,16 @@ bool32 DoesSpeciesUseHoldItemToChangeForm(u16 species, u16 heldItemId) return FALSE; } -bool32 CanMegaEvolve(u8 battlerId) +bool32 CanMegaEvolve(u8 battler) { u32 itemId, holdEffect, species; struct Pokemon *mon; - u8 battlerPosition = GetBattlerPosition(battlerId); - u8 partnerPosition = GetBattlerPosition(BATTLE_PARTNER(battlerId)); + u8 battlerPosition = GetBattlerPosition(battler); + u8 partnerPosition = GetBattlerPosition(BATTLE_PARTNER(battler)); struct MegaEvolutionData *mega = &(((struct ChooseMoveStruct *)(&gBattleResources->bufferA[gActiveBattler][4]))->mega); // Check if Player has a Mega Ring - if ((GetBattlerPosition(battlerId) == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBattlerPosition(battlerId) == B_POSITION_PLAYER_RIGHT)) + if ((GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)) && !CheckBagHasItem(ITEM_MEGA_RING, 1)) return FALSE; @@ -10120,34 +10113,34 @@ bool32 CanMegaEvolve(u8 battlerId) return FALSE; // Cannot use z move and mega evolve on same turn - if (gBattleStruct->zmove.toBeUsed[battlerId]) + if (gBattleStruct->zmove.toBeUsed[battler]) return FALSE; if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE - && IsPartnerMonFromSameTrainer(battlerId) - && (mega->alreadyEvolved[partnerPosition] || (mega->toEvolve & gBitTable[BATTLE_PARTNER(battlerId)]))) + && IsPartnerMonFromSameTrainer(battler) + && (mega->alreadyEvolved[partnerPosition] || (mega->toEvolve & gBitTable[BATTLE_PARTNER(battler)]))) return FALSE; // Check if mon is currently held by Sky Drop - if (gStatuses3[battlerId] & STATUS3_SKY_DROPPED) + if (gStatuses3[battler] & STATUS3_SKY_DROPPED) return FALSE; // Gets mon data. - if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT) - mon = &gEnemyParty[gBattlerPartyIndexes[battlerId]]; + if (GetBattlerSide(battler) == B_SIDE_OPPONENT) + mon = &gEnemyParty[gBattlerPartyIndexes[battler]]; else - mon = &gPlayerParty[gBattlerPartyIndexes[battlerId]]; + mon = &gPlayerParty[gBattlerPartyIndexes[battler]]; species = GetMonData(mon, MON_DATA_SPECIES); itemId = GetMonData(mon, MON_DATA_HELD_ITEM); if (itemId == ITEM_ENIGMA_BERRY_E_READER) - holdEffect = gEnigmaBerries[battlerId].holdEffect; + holdEffect = gEnigmaBerries[battler].holdEffect; else holdEffect = ItemId_GetHoldEffect(itemId); // Check if there is an entry in the evolution table for regular Mega Evolution. - if (GetBattleFormChangeTargetSpecies(battlerId, FORM_CHANGE_BATTLE_MEGA_EVOLUTION_ITEM) != SPECIES_NONE) + if (GetBattleFormChangeTargetSpecies(battler, FORM_CHANGE_BATTLE_MEGA_EVOLUTION_ITEM) != SPECIES_NONE) { // Can Mega Evolve via Mega Stone. if (holdEffect == HOLD_EFFECT_MEGA_STONE) @@ -10155,7 +10148,7 @@ bool32 CanMegaEvolve(u8 battlerId) } // Check if there is an entry in the evolution table for Wish Mega Evolution. - if (GetBattleFormChangeTargetSpecies(battlerId, FORM_CHANGE_BATTLE_MEGA_EVOLUTION_MOVE) != SPECIES_NONE) + if (GetBattleFormChangeTargetSpecies(battler, FORM_CHANGE_BATTLE_MEGA_EVOLUTION_MOVE) != SPECIES_NONE) { // Can't Wish Mega Evolve if holding a Z Crystal. if (holdEffect != HOLD_EFFECT_Z_CRYSTAL) @@ -10166,36 +10159,36 @@ bool32 CanMegaEvolve(u8 battlerId) return FALSE; } -bool32 IsBattlerMegaEvolved(u8 battlerId) +bool32 IsBattlerMegaEvolved(u8 battler) { // While Transform does copy stats and visuals, it shouldn't be counted as true Mega Evolution. - if (gBattleMons[battlerId].status2 & STATUS2_TRANSFORMED) + if (gBattleMons[battler].status2 & STATUS2_TRANSFORMED) return FALSE; - return (gSpeciesInfo[gBattleMons[battlerId].species].flags & SPECIES_FLAG_MEGA_EVOLUTION); + return (gSpeciesInfo[gBattleMons[battler].species].flags & SPECIES_FLAG_MEGA_EVOLUTION); } -bool32 IsBattlerPrimalReverted(u8 battlerId) +bool32 IsBattlerPrimalReverted(u8 battler) { // While Transform does copy stats and visuals, it shouldn't be counted as true Primal Revesion. - if (gBattleMons[battlerId].status2 & STATUS2_TRANSFORMED) + if (gBattleMons[battler].status2 & STATUS2_TRANSFORMED) return FALSE; - return (gSpeciesInfo[gBattleMons[battlerId].species].flags & SPECIES_FLAG_PRIMAL_REVERSION); + return (gSpeciesInfo[gBattleMons[battler].species].flags & SPECIES_FLAG_PRIMAL_REVERSION); } // Returns SPECIES_NONE if no form change is possible -u16 GetBattleFormChangeTargetSpecies(u8 battlerId, u16 method) +u16 GetBattleFormChangeTargetSpecies(u8 battler, u16 method) { u32 i, j; u16 targetSpecies = SPECIES_NONE; - u16 species = gBattleMons[battlerId].species; + u16 species = gBattleMons[battler].species; const struct FormChange *formChanges = gFormChangeTablePointers[species]; u16 heldItem; u32 ability; if (formChanges != NULL) { - heldItem = gBattleMons[battlerId].item; - ability = GetBattlerAbility(battlerId); + heldItem = gBattleMons[battler].item; + ability = GetBattlerAbility(battler); for (i = 0; formChanges[i].method != FORM_CHANGE_TERMINATOR; i++) { @@ -10209,20 +10202,20 @@ u16 GetBattleFormChangeTargetSpecies(u8 battlerId, u16 method) targetSpecies = formChanges[i].targetSpecies; break; case FORM_CHANGE_BATTLE_MEGA_EVOLUTION_MOVE: - if (gBattleMons[battlerId].moves[0] == formChanges[i].param1 - || gBattleMons[battlerId].moves[1] == formChanges[i].param1 - || gBattleMons[battlerId].moves[2] == formChanges[i].param1 - || gBattleMons[battlerId].moves[3] == formChanges[i].param1) + if (gBattleMons[battler].moves[0] == formChanges[i].param1 + || gBattleMons[battler].moves[1] == formChanges[i].param1 + || gBattleMons[battler].moves[2] == formChanges[i].param1 + || gBattleMons[battler].moves[3] == formChanges[i].param1) targetSpecies = formChanges[i].targetSpecies; break; case FORM_CHANGE_BATTLE_SWITCH: targetSpecies = formChanges[i].targetSpecies; break; case FORM_CHANGE_BATTLE_HP_PERCENT: - if (formChanges[i].param1 == GetBattlerAbility(battlerId)) + if (formChanges[i].param1 == GetBattlerAbility(battler)) { // We multiply by 100 to make sure that integer division doesn't mess with the health check. - u32 hpCheck = gBattleMons[battlerId].hp * 100 * 100 / gBattleMons[battlerId].maxHP; + u32 hpCheck = gBattleMons[battler].hp * 100 * 100 / gBattleMons[battler].maxHP; switch(formChanges[i].param2) { case HP_HIGHER_THAN: @@ -10240,7 +10233,7 @@ u16 GetBattleFormChangeTargetSpecies(u8 battlerId, u16 method) // Check if there is a required ability and if the battler's ability does not match it // or is suppressed. If so, revert to the no weather form. if (formChanges[i].param2 - && GetBattlerAbility(battlerId) != formChanges[i].param2 + && GetBattlerAbility(battler) != formChanges[i].param2 && formChanges[i].param1 == B_WEATHER_NONE) { targetSpecies = formChanges[i].targetSpecies; @@ -10258,7 +10251,7 @@ u16 GetBattleFormChangeTargetSpecies(u8 battlerId, u16 method) } break; case FORM_CHANGE_BATTLE_TURN_END: - if (formChanges[i].param1 == GetBattlerAbility(battlerId)) + if (formChanges[i].param1 == GetBattlerAbility(battler)) targetSpecies = formChanges[i].targetSpecies; break; } @@ -10269,43 +10262,43 @@ u16 GetBattleFormChangeTargetSpecies(u8 battlerId, u16 method) return targetSpecies; } -bool32 CanBattlerFormChange(u8 battlerId, u16 method) +bool32 CanBattlerFormChange(u8 battler, u16 method) { // Can't change form if transformed. - if (gBattleMons[battlerId].status2 & STATUS2_TRANSFORMED + if (gBattleMons[battler].status2 & STATUS2_TRANSFORMED && B_TRANSFORM_FORM_CHANGES >= GEN_5) return FALSE; // Mega Evolved Pokémon should always revert to normal upon fainting or ending the battle. - if (IsBattlerMegaEvolved(battlerId) && (method == FORM_CHANGE_FAINT || method == FORM_CHANGE_END_BATTLE)) + if (IsBattlerMegaEvolved(battler) && (method == FORM_CHANGE_FAINT || method == FORM_CHANGE_END_BATTLE)) return TRUE; - else if (IsBattlerPrimalReverted(battlerId) && (method == FORM_CHANGE_END_BATTLE)) + else if (IsBattlerPrimalReverted(battler) && (method == FORM_CHANGE_END_BATTLE)) return TRUE; - return DoesSpeciesHaveFormChangeMethod(gBattleMons[battlerId].species, method); + return DoesSpeciesHaveFormChangeMethod(gBattleMons[battler].species, method); } -bool32 TryBattleFormChange(u8 battlerId, u16 method) +bool32 TryBattleFormChange(u8 battler, u16 method) { - u8 monId = gBattlerPartyIndexes[battlerId]; - u8 side = GET_BATTLER_SIDE(battlerId); - struct Pokemon *party = GetBattlerParty(battlerId); + u8 monId = gBattlerPartyIndexes[battler]; + u8 side = GET_BATTLER_SIDE(battler); + struct Pokemon *party = GetBattlerParty(battler); u16 targetSpecies; - if (!CanBattlerFormChange(battlerId, method)) + if (!CanBattlerFormChange(battler, method)) return FALSE; - targetSpecies = GetBattleFormChangeTargetSpecies(battlerId, method); + targetSpecies = GetBattleFormChangeTargetSpecies(battler, method); if (targetSpecies == SPECIES_NONE) targetSpecies = GetFormChangeTargetSpecies(&party[monId], method, 0); if (targetSpecies != SPECIES_NONE) { // Saves the original species on the first form change for the player. if (gBattleStruct->changedSpecies[side][monId] == SPECIES_NONE) - gBattleStruct->changedSpecies[side][monId] = gBattleMons[battlerId].species; + gBattleStruct->changedSpecies[side][monId] = gBattleMons[battler].species; TryToSetBattleFormChangeMoves(&party[monId], method); SetMonData(&party[monId], MON_DATA_SPECIES, &targetSpecies); - gBattleMons[battlerId].species = targetSpecies; - RecalcBattlerStats(battlerId, &party[monId]); + gBattleMons[battler].species = targetSpecies; + RecalcBattlerStats(battler, &party[monId]); return TRUE; } else if (gBattleStruct->changedSpecies[side][monId] != SPECIES_NONE) @@ -10313,11 +10306,11 @@ bool32 TryBattleFormChange(u8 battlerId, u16 method) bool8 restoreSpecies = FALSE; // Mega Evolved Pokémon should always revert to normal upon fainting or ending the battle, so no need to add it to the form change tables. - if (IsBattlerMegaEvolved(battlerId) && (method == FORM_CHANGE_FAINT || method == FORM_CHANGE_END_BATTLE)) + if (IsBattlerMegaEvolved(battler) && (method == FORM_CHANGE_FAINT || method == FORM_CHANGE_END_BATTLE)) restoreSpecies = TRUE; // Unlike Megas, Primal Reversion isn't canceled on fainting. - else if (IsBattlerPrimalReverted(battlerId) && (method == FORM_CHANGE_END_BATTLE)) + else if (IsBattlerPrimalReverted(battler) && (method == FORM_CHANGE_END_BATTLE)) restoreSpecies = TRUE; if (restoreSpecies) @@ -10325,7 +10318,7 @@ bool32 TryBattleFormChange(u8 battlerId, u16 method) // Reverts the original species TryToSetBattleFormChangeMoves(&party[monId], method); SetMonData(&party[monId], MON_DATA_SPECIES, &gBattleStruct->changedSpecies[side][monId]); - RecalcBattlerStats(battlerId, &party[monId]); + RecalcBattlerStats(battler, &party[monId]); return TRUE; } } @@ -10353,9 +10346,9 @@ bool32 DoBattlersShareType(u32 battler1, u32 battler2) return FALSE; } -bool32 CanBattlerGetOrLoseItem(u8 battlerId, u16 itemId) +bool32 CanBattlerGetOrLoseItem(u8 battler, u16 itemId) { - u16 species = gBattleMons[battlerId].species; + u16 species = gBattleMons[battler].species; u16 holdEffect = ItemId_GetHoldEffect(itemId); // Mail can be stolen now @@ -10369,56 +10362,56 @@ bool32 CanBattlerGetOrLoseItem(u8 battlerId, u16 itemId) return TRUE; } -struct Pokemon *GetIllusionMonPtr(u32 battlerId) +struct Pokemon *GetIllusionMonPtr(u32 battler) { - if (gBattleStruct->illusion[battlerId].broken) + if (gBattleStruct->illusion[battler].broken) return NULL; - if (!gBattleStruct->illusion[battlerId].set) + if (!gBattleStruct->illusion[battler].set) { - if (GetBattlerSide(battlerId) == B_SIDE_PLAYER) - SetIllusionMon(&gPlayerParty[gBattlerPartyIndexes[battlerId]], battlerId); + if (GetBattlerSide(battler) == B_SIDE_PLAYER) + SetIllusionMon(&gPlayerParty[gBattlerPartyIndexes[battler]], battler); else - SetIllusionMon(&gEnemyParty[gBattlerPartyIndexes[battlerId]], battlerId); + SetIllusionMon(&gEnemyParty[gBattlerPartyIndexes[battler]], battler); } - if (!gBattleStruct->illusion[battlerId].on) + if (!gBattleStruct->illusion[battler].on) return NULL; - return gBattleStruct->illusion[battlerId].mon; + return gBattleStruct->illusion[battler].mon; } -void ClearIllusionMon(u32 battlerId) +void ClearIllusionMon(u32 battler) { - memset(&gBattleStruct->illusion[battlerId], 0, sizeof(gBattleStruct->illusion[battlerId])); + memset(&gBattleStruct->illusion[battler], 0, sizeof(gBattleStruct->illusion[battler])); } -u32 GetIllusionMonSpecies(u32 battlerId) +u32 GetIllusionMonSpecies(u32 battler) { - struct Pokemon *illusionMon = GetIllusionMonPtr(battlerId); + struct Pokemon *illusionMon = GetIllusionMonPtr(battler); if (illusionMon != NULL) return GetMonData(illusionMon, MON_DATA_SPECIES); return SPECIES_NONE; } -bool32 SetIllusionMon(struct Pokemon *mon, u32 battlerId) +bool32 SetIllusionMon(struct Pokemon *mon, u32 battler) { struct Pokemon *party, *partnerMon; s32 i, id; u8 side, partyCount; - gBattleStruct->illusion[battlerId].set = 1; + gBattleStruct->illusion[battler].set = 1; if (GetMonAbility(mon) != ABILITY_ILLUSION) return FALSE; - party = GetBattlerParty(battlerId); - side = GetBattlerSide(battlerId); + party = GetBattlerParty(battler); + side = GetBattlerSide(battler); partyCount = side == B_SIDE_PLAYER ? gPlayerPartyCount : gEnemyPartyCount; // If this pokemon is last in the party, ignore Illusion. if (&party[partyCount - 1] == mon) return FALSE; - if (IsBattlerAlive(BATTLE_PARTNER(battlerId))) - partnerMon = &party[gBattlerPartyIndexes[BATTLE_PARTNER(battlerId)]]; + if (IsBattlerAlive(BATTLE_PARTNER(battler))) + partnerMon = &party[gBattlerPartyIndexes[BATTLE_PARTNER(battler)]]; else partnerMon = mon; @@ -10432,10 +10425,10 @@ bool32 SetIllusionMon(struct Pokemon *mon, u32 battlerId) && &party[id] != mon && &party[id] != partnerMon) { - gBattleStruct->illusion[battlerId].on = 1; - gBattleStruct->illusion[battlerId].broken = 0; - gBattleStruct->illusion[battlerId].partyId = id; - gBattleStruct->illusion[battlerId].mon = &party[id]; + gBattleStruct->illusion[battler].on = 1; + gBattleStruct->illusion[battler].broken = 0; + gBattleStruct->illusion[battler].partyId = id; + gBattleStruct->illusion[battler].mon = &party[id]; return TRUE; } } @@ -10443,12 +10436,12 @@ bool32 SetIllusionMon(struct Pokemon *mon, u32 battlerId) return FALSE; } -bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 battlerId) +bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 battler) { #if B_BADGE_BOOST == GEN_3 if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_FRONTIER)) return FALSE; - else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + else if (GetBattlerSide(battler) != B_SIDE_PLAYER) return FALSE; else if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && gTrainerBattleOpponent_A == TRAINER_SECRET_BASE) return FALSE; @@ -10506,26 +10499,26 @@ static bool32 TryRemoveScreens(u8 battler) return removed; } -static bool32 IsUnnerveAbilityOnOpposingSide(u8 battlerId) +static bool32 IsUnnerveAbilityOnOpposingSide(u8 battler) { - if (IsAbilityOnOpposingSide(battlerId, ABILITY_UNNERVE) - || IsAbilityOnOpposingSide(battlerId, ABILITY_AS_ONE_ICE_RIDER) - || IsAbilityOnOpposingSide(battlerId, ABILITY_AS_ONE_SHADOW_RIDER)) + if (IsAbilityOnOpposingSide(battler, ABILITY_UNNERVE) + || IsAbilityOnOpposingSide(battler, ABILITY_AS_ONE_ICE_RIDER) + || IsAbilityOnOpposingSide(battler, ABILITY_AS_ONE_SHADOW_RIDER)) return TRUE; return FALSE; } // Photon geyser & light that burns the sky -u8 GetSplitBasedOnStats(u8 battlerId) +u8 GetSplitBasedOnStats(u8 battler) { - u32 attack = gBattleMons[battlerId].attack; - u32 spAttack = gBattleMons[battlerId].spAttack; + u32 attack = gBattleMons[battler].attack; + u32 spAttack = gBattleMons[battler].spAttack; - attack = attack * gStatStageRatios[gBattleMons[battlerId].statStages[STAT_ATK]][0]; - attack = attack / gStatStageRatios[gBattleMons[battlerId].statStages[STAT_ATK]][1]; + attack = attack * gStatStageRatios[gBattleMons[battler].statStages[STAT_ATK]][0]; + attack = attack / gStatStageRatios[gBattleMons[battler].statStages[STAT_ATK]][1]; - spAttack = spAttack * gStatStageRatios[gBattleMons[battlerId].statStages[STAT_SPATK]][0]; - spAttack = spAttack / gStatStageRatios[gBattleMons[battlerId].statStages[STAT_SPATK]][1]; + spAttack = spAttack * gStatStageRatios[gBattleMons[battler].statStages[STAT_SPATK]][0]; + spAttack = spAttack / gStatStageRatios[gBattleMons[battler].statStages[STAT_SPATK]][1]; if (spAttack >= attack) return SPLIT_SPECIAL; @@ -10547,19 +10540,19 @@ static u8 GetFlingPowerFromItemId(u16 itemId) } // Make sure the input bank is any bank on the specific mon's side -bool32 CanFling(u8 battlerId) +bool32 CanFling(u8 battler) { - u16 item = gBattleMons[battlerId].item; + u16 item = gBattleMons[battler].item; u16 itemEffect = ItemId_GetHoldEffect(item); if (item == ITEM_NONE #if B_KLUTZ_FLING_INTERACTION >= GEN_5 - || GetBattlerAbility(battlerId) == ABILITY_KLUTZ + || GetBattlerAbility(battler) == ABILITY_KLUTZ #endif || gFieldStatuses & STATUS_FIELD_MAGIC_ROOM - || gDisableStructs[battlerId].embargoTimer != 0 + || gDisableStructs[battler].embargoTimer != 0 || GetFlingPowerFromItemId(item) == 0 - || !CanBattlerGetOrLoseItem(battlerId, item)) + || !CanBattlerGetOrLoseItem(battler, item)) return FALSE; return TRUE; @@ -10741,7 +10734,7 @@ bool32 CanStealItem(u8 battlerStealing, u8 battlerItem, u16 item) return TRUE; } -void TrySaveExchangedItem(u8 battlerId, u16 stolenItem) +void TrySaveExchangedItem(u8 battler, u16 stolenItem) { // Because BtlController_EmitSetMonData does SetMonData, we need to save the stolen item only if it matches the battler's original // So, if the player steals an item during battle and has it stolen from it, it will not end the battle with it (naturally) @@ -10749,25 +10742,25 @@ void TrySaveExchangedItem(u8 battlerId, u16 stolenItem) // If regular trainer battle and mon's original item matches what is being stolen, save it to be restored at end of battle if (gBattleTypeFlags & BATTLE_TYPE_TRAINER && !(gBattleTypeFlags & BATTLE_TYPE_FRONTIER) - && GetBattlerSide(battlerId) == B_SIDE_PLAYER - && stolenItem == gBattleStruct->itemLost[gBattlerPartyIndexes[battlerId]].originalItem) - gBattleStruct->itemLost[gBattlerPartyIndexes[battlerId]].stolen = TRUE; + && GetBattlerSide(battler) == B_SIDE_PLAYER + && stolenItem == gBattleStruct->itemLost[gBattlerPartyIndexes[battler]].originalItem) + gBattleStruct->itemLost[gBattlerPartyIndexes[battler]].stolen = TRUE; #endif } -bool32 IsBattlerAffectedByHazards(u8 battlerId, bool32 toxicSpikes) +bool32 IsBattlerAffectedByHazards(u8 battler, bool32 toxicSpikes) { bool32 ret = TRUE; - u32 holdEffect = GetBattlerHoldEffect(battlerId, TRUE); - if (toxicSpikes && holdEffect == HOLD_EFFECT_HEAVY_DUTY_BOOTS && !IS_BATTLER_OF_TYPE(battlerId, TYPE_POISON)) + u32 holdEffect = GetBattlerHoldEffect(battler, TRUE); + if (toxicSpikes && holdEffect == HOLD_EFFECT_HEAVY_DUTY_BOOTS && !IS_BATTLER_OF_TYPE(battler, TYPE_POISON)) { ret = FALSE; - RecordItemEffectBattle(battlerId, holdEffect); + RecordItemEffectBattle(battler, holdEffect); } else if (holdEffect == HOLD_EFFECT_HEAVY_DUTY_BOOTS) { ret = FALSE; - RecordItemEffectBattle(battlerId, holdEffect); + RecordItemEffectBattle(battler, holdEffect); } return ret; } @@ -10781,14 +10774,14 @@ bool32 TestSheerForceFlag(u8 battler, u16 move) } // This function is the body of "jumpifstat", but can be used dynamically in a function -bool32 CompareStat(u8 battlerId, u8 statId, u8 cmpTo, u8 cmpKind) +bool32 CompareStat(u8 battler, u8 statId, u8 cmpTo, u8 cmpKind) { bool8 ret = FALSE; - u8 statValue = gBattleMons[battlerId].statStages[statId]; + u8 statValue = gBattleMons[battler].statStages[statId]; // Because this command is used as a way of checking if a stat can be lowered/raised, // we need to do some modification at run-time. - if (GetBattlerAbility(battlerId) == ABILITY_CONTRARY) + if (GetBattlerAbility(battler) == ABILITY_CONTRARY) { if (cmpKind == CMP_GREATER_THAN) cmpKind = CMP_LESS_THAN; @@ -10832,9 +10825,9 @@ bool32 CompareStat(u8 battlerId, u8 statId, u8 cmpTo, u8 cmpKind) return ret; } -void BufferStatChange(u8 battlerId, u8 statId, u8 stringId) +void BufferStatChange(u8 battler, u8 statId, u8 stringId) { - bool8 hasContrary = (GetBattlerAbility(battlerId) == ABILITY_CONTRARY); + bool8 hasContrary = (GetBattlerAbility(battler) == ABILITY_CONTRARY); PREPARE_STAT_BUFFER(gBattleTextBuff1, statId); if (stringId == STRINGID_STATFELL) @@ -10857,16 +10850,16 @@ void BufferStatChange(u8 battlerId, u8 statId, u8 stringId) } } -bool32 TryRoomService(u8 battlerId) +bool32 TryRoomService(u8 battler) { - if (gFieldStatuses & STATUS_FIELD_TRICK_ROOM && CompareStat(battlerId, STAT_SPEED, MIN_STAT_STAGE, CMP_GREATER_THAN)) + if (gFieldStatuses & STATUS_FIELD_TRICK_ROOM && CompareStat(battler, STAT_SPEED, MIN_STAT_STAGE, CMP_GREATER_THAN)) { - BufferStatChange(battlerId, STAT_SPEED, STRINGID_STATFELL); - gEffectBattler = gBattleScripting.battler = battlerId; + BufferStatChange(battler, STAT_SPEED, STRINGID_STATFELL); + gEffectBattler = gBattleScripting.battler = battler; SET_STATCHANGER(STAT_SPEED, 1, TRUE); gBattleScripting.animArg1 = 14 + STAT_SPEED; gBattleScripting.animArg2 = 0; - gLastUsedItem = gBattleMons[battlerId].item; + gLastUsedItem = gBattleMons[battler].item; return TRUE; } else @@ -10899,12 +10892,12 @@ u16 GetUsedHeldItem(u8 battler) return gBattleStruct->usedHeldItems[gBattlerPartyIndexes[battler]][GetBattlerSide(battler)]; } -bool32 IsBattlerWeatherAffected(u8 battlerId, u32 weatherFlags) +bool32 IsBattlerWeatherAffected(u8 battler, u32 weatherFlags) { if (gBattleWeather & weatherFlags && WEATHER_HAS_EFFECT) { // given weather is active -> check if its sun, rain against utility umbrella ( since only 1 weather can be active at once) - if (gBattleWeather & (B_WEATHER_SUN | B_WEATHER_RAIN) && GetBattlerHoldEffect(battlerId, TRUE) == HOLD_EFFECT_UTILITY_UMBRELLA) + if (gBattleWeather & (B_WEATHER_SUN | B_WEATHER_RAIN) && GetBattlerHoldEffect(battler, TRUE) == HOLD_EFFECT_UTILITY_UMBRELLA) return FALSE; // utility umbrella blocks sun, rain effects return TRUE; @@ -10914,12 +10907,12 @@ bool32 IsBattlerWeatherAffected(u8 battlerId, u32 weatherFlags) // Gets move target before redirection effects etc. are applied // Possible return values are defined in battle.h following MOVE_TARGET_SELECTED -u32 GetBattlerMoveTargetType(u8 battlerId, u16 move) +u32 GetBattlerMoveTargetType(u8 battler, u16 move) { u32 target; if (gBattleMoves[move].effect == EFFECT_EXPANDING_FORCE - && IsBattlerTerrainAffected(battlerId, STATUS_FIELD_PSYCHIC_TERRAIN)) + && IsBattlerTerrainAffected(battler, STATUS_FIELD_PSYCHIC_TERRAIN)) return MOVE_TARGET_BOTH; else return gBattleMoves[move].target; @@ -10979,27 +10972,27 @@ void RecalcBattlerStats(u32 battler, struct Pokemon *mon) CopyMonAbilityAndTypesToBattleMon(battler, mon); } -void RemoveConfusionStatus(u8 battlerId) +void RemoveConfusionStatus(u8 battler) { - gBattleMons[battlerId].status2 &= ~STATUS2_CONFUSION; - gStatuses4[battlerId] &= ~STATUS4_INFINITE_CONFUSION; + gBattleMons[battler].status2 &= ~STATUS2_CONFUSION; + gStatuses4[battler] &= ~STATUS4_INFINITE_CONFUSION; } -static bool8 CanBeInfinitelyConfused(u8 battlerId) +static bool8 CanBeInfinitelyConfused(u8 battler) { - if (gBattleMons[battlerId].ability == ABILITY_OWN_TEMPO - || IsBattlerTerrainAffected(battlerId, STATUS_FIELD_MISTY_TERRAIN) - || gSideStatuses[GetBattlerSide(battlerId)] & SIDE_STATUS_SAFEGUARD) + if (gBattleMons[battler].ability == ABILITY_OWN_TEMPO + || IsBattlerTerrainAffected(battler, STATUS_FIELD_MISTY_TERRAIN) + || gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_SAFEGUARD) { return FALSE; } return TRUE; } -u8 GetBattlerGender(u8 battlerId) +u8 GetBattlerGender(u8 battler) { - return GetGenderFromSpeciesAndPersonality(gBattleMons[battlerId].species, - gBattleMons[battlerId].personality); + return GetGenderFromSpeciesAndPersonality(gBattleMons[battler].species, + gBattleMons[battler].personality); } bool8 AreBattlersOfOppositeGender(u8 battler1, u8 battler2) @@ -11010,9 +11003,9 @@ bool8 AreBattlersOfOppositeGender(u8 battler1, u8 battler2) return (gender1 != MON_GENDERLESS && gender2 != MON_GENDERLESS && gender1 != gender2); } -u32 CalcSecondaryEffectChance(u8 battlerId, u8 secondaryEffectChance) +u32 CalcSecondaryEffectChance(u8 battler, u8 secondaryEffectChance) { - if (GetBattlerAbility(battlerId) == ABILITY_SERENE_GRACE) + if (GetBattlerAbility(battler) == ABILITY_SERENE_GRACE) secondaryEffectChance *= 2; return secondaryEffectChance; diff --git a/src/battle_util2.c b/src/battle_util2.c index 0f04a6eb4e..8dda3004c0 100644 --- a/src/battle_util2.c +++ b/src/battle_util2.c @@ -72,7 +72,7 @@ void FreeBattleResources(void) } } -void AdjustFriendshipOnBattleFaint(u8 battlerId) +void AdjustFriendshipOnBattleFaint(u8 battler) { u8 opposingBattlerId; @@ -91,28 +91,28 @@ void AdjustFriendshipOnBattleFaint(u8 battlerId) opposingBattlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); } - if (gBattleMons[opposingBattlerId].level > gBattleMons[battlerId].level) + if (gBattleMons[opposingBattlerId].level > gBattleMons[battler].level) { - if (gBattleMons[opposingBattlerId].level - gBattleMons[battlerId].level > 29) - AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_LARGE); + if (gBattleMons[opposingBattlerId].level - gBattleMons[battler].level > 29) + AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_LARGE); else - AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_SMALL); + AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_SMALL); } else { - AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battlerId]], FRIENDSHIP_EVENT_FAINT_SMALL); + AdjustFriendship(&gPlayerParty[gBattlerPartyIndexes[battler]], FRIENDSHIP_EVENT_FAINT_SMALL); } } -void SwitchPartyOrderInGameMulti(u8 battlerId, u8 arg1) +void SwitchPartyOrderInGameMulti(u8 battler, u8 arg1) { - if (GetBattlerSide(battlerId) != B_SIDE_OPPONENT) + if (GetBattlerSide(battler) != B_SIDE_OPPONENT) { s32 i; for (i = 0; i < (int)ARRAY_COUNT(gBattlePartyCurrentOrder); i++) gBattlePartyCurrentOrder[i] = *(0 * 3 + i + (u8 *)(gBattleStruct->battlerPartyOrders)); - SwitchPartyMonSlots(GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battlerId]), GetPartyIdFromBattlePartyId(arg1)); + SwitchPartyMonSlots(GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[battler]), GetPartyIdFromBattlePartyId(arg1)); for (i = 0; i < (int)ARRAY_COUNT(gBattlePartyCurrentOrder); i++) *(0 * 3 + i + (u8 *)(gBattleStruct->battlerPartyOrders)) = gBattlePartyCurrentOrder[i]; @@ -121,7 +121,7 @@ void SwitchPartyOrderInGameMulti(u8 battlerId, u8 arg1) // Called when a Pokémon is unable to attack during a Battle Palace battle. // Check if it was because they are frozen/asleep, and if so try to cure the status. -u32 BattlePalace_TryEscapeStatus(u8 battlerId) +u32 BattlePalace_TryEscapeStatus(u8 battler) { u32 effect = 0; @@ -130,13 +130,13 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) switch (gBattleCommunication[MULTIUSE_STATE]) { case 0: - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { - if (UproarWakeUpCheck(battlerId)) + if (UproarWakeUpCheck(battler)) { // Wake up from Uproar - gBattleMons[battlerId].status1 &= ~(STATUS1_SLEEP); - gBattleMons[battlerId].status2 &= ~(STATUS2_NIGHTMARE); + gBattleMons[battler].status1 &= ~(STATUS1_SLEEP); + gBattleMons[battler].status2 &= ~(STATUS2_NIGHTMARE); BattleScriptPushCursor(); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_WOKE_UP_UPROAR; gBattlescriptCurrInstr = BattleScript_MoveUsedWokeUp; @@ -146,18 +146,18 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) { u32 toSub; - if (GetBattlerAbility(battlerId) == ABILITY_EARLY_BIRD) + if (GetBattlerAbility(battler) == ABILITY_EARLY_BIRD) toSub = 2; else toSub = 1; // Reduce number of sleep turns - if ((gBattleMons[battlerId].status1 & STATUS1_SLEEP) < toSub) - gBattleMons[battlerId].status1 &= ~(STATUS1_SLEEP); + if ((gBattleMons[battler].status1 & STATUS1_SLEEP) < toSub) + gBattleMons[battler].status1 &= ~(STATUS1_SLEEP); else - gBattleMons[battlerId].status1 -= toSub; + gBattleMons[battler].status1 -= toSub; - if (gBattleMons[battlerId].status1 & STATUS1_SLEEP) + if (gBattleMons[battler].status1 & STATUS1_SLEEP) { // Still asleep gBattlescriptCurrInstr = BattleScript_MoveUsedIsAsleep; @@ -166,7 +166,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) else { // Wake up - gBattleMons[battlerId].status2 &= ~(STATUS2_NIGHTMARE); + gBattleMons[battler].status2 &= ~(STATUS2_NIGHTMARE); BattleScriptPushCursor(); gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_WOKE_UP; gBattlescriptCurrInstr = BattleScript_MoveUsedWokeUp; @@ -177,7 +177,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) gBattleCommunication[MULTIUSE_STATE]++; break; case 1: - if (gBattleMons[battlerId].status1 & STATUS1_FREEZE) + if (gBattleMons[battler].status1 & STATUS1_FREEZE) { if (Random() % 5 != 0) { @@ -187,7 +187,7 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) else { // Unfreeze - gBattleMons[battlerId].status1 &= ~(STATUS1_FREEZE); + gBattleMons[battler].status1 &= ~(STATUS1_FREEZE); BattleScriptPushCursor(); gBattlescriptCurrInstr = BattleScript_MoveUsedUnfroze; gBattleCommunication[MULTISTRING_CHOOSER] = B_MSG_DEFROSTED; @@ -204,9 +204,8 @@ u32 BattlePalace_TryEscapeStatus(u8 battlerId) if (effect == 2) { - gActiveBattler = battlerId; - BtlController_EmitSetMonData(BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[gActiveBattler].status1); - MarkBattlerForControllerExec(gActiveBattler); + BtlController_EmitSetMonData(battler, BUFFER_A, REQUEST_STATUS_BATTLE, 0, 4, &gBattleMons[battler].status1); + MarkBattlerForControllerExec(battler); } return effect; diff --git a/src/pokeball.c b/src/pokeball.c index 2e556ec225..891b8fe4a5 100644 --- a/src/pokeball.c +++ b/src/pokeball.c @@ -527,17 +527,17 @@ const struct SpriteTemplate gBallSpriteTemplates[POKEBALL_COUNT] = #define tBattler data[3] #define tOpponentBattler data[4] -u8 DoPokeballSendOutAnimation(s16 pan, u8 kindOfThrow) +u8 DoPokeballSendOutAnimation(u32 battler, s16 pan, u8 kindOfThrow) { u8 taskId; gDoingBattleAnim = TRUE; - gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive = TRUE; + gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive = TRUE; taskId = CreateTask(Task_DoPokeballSendOutAnim, 5); gTasks[taskId].tPan = pan; gTasks[taskId].tThrowId = kindOfThrow; - gTasks[taskId].tBattler = gActiveBattler; + gTasks[taskId].tBattler = battler; return 0; }