From 4a4a72f9fb66173a0bd0802c15c17c115d490d91 Mon Sep 17 00:00:00 2001 From: Eduardo Quezada Date: Wed, 28 Jan 2026 05:32:03 -0300 Subject: [PATCH] Added `enum BattlerId` type checks (#8954) --- include/battle.h | 62 +-- include/battle_ai_field_statuses.h | 6 +- include/battle_ai_items.h | 2 +- include/battle_ai_main.h | 14 +- include/battle_ai_switch.h | 12 +- include/battle_ai_util.h | 394 +++++++-------- include/battle_anim.h | 56 +-- include/battle_arena.h | 6 +- include/battle_controllers.h | 290 +++++------ include/battle_dynamax.h | 14 +- include/battle_gfx_sfx_util.h | 36 +- include/battle_gimmick.h | 26 +- include/battle_hold_effects.h | 2 +- include/battle_interface.h | 20 +- include/battle_main.h | 24 +- include/battle_message.h | 4 +- include/battle_script_commands.h | 40 +- include/battle_terastal.h | 12 +- include/battle_tv.h | 2 +- include/battle_util.h | 308 ++++++------ include/battle_util2.h | 6 +- include/battle_z_move.h | 14 +- include/constants/battle.h | 2 +- include/constants/battle_anim.h | 23 +- include/party_menu.h | 4 +- include/pokeball.h | 6 +- include/pokemon.h | 14 +- include/recorded_battle.h | 12 +- include/reshow_battle_screen.h | 2 +- include/test/battle.h | 12 +- include/test_runner.h | 22 +- include/trainer_slide.h | 14 +- include/type_icons.h | 2 +- src/battle_ai_field_statuses.c | 56 +-- src/battle_ai_items.c | 8 +- src/battle_ai_main.c | 224 ++++----- src/battle_ai_switch.c | 164 +++---- src/battle_ai_util.c | 480 +++++++++--------- src/battle_anim.c | 66 +-- src/battle_anim_dark.c | 11 +- src/battle_anim_effects_1.c | 55 +-- src/battle_anim_effects_2.c | 20 +- src/battle_anim_effects_3.c | 61 ++- src/battle_anim_electric.c | 16 +- src/battle_anim_fight.c | 4 +- src/battle_anim_flying.c | 3 +- src/battle_anim_ghost.c | 2 +- src/battle_anim_ground.c | 15 +- src/battle_anim_ice.c | 23 +- src/battle_anim_mon_movement.c | 76 +-- src/battle_anim_mons.c | 66 +-- src/battle_anim_new.c | 60 +-- src/battle_anim_normal.c | 20 +- src/battle_anim_poison.c | 14 +- src/battle_anim_psychic.c | 19 +- src/battle_anim_rock.c | 3 +- src/battle_anim_sound_tasks.c | 44 +- src/battle_anim_status_effects.c | 8 +- src/battle_anim_throw.c | 18 +- src/battle_anim_utility_funcs.c | 42 +- src/battle_arena.c | 28 +- src/battle_controller_link_opponent.c | 49 +- src/battle_controller_link_partner.c | 34 +- src/battle_controller_opponent.c | 64 +-- src/battle_controller_player.c | 263 +++++----- src/battle_controller_player_partner.c | 56 +-- src/battle_controller_recorded_opponent.c | 61 +-- src/battle_controller_recorded_partner.c | 50 +- src/battle_controller_recorded_player.c | 56 +-- src/battle_controller_safari.c | 58 +-- src/battle_controller_wally.c | 62 +-- src/battle_controllers.c | 318 ++++++------ src/battle_debug.c | 24 +- src/battle_dynamax.c | 16 +- src/battle_end_turn.c | 109 ++--- src/battle_gfx_sfx_util.c | 68 ++- src/battle_gimmick.c | 37 +- src/battle_hold_effects.c | 94 ++-- src/battle_interface.c | 68 +-- src/battle_main.c | 264 +++++----- src/battle_message.c | 18 +- src/battle_move_resolution.c | 134 ++--- src/battle_records.c | 2 +- src/battle_script_commands.c | 430 ++++++++-------- src/battle_switch_in.c | 22 +- src/battle_terastal.c | 12 +- src/battle_tv.c | 2 +- src/battle_util.c | 571 +++++++++++----------- src/battle_util2.c | 10 +- src/battle_z_move.c | 30 +- src/contest.c | 10 +- src/item_use.c | 2 +- src/party_menu.c | 15 +- src/pokeball.c | 29 +- src/pokemon.c | 20 +- src/pokemon_sprite_visualizer.c | 6 +- src/recorded_battle.c | 20 +- src/reshow_battle_screen.c | 35 +- src/trainer_slide.c | 62 +-- src/type_icons.c | 36 +- test/battle/ability/arena_trap.c | 18 +- test/battle/ai/ai_doubles.c | 2 +- test/battle/ai/ai_multi.c | 6 +- test/test_runner_battle.c | 62 +-- 104 files changed, 3202 insertions(+), 3172 deletions(-) diff --git a/include/battle.h b/include/battle.h index ff2cac7c94..ebb4ae0276 100644 --- a/include/battle.h +++ b/include/battle.h @@ -564,7 +564,7 @@ struct BattleStruct u8 expSentInMons; // As bits for player party mons - not including exp share mons. u8 wildVictorySong; enum Type dynamicMoveType; - u8 battlerPreventingSwitchout; + enum BattlerId battlerPreventingSwitchout; u8 moneyMultiplier:6; u8 moneyMultiplierItem:1; u8 moneyMultiplierMove:1; @@ -640,9 +640,9 @@ struct BattleStruct u8 stolenStats[NUM_BATTLE_STATS]; // hp byte is used for which stats to raise, other inform about by how many stages enum Ability tracedAbility[MAX_BATTLERS_COUNT]; struct Illusion illusion[MAX_BATTLERS_COUNT]; - u8 soulheartBattlerId; - u8 friskedBattler; // Frisk needs to identify 2 battlers in double battles. - u8 quickClawBattlerId; + enum BattlerId soulheartBattlerId; + enum BattlerId friskedBattler; // Frisk needs to identify 2 battlers in double battles. + enum BattlerId quickClawBattlerId; struct LostItem itemLost[NUM_BATTLE_SIDES][PARTY_SIZE]; // Pokemon that had items consumed or stolen (two bytes per party member per side) u8 blunderPolicy:1; // should blunder policy activate u8 swapDamageCategory:1; // Photon Geyser, Shell Side Arm, Light That Burns the Sky @@ -806,7 +806,7 @@ struct BattleScripting u8 moveendState; u8 savedStatChanger; // For further use, if attempting to change stat two times(ex. Moody) u8 shiftSwitched; // When the game tells you the next enemy's pokemon and you switch. Option for noobs but oh well. - u8 battler; + enum BattlerId battler; u8 animTurn; u8 animTargetsHit; u8 statChanger; @@ -961,8 +961,8 @@ extern u8 gBattlersCount; extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT]; extern u8 gBattlerPositions[MAX_BATTLERS_COUNT]; extern u8 gActionsByTurnOrder[MAX_BATTLERS_COUNT]; -extern u8 gBattlerByTurnOrder[MAX_BATTLERS_COUNT]; -extern u8 gBattlersBySpeed[MAX_BATTLERS_COUNT]; +extern enum BattlerId gBattlerByTurnOrder[MAX_BATTLERS_COUNT]; +extern enum BattlerId gBattlersBySpeed[MAX_BATTLERS_COUNT]; extern u8 gCurrentTurnActionNumber; extern u8 gCurrentActionFuncId; extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT]; @@ -975,11 +975,11 @@ extern u16 gCalledMove; extern s32 gBideDmg[MAX_BATTLERS_COUNT]; extern u16 gLastUsedItem; extern enum Ability gLastUsedAbility; -extern u8 gBattlerAttacker; -extern u8 gBattlerTarget; -extern u8 gBattlerFainted; -extern u8 gEffectBattler; -extern u8 gPotentialItemEffectBattler; +extern enum BattlerId gBattlerAttacker; +extern enum BattlerId gBattlerTarget; +extern enum BattlerId gBattlerFainted; +extern enum BattlerId gEffectBattler; +extern enum BattlerId gPotentialItemEffectBattler; extern u8 gAbsentBattlerFlags; extern u8 gMultiHitCounter; extern const u8 *gBattlescriptCurrInstr; @@ -1036,7 +1036,7 @@ extern u16 gMoveToLearn; extern u32 gFieldStatuses; extern struct FieldTimer gFieldTimers; extern u16 gBattleTurnCounter; -extern u8 gBattlerAbility; +extern enum BattlerId gBattlerAbility; extern struct QueuedStatBoost gQueuedStatBoosts[MAX_BATTLERS_COUNT]; extern MainCallback gPreBattleCallback1; @@ -1054,7 +1054,7 @@ extern bool8 gLastUsedBallMenuPresent; extern u8 gPartyCriticalHits[PARTY_SIZE]; extern u8 gCategoryIconSpriteId; -static inline bool32 IsBattlerAlive(u32 battler) +static inline bool32 IsBattlerAlive(enum BattlerId battler) { if (battler >= gBattlersCount) return FALSE; @@ -1066,24 +1066,24 @@ static inline bool32 IsBattlerAlive(u32 battler) return TRUE; } -static inline bool32 IsBattlerTurnDamaged(u32 battler) +static inline bool32 IsBattlerTurnDamaged(enum BattlerId battler) { return gSpecialStatuses[battler].damagedByAttack; } -static inline bool32 IsBattlerAtMaxHp(u32 battler) +static inline bool32 IsBattlerAtMaxHp(enum BattlerId battler) { return gBattleMons[battler].hp == gBattleMons[battler].maxHP; } -static inline enum BattlerPosition GetBattlerPosition(u32 battler) +static inline enum BattlerPosition GetBattlerPosition(enum BattlerId battler) { return gBattlerPositions[battler]; } -static inline u32 GetBattlerAtPosition(enum BattlerPosition position) +static inline enum BattlerId GetBattlerAtPosition(enum BattlerPosition position) { - u32 battler; + enum BattlerId battler; for (battler = 0; battler < gBattlersCount; battler++) { if (GetBattlerPosition(battler) == position) @@ -1092,37 +1092,37 @@ static inline u32 GetBattlerAtPosition(enum BattlerPosition position) return battler; } -static inline u32 GetPartnerBattler(u32 battler) +static inline u32 GetPartnerBattler(enum BattlerId battler) { return GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(battler))); } -static inline u32 GetOppositeBattler(u32 battler) +static inline u32 GetOppositeBattler(enum BattlerId battler) { return GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler))); } -static inline u32 GetBattlerSide(u32 battler) +static inline u32 GetBattlerSide(enum BattlerId battler) { return GetBattlerPosition(battler) & BIT_SIDE; } -static inline bool32 IsOnPlayerSide(u32 battler) +static inline bool32 IsOnPlayerSide(enum BattlerId battler) { return GetBattlerSide(battler) == B_SIDE_PLAYER; } -static inline bool32 IsBattlerAlly(u32 battlerAtk, u32 battlerDef) +static inline bool32 IsBattlerAlly(enum BattlerId battlerAtk, enum BattlerId battlerDef) { return GetBattlerSide(battlerAtk) == GetBattlerSide(battlerDef); } -static inline u32 GetOpposingSideBattler(u32 battler) +static inline u32 GetOpposingSideBattler(enum BattlerId battler) { return GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerSide(battler))); } -static inline struct Pokemon* GetBattlerMon(u32 battler) +static inline struct Pokemon* GetBattlerMon(enum BattlerId battler) { u32 index = gBattlerPartyIndexes[battler]; return !IsOnPlayerSide(battler) ? &gEnemyParty[index] : &gPlayerParty[index]; @@ -1133,12 +1133,12 @@ static inline struct Pokemon *GetSideParty(enum BattleSide side) return side == B_SIDE_PLAYER ? gPlayerParty : gEnemyParty; } -static inline struct Pokemon *GetBattlerParty(u32 battler) +static inline struct Pokemon *GetBattlerParty(enum BattlerId battler) { return GetSideParty(GetBattlerSide(battler)); } -static inline struct PartyState *GetBattlerPartyState(u32 battler) +static inline struct PartyState *GetBattlerPartyState(enum BattlerId battler) { return &gBattleStruct->partyState[GetBattlerSide(battler)][gBattlerPartyIndexes[battler]]; } @@ -1155,19 +1155,19 @@ static inline bool32 IsSpreadMove(enum MoveTarget moveTarget) return moveTarget == TARGET_BOTH || moveTarget == TARGET_FOES_AND_ALLY; } -static inline u32 GetChosenMoveFromPosition(u32 battler) +static inline u32 GetBattlerChosenMove(enum BattlerId battler) { return gBattleMons[battler].moves[gBattleStruct->chosenMovePositions[battler]]; } -static inline void SetPassiveDamageAmount(u32 battler, s32 value) +static inline void SetPassiveDamageAmount(enum BattlerId battler, s32 value) { if (value == 0) value = 1; gBattleStruct->passiveHpUpdate[battler] = value; } -static inline void SetHealAmount(u32 battler, s32 value) +static inline void SetHealAmount(enum BattlerId battler, s32 value) { if (value == 0) value = 1; diff --git a/include/battle_ai_field_statuses.h b/include/battle_ai_field_statuses.h index aa8f4f2d13..2c3354cea1 100644 --- a/include/battle_ai_field_statuses.h +++ b/include/battle_ai_field_statuses.h @@ -12,8 +12,8 @@ enum FieldEffectOutcome FIELD_EFFECT_BLOCKED, }; -bool32 WeatherChecker(u32 battler, u32 weather, enum FieldEffectOutcome desiredResult); -bool32 FieldStatusChecker(u32 battler, u32 fieldStatus, enum FieldEffectOutcome desiredResult); -s32 CalcWeatherScore(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData); +bool32 WeatherChecker(enum BattlerId battler, u32 weather, enum FieldEffectOutcome desiredResult); +bool32 FieldStatusChecker(enum BattlerId battler, u32 fieldStatus, enum FieldEffectOutcome desiredResult); +s32 CalcWeatherScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData); #endif //GUARD_BATTLE_AI_FIELD_STATUSES_H diff --git a/include/battle_ai_items.h b/include/battle_ai_items.h index 0abd2eac55..868cf315fb 100644 --- a/include/battle_ai_items.h +++ b/include/battle_ai_items.h @@ -1,6 +1,6 @@ #ifndef GUARD_BATTLE_AI_ITEMS_H #define GUARD_BATTLE_AI_ITEMS_H -bool32 ShouldUseItem(u32 battler); +bool32 ShouldUseItem(enum BattlerId battler); #endif // GUARD_BATTLE_AI_ITEMS_H diff --git a/include/battle_ai_main.h b/include/battle_ai_main.h index a690692884..a5b7ed8e36 100644 --- a/include/battle_ai_main.h +++ b/include/battle_ai_main.h @@ -126,16 +126,16 @@ enum MoveComparisonResult void BattleAI_SetupItems(void); void BattleAI_SetupFlags(void); -void BattleAI_SetupAIData(u8 defaultScoreMoves, u32 battler); -void ComputeBattlerDecisions(u32 battler); -u32 BattleAI_ChooseMoveIndex(u32 battler); +void BattleAI_SetupAIData(u8 defaultScoreMoves, enum BattlerId battler); +void ComputeBattlerDecisions(enum BattlerId battler); +u32 BattleAI_ChooseMoveIndex(enum BattlerId battler); void Ai_InitPartyStruct(void); -void Ai_UpdateSwitchInData(u32 battler); -void Ai_UpdateFaintData(u32 battler); +void Ai_UpdateSwitchInData(enum BattlerId battler); +void Ai_UpdateFaintData(enum BattlerId battler); void SetAiLogicDataForTurn(struct AiLogicData *aiData); void ResetDynamicAiFunctions(void); -void AI_TrySwitchOrUseItem(u32 battler); -void CalcBattlerAiMovesData(struct AiLogicData *aiData, u32 battlerAtk, u32 battlerDef, u32 weather, u32 fieldStatus); +void AI_TrySwitchOrUseItem(enum BattlerId battler); +void CalcBattlerAiMovesData(struct AiLogicData *aiData, enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 weather, u32 fieldStatus); extern AiSwitchFunc gDynamicAiSwitchFunc; diff --git a/include/battle_ai_switch.h b/include/battle_ai_switch.h index d37ebf090e..16b75c735b 100644 --- a/include/battle_ai_switch.h +++ b/include/battle_ai_switch.h @@ -43,11 +43,11 @@ enum SwitchType SWITCH_MID_BATTLE_OPTIONAL, }; -u32 GetMostSuitableMonToSwitchInto(u32 battler, enum SwitchType switchType); -bool32 ShouldSwitch(u32 battler); -void ModifySwitchAfterMoveScoring(u32 battler); -u32 AI_SelectRevivalBlessingMon(u32 battler); -bool32 IsSwitchinValid(u32 battler); -bool32 IsAceMon(u32 battler, u32 monPartyId); +u32 GetMostSuitableMonToSwitchInto(enum BattlerId battler, enum SwitchType switchType); +bool32 ShouldSwitch(enum BattlerId battler); +void ModifySwitchAfterMoveScoring(enum BattlerId battler); +u32 AI_SelectRevivalBlessingMon(enum BattlerId battler); +bool32 IsSwitchinValid(enum BattlerId battler); +bool32 IsAceMon(enum BattlerId battler, u32 monPartyId); #endif // GUARD_BATTLE_AI_SWITCH_H diff --git a/include/battle_ai_util.h b/include/battle_ai_util.h index 780a4c83fd..aeaccab196 100644 --- a/include/battle_ai_util.h +++ b/include/battle_ai_util.h @@ -77,154 +77,154 @@ static inline bool32 IsMoveUnusable(u32 moveIndex, enum Move move, u32 moveLimit typedef bool32 (*MoveFlag)(enum Move move); -bool32 AI_IsFaster(u32 battlerAi, u32 battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority); -bool32 AI_IsSlower(u32 battlerAi, u32 battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority); +bool32 AI_IsFaster(enum BattlerId battlerAi, enum BattlerId battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority); +bool32 AI_IsSlower(enum BattlerId battlerAi, enum BattlerId battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority); bool32 AI_RandLessThan(u32 val); -bool32 AI_IsBattlerGrounded(u32 battler); -enum MoveTarget AI_GetBattlerMoveTargetType(u32 battler, enum Move move); -enum Ability AI_GetMoldBreakerSanitizedAbility(u32 battlerAtk, enum Ability abilityAtk, enum Ability abilityDef, enum HoldEffect holdEffectDef, enum Move move); -u32 AI_GetDamage(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, struct AiLogicData *aiData); +bool32 AI_IsBattlerGrounded(enum BattlerId battler); +enum MoveTarget AI_GetBattlerMoveTargetType(enum BattlerId battler, enum Move move); +enum Ability AI_GetMoldBreakerSanitizedAbility(enum BattlerId battlerAtk, enum Ability abilityAtk, enum Ability abilityDef, enum HoldEffect holdEffectDef, enum Move move); +u32 AI_GetDamage(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, struct AiLogicData *aiData); bool32 IsAiFlagPresent(u64 flag); -bool32 IsAiBattlerAware(u32 battlerId); -bool32 CanAiPredictMove(u32 battlerId); -bool32 IsAiBattlerAssumingStab(u32 battlerId); -bool32 IsAiBattlerAssumingStatusMoves(u32 battlerId); -bool32 IsAiBattlerPredictingAbility(u32 battlerId); +bool32 IsAiBattlerAware(enum BattlerId battlerId); +bool32 CanAiPredictMove(enum BattlerId battlerId); +bool32 IsAiBattlerAssumingStab(enum BattlerId battlerId); +bool32 IsAiBattlerAssumingStatusMoves(enum BattlerId battlerId); +bool32 IsAiBattlerPredictingAbility(enum BattlerId battlerId); bool32 ShouldRecordStatusMove(enum Move move); -void ClearBattlerMoveHistory(u32 battlerId); -void RecordLastUsedMoveBy(u32 battlerId, enum Move move); -void RecordAllMoves(u32 battler); -void RecordKnownMove(u32 battlerId, enum Move move); -void RecordAbilityBattle(u32 battlerId, enum Ability abilityId); -void ClearBattlerAbilityHistory(u32 battlerId); -void RecordItemEffectBattle(u32 battlerId, enum HoldEffect itemEffect); -void ClearBattlerItemEffectHistory(u32 battlerId); -void SaveBattlerData(u32 battlerId); -void SetBattlerData(u32 battlerId); -void SetBattlerAiData(u32 battlerId, struct AiLogicData *aiData); -void RestoreBattlerData(u32 battlerId); -enum Move GetAIChosenMove(u32 battlerId); +void ClearBattlerMoveHistory(enum BattlerId battlerId); +void RecordLastUsedMoveBy(enum BattlerId battlerId, enum Move move); +void RecordAllMoves(enum BattlerId battler); +void RecordKnownMove(enum BattlerId battlerId, enum Move move); +void RecordAbilityBattle(enum BattlerId battlerId, enum Ability abilityId); +void ClearBattlerAbilityHistory(enum BattlerId battlerId); +void RecordItemEffectBattle(enum BattlerId battlerId, enum HoldEffect itemEffect); +void ClearBattlerItemEffectHistory(enum BattlerId battlerId); +void SaveBattlerData(enum BattlerId battlerId); +void SetBattlerData(enum BattlerId battlerId); +void SetBattlerAiData(enum BattlerId battler, struct AiLogicData *aiData); +void RestoreBattlerData(enum BattlerId battlerId); +enum Move GetAIChosenMove(enum BattlerId battlerId); u32 GetTotalBaseStat(u32 species); -bool32 IsTruantMonVulnerable(u32 battlerAI, u32 opposingBattler); -bool32 AI_BattlerAtMaxHp(u32 battler); -u32 GetHealthPercentage(u32 battler); -bool32 AI_CanBattlerEscape(u32 battler); -bool32 IsBattlerTrapped(u32 battlerAtk, u32 battlerDef); -s32 AI_WhoStrikesFirst(u32 battlerAI, u32 battler2, enum Move aiMoveConsidered, enum Move playerMoveConsidered, enum ConsiderPriority considerPriority); -bool32 CanTargetFaintAi(u32 battlerDef, u32 battlerAtk); -u32 NoOfHitsForTargetToFaintBattler(u32 battlerDef, u32 battlerAtk, enum AiConsiderEndure considerEndure); -void GetBestDmgMovesFromBattler(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum Move *bestMoves); -u32 GetMoveIndex(u32 battler, enum Move move); -bool32 IsBestDmgMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum Move move); -bool32 BestDmgMoveHasEffect(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum BattleMoveEffects moveEffect); -u32 GetBestDmgFromBattler(u32 battler, u32 battlerTarget, enum DamageCalcContext calcContext); -bool32 CanTargetMoveFaintAi(enum Move move, u32 battlerDef, u32 battlerAtk, u32 nHits); -bool32 CanTargetFaintAiWithMod(u32 battlerDef, u32 battlerAtk, s32 hpMod, s32 dmgMod); -enum Ability AI_DecideKnownAbilityForTurn(u32 battlerId); -enum HoldEffect AI_DecideHoldEffectForTurn(u32 battlerId); -bool32 DoesBattlerIgnoreAbilityChecks(u32 battlerAtk, enum Ability atkAbility, enum Move move); +bool32 IsTruantMonVulnerable(enum BattlerId battlerAI, enum BattlerId opposingBattler); +bool32 AI_BattlerAtMaxHp(enum BattlerId battler); +u32 GetHealthPercentage(enum BattlerId battler); +bool32 AI_CanBattlerEscape(enum BattlerId battler); +bool32 IsBattlerTrapped(enum BattlerId battlerAtk, enum BattlerId battlerDef); +s32 AI_WhoStrikesFirst(enum BattlerId battlerAI, enum BattlerId battler, enum Move aiMoveConsidered, enum Move playerMoveConsidered, enum ConsiderPriority considerPriority); +bool32 CanTargetFaintAi(enum BattlerId battlerDef, enum BattlerId battlerAtk); +u32 NoOfHitsForTargetToFaintBattler(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum AiConsiderEndure considerEndure); +void GetBestDmgMovesFromBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum Move *bestMoves); +u32 GetMoveIndex(enum BattlerId battler, enum Move move); +bool32 IsBestDmgMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum Move move); +bool32 BestDmgMoveHasEffect(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum BattleMoveEffects moveEffect); +u32 GetBestDmgFromBattler(enum BattlerId battler, enum BattlerId battlerTarget, enum DamageCalcContext calcContext); +bool32 CanTargetMoveFaintAi(enum Move move, enum BattlerId battlerDef, enum BattlerId battlerAtk, u32 nHits); +bool32 CanTargetFaintAiWithMod(enum BattlerId battlerDef, enum BattlerId battlerAtk, s32 hpMod, s32 dmgMod); +enum Ability AI_DecideKnownAbilityForTurn(enum BattlerId battlerId); +enum HoldEffect AI_DecideHoldEffectForTurn(enum BattlerId battlerId); +bool32 DoesBattlerIgnoreAbilityChecks(enum BattlerId battlerAtk, enum Ability atkAbility, enum Move move); u32 AI_GetWeather(void); -u32 AI_GetSwitchinWeather(u32 battler); -u32 AI_GetSwitchinFieldStatus(u32 battler); +u32 AI_GetSwitchinWeather(enum BattlerId battler); +u32 AI_GetSwitchinFieldStatus(enum BattlerId battler); enum WeatherState IsWeatherActive(u32 flags); -bool32 CanAIFaintTarget(u32 battlerAtk, u32 battlerDef, u32 numHits); -bool32 CanIndexMoveFaintTarget(u32 battlerAtk, u32 battlerDef, u32 index, enum DamageCalcContext calcContext); -bool32 HasDamagingMove(u32 battler); -bool32 HasDamagingMoveOfType(u32 battler, enum Type type); -u32 GetBattlerSecondaryDamage(u32 battlerId); -bool32 BattlerWillFaintFromWeather(u32 battler, enum Ability ability); -bool32 BattlerWillFaintFromSecondaryDamage(u32 battler, enum Ability ability); -bool32 ShouldTryOHKO(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move); -bool32 ShouldUseRecoilMove(u32 battlerAtk, u32 battlerDef, u32 recoilDmg, u32 moveIndex); -bool32 ShouldAbsorb(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 ShouldRecover(u32 battlerAtk, u32 battlerDef, enum Move move, u32 healPercent); -bool32 ShouldSetScreen(u32 battlerAtk, u32 battlerDef, enum BattleMoveEffects moveEffect); -bool32 ShouldCureStatus(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData); -bool32 ShouldCureStatusWithItem(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData); -enum AIPivot ShouldPivot(u32 battlerAtk, u32 battlerDef, enum Move move); +bool32 CanAIFaintTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 numHits); +bool32 CanIndexMoveFaintTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 index, enum DamageCalcContext calcContext); +bool32 HasDamagingMove(enum BattlerId battler); +bool32 HasDamagingMoveOfType(enum BattlerId battler, enum Type type); +u32 GetBattlerSecondaryDamage(enum BattlerId battlerId); +bool32 BattlerWillFaintFromWeather(enum BattlerId battler, enum Ability ability); +bool32 BattlerWillFaintFromSecondaryDamage(enum BattlerId battler, enum Ability ability); +bool32 ShouldTryOHKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move); +bool32 ShouldUseRecoilMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 recoilDmg, u32 moveIndex); +bool32 ShouldAbsorb(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 ShouldRecover(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, u32 healPercent); +bool32 ShouldSetScreen(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum BattleMoveEffects moveEffect); +bool32 ShouldCureStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData); +bool32 ShouldCureStatusWithItem(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData); +enum AIPivot ShouldPivot(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); bool32 IsRecycleEncouragedItem(enum Item item); -bool32 ShouldRestoreHpBerry(u32 battlerAtk, enum Item item); +bool32 ShouldRestoreHpBerry(enum BattlerId battlerAtk, enum Item item); bool32 IsStatBoostingBerry(enum Item item); -bool32 CanKnockOffItem(u32 fromBattler, u32 battler, enum Item item); +bool32 CanKnockOffItem(enum BattlerId fromBattler, enum BattlerId battler, enum Item item); bool32 IsAbilityOfRating(enum Ability ability, s32 rating); -bool32 AI_IsAbilityOnSide(u32 battlerId, enum Ability ability); -bool32 AI_MoveMakesContact(u32 battlerAtk, u32 battlerDef, enum Ability ability, enum HoldEffect holdEffect, enum Move move); -bool32 IsUnseenFistContactMove(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 IsConsideringZMove(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 ShouldUseZMove(u32 battlerAtk, u32 battlerDef, enum Move chosenMove); -void SetAIUsingGimmick(u32 battler, enum AIConsiderGimmick use); -bool32 IsAIUsingGimmick(u32 battler); -void DecideTerastal(u32 battler); -bool32 CanEndureHit(u32 battler, u32 battlerTarget, enum Move move); -bool32 ShouldFinalGambit(u32 battlerAtk, u32 battlerDef, bool32 aiIsFaster); -bool32 ShouldConsiderSelfSacrificeDamageEffect(u32 battlerAtk, u32 battlerDef, enum Move move, bool32 aiIsFaster); +bool32 AI_IsAbilityOnSide(enum BattlerId battlerId, enum Ability ability); +bool32 AI_MoveMakesContact(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability ability, enum HoldEffect holdEffect, enum Move move); +bool32 IsUnseenFistContactMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 IsConsideringZMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 ShouldUseZMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move chosenMove); +void SetAIUsingGimmick(enum BattlerId battler, enum AIConsiderGimmick use); +bool32 IsAIUsingGimmick(enum BattlerId battler); +void DecideTerastal(enum BattlerId battler); +bool32 CanEndureHit(enum BattlerId battler, enum BattlerId battlerTarget, enum Move move); +bool32 ShouldFinalGambit(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 aiIsFaster); +bool32 ShouldConsiderSelfSacrificeDamageEffect(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, bool32 aiIsFaster); // stat stage checks -bool32 AnyStatIsRaised(u32 battlerId); -bool32 AnyUsefulStatIsRaised(u32 battlerId); -bool32 CanLowerStat(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData, enum Stat stat); -bool32 BattlerStatCanRise(u32 battler, enum Ability battlerAbility, enum Stat stat); -bool32 AreBattlersStatsMaxed(u32 battler); -u32 CountPositiveStatStages(u32 battlerId); -u32 CountNegativeStatStages(u32 battlerId); +bool32 AnyStatIsRaised(enum BattlerId battlerId); +bool32 AnyUsefulStatIsRaised(enum BattlerId battlerId); +bool32 CanLowerStat(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData, enum Stat stat); +bool32 BattlerStatCanRise(enum BattlerId battler, enum Ability battlerAbility, enum Stat stat); +bool32 AreBattlersStatsMaxed(enum BattlerId battler); +u32 CountPositiveStatStages(enum BattlerId battlerId); +u32 CountNegativeStatStages(enum BattlerId battlerId); // move checks -bool32 Ai_IsPriorityBlocked(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData); +bool32 Ai_IsPriorityBlocked(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData); bool32 AI_CanMoveBeBlockedByTarget(struct BattleContext *ctx); bool32 MovesWithCategoryUnusable(u32 attacker, u32 target, enum DamageCategory category); -enum MoveComparisonResult CompareMoveEffects(enum Move move1, enum Move move2, u32 battlerAtk, u32 battlerDef, s32 noOfHitsToKo); -struct SimulatedDamage AI_CalcDamageSaveBattlers(enum Move move, u32 battlerAtk, u32 battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef); -bool32 IsAdditionalEffectBlocked(u32 battlerAtk, u32 abilityAtk, u32 battlerDef, enum Ability abilityDef); -struct SimulatedDamage AI_CalcDamage(enum Move move, u32 battlerAtk, u32 battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef, u32 weather, u32 fieldStatuses); -bool32 AI_IsDamagedByRecoil(u32 battler); +enum MoveComparisonResult CompareMoveEffects(enum Move move1, enum Move move2, enum BattlerId battlerAtk, enum BattlerId battlerDef, s32 noOfHitsToKo); +struct SimulatedDamage AI_CalcDamageSaveBattlers(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef); +bool32 IsAdditionalEffectBlocked(enum BattlerId battlerAtk, u32 abilityAtk, enum BattlerId battlerDef, enum Ability abilityDef); +struct SimulatedDamage AI_CalcDamage(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef, u32 weather, u32 fieldStatuses); +bool32 AI_IsDamagedByRecoil(enum BattlerId battler); u32 GetNoOfHitsToKO(u32 dmg, s32 hp); -u32 GetNoOfHitsToKOBattlerDmg(u32 dmg, u32 battlerDef); -u32 GetNoOfHitsToKOBattler(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, enum AiConsiderEndure considerEndure); -u32 GetBestNoOfHitsToKO(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext); -u32 GetCurrDamageHpPercent(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext); -uq4_12_t AI_GetMoveEffectiveness(enum Move move, u32 battlerAtk, u32 battlerDef); -enum Move *GetMovesArray(u32 battler); +u32 GetNoOfHitsToKOBattlerDmg(u32 dmg, enum BattlerId battlerDef); +u32 GetNoOfHitsToKOBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, enum AiConsiderEndure considerEndure); +u32 GetBestNoOfHitsToKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext); +u32 GetCurrDamageHpPercent(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext); +uq4_12_t AI_GetMoveEffectiveness(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef); +enum Move *GetMovesArray(enum BattlerId battler); bool32 IsConfusionMoveEffect(enum BattleMoveEffects moveEffect); -bool32 HasMove(u32 battlerId, enum Move move); -u32 GetBattlerMoveIndexWithEffect(u32 battler, enum BattleMoveEffects effect); -bool32 HasPhysicalBestMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext); -bool32 HasOnlyMovesWithCategory(u32 battlerId, enum DamageCategory category, bool32 onlyOffensive); -bool32 HasMoveWithCategory(u32 battler, enum DamageCategory category); -bool32 HasMoveWithType(u32 battler, enum Type type); -bool32 HasMoveWithEffect(u32 battler, enum BattleMoveEffects moveEffect); -bool32 HasMoveWithAIEffect(u32 battler, u32 aiEffect); -bool32 HasBattlerSideMoveWithEffect(u32 battler, enum BattleMoveEffects effect); -bool32 HasBattlerSideMoveWithAIEffect(u32 battler, u32 effect); -bool32 HasBattlerSideUsedMoveWithEffect(u32 battler, enum BattleMoveEffects effect); -bool32 HasNonVolatileMoveEffect(u32 battlerId, enum MoveEffect effect); -bool32 IsPowerBasedOnStatus(u32 battlerId, enum BattleMoveEffects effect, u32 argument); -bool32 HasMoveWithAdditionalEffect(u32 battlerId, enum MoveEffect moveEffect); -bool32 HasBattlerSideMoveWithAdditionalEffect(u32 battler, enum MoveEffect moveEffect); -bool32 HasMoveWithCriticalHitChance(u32 battlerId); -bool32 HasMoveWithMoveEffectExcept(u32 battlerId, enum MoveEffect moveEffect, enum BattleMoveEffects exception); -bool32 HasMoveThatLowersOwnStats(u32 battlerId); -bool32 HasMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef, u32 accCheck, bool32 ignoreStatus); -bool32 HasAnyKnownMove(u32 battlerId); +bool32 HasMove(enum BattlerId battlerId, enum Move move); +u32 GetBattlerMoveIndexWithEffect(enum BattlerId battler, enum BattleMoveEffects effect); +bool32 HasPhysicalBestMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext); +bool32 HasOnlyMovesWithCategory(enum BattlerId battlerId, enum DamageCategory category, bool32 onlyOffensive); +bool32 HasMoveWithCategory(enum BattlerId battler, enum DamageCategory category); +bool32 HasMoveWithType(enum BattlerId battler, enum Type type); +bool32 HasMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects moveEffect); +bool32 HasMoveWithAIEffect(enum BattlerId battler, u32 aiEffect); +bool32 HasBattlerSideMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects effect); +bool32 HasBattlerSideMoveWithAIEffect(enum BattlerId battler, u32 effect); +bool32 HasBattlerSideUsedMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects effect); +bool32 HasNonVolatileMoveEffect(enum BattlerId battlerId, enum MoveEffect effect); +bool32 IsPowerBasedOnStatus(enum BattlerId battlerId, enum BattleMoveEffects effect, u32 argument); +bool32 HasMoveWithAdditionalEffect(enum BattlerId battlerId, enum MoveEffect moveEffect); +bool32 HasBattlerSideMoveWithAdditionalEffect(enum BattlerId battler, enum MoveEffect moveEffect); +bool32 HasMoveWithCriticalHitChance(enum BattlerId battlerId); +bool32 HasMoveWithMoveEffectExcept(enum BattlerId battlerId, enum MoveEffect moveEffect, enum BattleMoveEffects exception); +bool32 HasMoveThatLowersOwnStats(enum BattlerId battlerId); +bool32 HasMoveWithLowAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 accCheck, bool32 ignoreStatus); +bool32 HasAnyKnownMove(enum BattlerId battlerId); bool32 IsAromaVeilProtectedEffect(enum BattleMoveEffects moveEffect); bool32 IsNonVolatileStatusMove(enum Move move); -bool32 IsMoveRedirectionPrevented(u32 battlerAtk, enum Move move, enum Ability atkAbility); +bool32 IsMoveRedirectionPrevented(enum BattlerId battlerAtk, enum Move move, enum Ability atkAbility); bool32 IsHazardMove(enum Move move); -bool32 IsTwoTurnNotSemiInvulnerableMove(u32 battlerAtk, enum Move move); -bool32 IsBattlerDamagedByStatus(u32 battler); -s32 ProtectChecks(u32 battlerAtk, u32 battlerDef, enum Move move, enum Move predictedMove); -bool32 ShouldRaiseAnyStat(u32 battlerAtk, u32 battlerDef); -bool32 ShouldSetWeather(u32 battler, u32 weather); -bool32 ShouldClearWeather(u32 battler, u32 weather); -bool32 ShouldSetFieldStatus(u32 battler, u32 fieldStatus); -bool32 ShouldClearFieldStatus(u32 battler, u32 fieldStatus); -bool32 HasSleepMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef); -bool32 HasHealingEffect(u32 battler); +bool32 IsTwoTurnNotSemiInvulnerableMove(enum BattlerId battlerAtk, enum Move move); +bool32 IsBattlerDamagedByStatus(enum BattlerId battler); +s32 ProtectChecks(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Move predictedMove); +bool32 ShouldRaiseAnyStat(enum BattlerId battlerAtk, enum BattlerId battlerDef); +bool32 ShouldSetWeather(enum BattlerId battler, u32 weather); +bool32 ShouldClearWeather(enum BattlerId battler, u32 weather); +bool32 ShouldSetFieldStatus(enum BattlerId battler, u32 fieldStatus); +bool32 ShouldClearFieldStatus(enum BattlerId battler, u32 fieldStatus); +bool32 HasSleepMoveWithLowAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef); +bool32 HasHealingEffect(enum BattlerId battler); bool32 IsTrappingMove(enum Move move); -bool32 HasTrappingMoveEffect(u32 battler); -bool32 IsFlinchGuaranteed(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 HasChoiceEffect(u32 battler); -bool32 HasThawingMove(u32 battler); -bool32 HasUsableWhileAsleepMove(u32 battler); +bool32 HasTrappingMoveEffect(enum BattlerId battler); +bool32 IsFlinchGuaranteed(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 HasChoiceEffect(enum BattlerId battler); +bool32 HasThawingMove(enum BattlerId battler); +bool32 HasUsableWhileAsleepMove(enum BattlerId battler); bool32 IsStatRaisingEffect(enum BattleMoveEffects effect); bool32 IsStatLoweringEffect(enum BattleMoveEffects effect); bool32 IsSelfStatLoweringEffect(enum MoveEffect effect); @@ -233,107 +233,107 @@ bool32 IsSwitchOutEffect(enum BattleMoveEffects effect); bool32 IsChaseEffect(enum BattleMoveEffects effect); bool32 IsAttackBoostMoveEffect(enum BattleMoveEffects effect); bool32 IsUngroundingEffect(enum BattleMoveEffects effect); -bool32 HasMoveWithFlag(u32 battler, MoveFlag getFlag); +bool32 HasMoveWithFlag(enum BattlerId battler, MoveFlag getFlag); bool32 IsHazardClearingMove(enum Move move); bool32 IsSubstituteEffect(enum BattleMoveEffects effect); bool32 IsSelfSacrificeEffect(enum Move move); u32 GetAIExplosionChanceFromHP(u32 hpPercent); // status checks -bool32 AI_CanBeConfused(u32 battlerAtk, u32 battlerDef, enum Move move, enum Ability ability); -bool32 IsBattlerIncapacitated(u32 battler, enum Ability ability); -bool32 AI_CanPutToSleep(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); -bool32 ShouldPoison(u32 battlerAtk, u32 battlerDef); -bool32 AI_CanPoison(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); -bool32 AI_CanParalyze(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); -bool32 AI_CanConfuse(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove); -bool32 ShouldBurn(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 ShouldFreezeOrFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 ShouldParalyze(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 AI_CanBurn(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove); -bool32 AI_CanGiveFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove); -bool32 AI_CanBeInfatuated(u32 battlerAtk, u32 battlerDef, enum Ability defAbility); -bool32 AnyPartyMemberStatused(u32 battlerId, bool32 checkSoundproof); -bool32 ShouldTryToFlinch(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move); -bool32 ShouldTrap(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 IsWakeupTurn(u32 battler); -bool32 AI_IsBattlerAsleepOrComatose(u32 battlerId); +bool32 AI_CanBeConfused(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Ability ability); +bool32 IsBattlerIncapacitated(enum BattlerId battler, enum Ability ability); +bool32 AI_CanPutToSleep(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); +bool32 ShouldPoison(enum BattlerId battlerAtk, enum BattlerId battlerDef); +bool32 AI_CanPoison(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); +bool32 AI_CanParalyze(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove); +bool32 AI_CanConfuse(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove); +bool32 ShouldBurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 ShouldFreezeOrFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 ShouldParalyze(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 AI_CanBurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove); +bool32 AI_CanGiveFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove); +bool32 AI_CanBeInfatuated(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility); +bool32 AnyPartyMemberStatused(enum BattlerId battlerId, bool32 checkSoundproof); +bool32 ShouldTryToFlinch(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move); +bool32 ShouldTrap(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 IsWakeupTurn(enum BattlerId battler); +bool32 AI_IsBattlerAsleepOrComatose(enum BattlerId battlerId); // ability logic bool32 IsMoxieTypeAbility(enum Ability ability); bool32 DoesAbilityRaiseStatsWhenLowered(enum Ability ability); -bool32 ShouldTriggerAbility(u32 battlerAtk, u32 battlerDef, enum Ability ability); -bool32 CanEffectChangeAbility(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData); -void AbilityChangeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score, struct AiLogicData *aiData); -enum AIScore BattlerBenefitsFromAbilityScore(u32 battler, enum Ability ability, struct AiLogicData *aiData); +bool32 ShouldTriggerAbility(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability ability); +bool32 CanEffectChangeAbility(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData); +void AbilityChangeScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score, struct AiLogicData *aiData); +enum AIScore BattlerBenefitsFromAbilityScore(enum BattlerId battler, enum Ability ability, struct AiLogicData *aiData); // partner logic -bool32 IsTargetingPartner(u32 battlerAtk, u32 battlerDef); +bool32 IsTargetingPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef); // IsTargetingPartner includes a check to make sure the adjacent pokemon is truly a partner. -enum Move GetAllyChosenMove(u32 battlerId); +enum Move GetAllyChosenMove(enum BattlerId battlerId); bool32 IsBattle1v1(void); // IsBattle1v1 is distinct from !IsDoubleBattle. If the player is fighting Maxie and Tabitha, with Steven as their partner, and both Tabitha and Steven have run out of Pokemon, the battle is 1v1, even though mechanically it is a Double Battle for how battlers and flags are set. // Most AI checks should be using IsBattle1v1; most engine checks should be using !IsDoubleBattle -bool32 HasTwoOpponents(u32 battler); +bool32 HasTwoOpponents(enum BattlerId battler); // HasTwoOpponents checks if the opposing side has two pokemon. Partner state is irrelevant. e.g., Dragon Darts hits one time with two opponents and twice with one opponent. -bool32 HasPartner(u32 battler); -bool32 HasPartnerIgnoreFlags(u32 battler); +bool32 HasPartner(enum BattlerId battler); +bool32 HasPartnerIgnoreFlags(enum BattlerId battler); // HasPartner respects the Attacks Partner AI flag; HasPartnerIgnoreFlags checks only if a live pokemon is adjacent. -bool32 AreMovesEquivalent(u32 battlerAtk, u32 battlerAtkPartner, enum Move move, enum Move partnerMove); -bool32 DoesPartnerHaveSameMoveEffect(u32 battlerAtkPartner, u32 battlerDef, enum Move move, enum Move partnerMove); -bool32 PartnerMoveEffectIsStatusSameTarget(u32 battlerAtkPartner, u32 battlerDef, enum Move partnerMove); -bool32 PartnerMoveEffectIs(u32 battlerAtkPartner, enum Move partnerMove, enum BattleMoveEffects effectCheck); -bool32 PartnerMoveIs(u32 battlerAtkPartner, enum Move partnerMove, enum Move moveCheck); -bool32 PartnerMoveIsSameAsAttacker(u32 battlerAtkPartner, u32 battlerDef, enum Move move, enum Move partnerMove); -bool32 PartnerMoveIsSameNoTarget(u32 battlerAtkPartner, enum Move move, enum Move partnerMove); +bool32 AreMovesEquivalent(enum BattlerId battlerAtk, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove); +bool32 DoesPartnerHaveSameMoveEffect(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move move, enum Move partnerMove); +bool32 PartnerMoveEffectIsStatusSameTarget(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move partnerMove); +bool32 PartnerMoveEffectIs(enum BattlerId battlerAtkPartner, enum Move partnerMove, enum BattleMoveEffects effectCheck); +bool32 PartnerMoveIs(enum BattlerId battlerAtkPartner, enum Move partnerMove, enum Move moveCheck); +bool32 PartnerMoveIsSameAsAttacker(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move move, enum Move partnerMove); +bool32 PartnerMoveIsSameNoTarget(enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove); bool32 PartnerMoveActivatesSleepClause(enum Move partnerMove); -bool32 ShouldUseWishAromatherapy(u32 battlerAtk, u32 battlerDef, enum Move move); -u32 GetFriendlyFireKOThreshold(u32 battler); -bool32 IsAllyProtectingFromMove(u32 battlerAtk, enum Move attackerMove, enum Move allyMove); +bool32 ShouldUseWishAromatherapy(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +u32 GetFriendlyFireKOThreshold(enum BattlerId battler); +bool32 IsAllyProtectingFromMove(enum BattlerId battlerAtk, enum Move attackerMove, enum Move allyMove); // party logic struct BattlePokemon *AllocSaveBattleMons(void); void FreeRestoreBattleMons(struct BattlePokemon *savedBattleMons); struct AiLogicData *AllocSaveAiLogicData(void); void FreeRestoreAiLogicData(struct AiLogicData *savedAiLogicData); -s32 CountUsablePartyMons(u32 battlerId); -bool32 IsPartyFullyHealedExceptBattler(u32 battler); -bool32 PartyHasMoveCategory(u32 battlerId, enum DamageCategory category); -bool32 SideHasMoveCategory(u32 battlerId, enum DamageCategory category); -void GetAIPartyIndexes(u32 battlerId, s32 *firstId, s32 *lastId); -u32 GetActiveBattlerIds(u32 battler, u32 *battlerIn1, u32 *battlerIn2); -bool32 IsPartyMonOnFieldOrChosenToSwitch(u32 partyIndex, u32 battlerIn1, u32 battlerIn2); +s32 CountUsablePartyMons(enum BattlerId battlerId); +bool32 IsPartyFullyHealedExceptBattler(enum BattlerId battler); +bool32 PartyHasMoveCategory(enum BattlerId battlerId, enum DamageCategory category); +bool32 SideHasMoveCategory(enum BattlerId battlerId, enum DamageCategory category); +void GetAIPartyIndexes(enum BattlerId battlerId, s32 *firstId, s32 *lastId); +u32 GetActiveBattlerIds(enum BattlerId battler, enum BattlerId *battlerIn1, enum BattlerId *battlerIn2); +bool32 IsPartyMonOnFieldOrChosenToSwitch(u32 partyIndex, enum BattlerId battlerIn1, enum BattlerId battlerIn2); // score increases -enum AIScore IncreaseStatUpScore(u32 battlerAtk, u32 battlerDef, enum StatChange statId); -enum AIScore IncreaseStatUpScoreContrary(u32 battlerAtk, u32 battlerDef, enum StatChange statId); -enum AIScore IncreaseStatDownScore(u32 battlerAtk, u32 battlerDef, enum Stat stat); -void IncreasePoisonScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -void IncreaseBurnScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -void IncreaseParalyzeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -void IncreaseSleepScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -void IncreaseConfusionScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -void IncreaseFrostbiteScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -bool32 HasHPForDamagingSetup(u32 battlerAtk, u32 battlerDef, u32 hpThreshold); +enum AIScore IncreaseStatUpScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum StatChange statId); +enum AIScore IncreaseStatUpScoreContrary(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum StatChange statId); +enum AIScore IncreaseStatDownScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Stat stat); +void IncreasePoisonScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +void IncreaseBurnScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +void IncreaseParalyzeScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +void IncreaseSleepScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +void IncreaseConfusionScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +void IncreaseFrostbiteScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +bool32 HasHPForDamagingSetup(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 hpThreshold); -s32 AI_TryToClearStats(u32 battlerAtk, u32 battlerDef, bool32 isDoubleBattle); -bool32 AI_ShouldCopyStatChanges(u32 battlerAtk, u32 battlerDef); -bool32 AI_ShouldSetUpHazards(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData); -void IncreaseTidyUpScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score); -bool32 AI_ShouldSpicyExtract(u32 battlerAtk, u32 battlerAtkPartner, enum Move move, struct AiLogicData *aiData); -u32 IncreaseSubstituteMoveScore(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 IsBattlerItemEnabled(u32 battler); -bool32 IsBattlerPredictedToSwitch(u32 battler); -enum Move GetIncomingMove(u32 battler, u32 opposingBattler, struct AiLogicData *aiData); -enum Move GetIncomingMoveSpeedCheck(u32 battler, u32 opposingBattler, struct AiLogicData *aiData); +s32 AI_TryToClearStats(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 isDoubleBattle); +bool32 AI_ShouldCopyStatChanges(enum BattlerId battlerAtk, enum BattlerId battlerDef); +bool32 AI_ShouldSetUpHazards(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData); +void IncreaseTidyUpScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score); +bool32 AI_ShouldSpicyExtract(enum BattlerId battlerAtk, enum BattlerId battlerAtkPartner, enum Move move, struct AiLogicData *aiData); +u32 IncreaseSubstituteMoveScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 IsBattlerItemEnabled(enum BattlerId battler); +bool32 IsBattlerPredictedToSwitch(enum BattlerId battler); +enum Move GetIncomingMove(enum BattlerId battler, enum BattlerId opposingBattler, struct AiLogicData *aiData); +enum Move GetIncomingMoveSpeedCheck(enum BattlerId battler, enum BattlerId opposingBattler, struct AiLogicData *aiData); bool32 IsNaturalEnemy(u32 speciesAttacker, u32 speciesTarget); -bool32 AI_OpponentCanFaintAiWithMod(u32 battler, u32 healAmount); -void SetBattlerFieldStatusForSwitchin(u32 battler); -bool32 ShouldInstructPartner(u32 battlerDef, enum Move move); -bool32 CanMoveBeBouncedBack(u32 battler, enum Move move); +bool32 AI_OpponentCanFaintAiWithMod(enum BattlerId battler, u32 healAmount); +void SetBattlerFieldStatusForSwitchin(enum BattlerId battler); +bool32 ShouldInstructPartner(enum BattlerId partner, enum Move move); +bool32 CanMoveBeBouncedBack(enum BattlerId battler, enum Move move); // Switching and item helpers -bool32 AiExpectsToFaintPlayer(u32 battler); +bool32 AiExpectsToFaintPlayer(enum BattlerId battler); // These are for the purpose of not doubling up on moves during double battles. // Used in GetAIEffectGroup for move effects and GetAIEffectGroupFromMove for additional effects diff --git a/include/battle_anim.h b/include/battle_anim.h index fb11d633ab..af650c5363 100644 --- a/include/battle_anim.h +++ b/include/battle_anim.h @@ -73,8 +73,8 @@ extern u8 gAnimFriendship; extern u16 gWeatherMoveAnim; extern s16 gBattleAnimArgs[ANIM_ARGS_COUNT]; extern u8 gAnimMoveTurn; -extern u8 gBattleAnimAttacker; -extern u8 gBattleAnimTarget; +extern enum BattlerId gBattleAnimAttacker; +extern enum BattlerId gBattleAnimTarget; extern u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT]; extern u8 gAnimCustomPanning; extern u16 gAnimMoveIndex; @@ -85,9 +85,9 @@ void LaunchBattleAnimation(u32 animType, u32 animId); void DestroyAnimSprite(struct Sprite *sprite); void DestroyAnimVisualTask(u8 taskId); void DestroyAnimSoundTask(u8 taskId); -u8 GetAnimBattlerId(u8 wantedBattler); -bool8 IsBattlerSpriteVisible(u8 battler); -void MoveBattlerSpriteToBG(u8 battler, bool8 toBG_2, bool8 setSpriteInvisible); +enum BattlerId GetAnimBattlerId(enum AnimBattler wantedBattler); +bool8 IsBattlerSpriteVisible(enum BattlerId battler); +void MoveBattlerSpriteToBG(enum BattlerId battler, bool8 toBG_2, bool8 setSpriteInvisible); bool8 IsContest(void); s8 BattleAnimAdjustPanning(s8 pan); s8 BattleAnimAdjustPanning2(s8 pan); @@ -113,18 +113,18 @@ void AnimTranslateLinearAndFlicker_Flipped(struct Sprite *sprite); void AnimWeatherBallUp(struct Sprite *sprite); void AnimWeatherBallDown(struct Sprite *sprite); void AnimSpinningSparkle(struct Sprite *sprite); -void SetAverageBattlerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y); -void SetToPartnerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y); +void SetAverageBattlerPositions(enum BattlerId battler, bool8 respectMonPicOffsets, s16 *x, s16 *y); +void SetToPartnerPositions(enum BattlerId battler, bool8 respectMonPicOffsets, s16 *x, s16 *y); void DestroySpriteAndMatrix(struct Sprite *sprite); void TranslateSpriteLinearFixedPoint(struct Sprite *sprite); void InitSpritePosToAnimAttacker(struct Sprite *sprite, bool8 respectMonPicOffsets); void InitSpritePosToAnimTarget(struct Sprite *sprite, bool8 respectMonPicOffsets); -bool32 InitSpritePosToAnimBattler(u32 animBattlerId, struct Sprite *sprite, bool8 respectMonPicOffsets); +bool32 InitSpritePosToAnimBattler(enum AnimBattler animBattlerId, struct Sprite *sprite, bool8 respectMonPicOffsets); void StartAnimLinearTranslation(struct Sprite *sprite); void InitAnimArcTranslation(struct Sprite *sprite); bool8 AnimTranslateLinear(struct Sprite *sprite); void TranslateAnimSpriteToTargetMonLocation(struct Sprite *sprite); -u8 GetBattlerSpriteCoord2(u8 battler, u8 coordType); +u8 GetBattlerSpriteCoord2(enum BattlerId battler, u8 coordType); void InitAnimLinearTranslationWithSpeed(struct Sprite *sprite); u16 ArcTan2Neg(s16 x, s16 y); void TrySetSpriteRotScale(struct Sprite *sprite, bool8 recalcCenterVector, s16 xScale, s16 yScale, u16 rotation); @@ -133,19 +133,19 @@ void TranslateSpriteLinearAndFlicker(struct Sprite *sprite); void SetSpriteCoordsToAnimAttackerCoords(struct Sprite *sprite); void RunStoredCallbackWhenAnimEnds(struct Sprite *sprite); void SetAnimSpriteInitialXOffset(struct Sprite *sprite, s16 xOffset); -s16 GetBattlerSpriteCoordAttr(u8 battler, u8 attr); -u8 GetBattlerYCoordWithElevation(u8 battler); +s16 GetBattlerSpriteCoordAttr(enum BattlerId battler, u8 attr); +u8 GetBattlerYCoordWithElevation(enum BattlerId battler); void WaitAnimForDuration(struct Sprite *sprite); void AnimTravelDiagonally(struct Sprite *sprite); void InitAnimLinearTranslation(struct Sprite *sprite); void AnimTranslateLinear_WithFollowup(struct Sprite *sprite); -u8 GetBattlerSpriteBGPriority(u8 battler); +u8 GetBattlerSpriteBGPriority(enum BattlerId battler); void *LoadPointerFromVars(s16 lo, s16 hi); void StorePointerInVars(s16 *lo, s16 *hi, const void *ptr); void InitPrioritiesForVisibleBattlers(void); void GetBattleAnimBg1Data(struct BattleAnimBgData *out); void GetBattleAnimBgData(struct BattleAnimBgData *out, u32 bgId); -u8 GetBattlerSpriteSubpriority(u8 battler); +u8 GetBattlerSpriteSubpriority(enum BattlerId battler); bool8 TranslateAnimHorizontalArc(struct Sprite *sprite); void TranslateSpriteLinearByIdFixedPoint(struct Sprite *sprite); void ResetSpriteRotScale(u8 spriteId); @@ -155,8 +155,8 @@ void PrepareBattlerSpriteForRotScale(u8 spriteId, u8 objMode); void SetBattlerSpriteYOffsetFromRotation(u8 spriteId); u32 GetBattlePalettesMask(bool8 battleBackground, bool8 attacker, bool8 target, bool8 attackerPartner, bool8 targetPartner, bool8 anim1, bool8 anim2); u32 GetBattleMonSpritePalettesMask(u8 playerLeft, u8 playerRight, u8 opponentLeft, u8 opponentRight); -u8 GetSpritePalIdxByBattler(u8 battler); -s16 CloneBattlerSpriteWithBlend(u8 animBattler); +u8 GetSpritePalIdxByBattler(enum BattlerId battler); +s16 CloneBattlerSpriteWithBlend(enum AnimBattler animBattler); void DestroySpriteWithActiveSheet(struct Sprite *sprite); u8 CreateInvisibleSpriteCopy(int battler, u8 spriteId, int species); void AnimLoadCompressedBgTilemapHandleContest(struct BattleAnimBgData *data, const void *src, bool32 largeScreen); @@ -180,8 +180,8 @@ void SetGrayscaleOrOriginalPalette(u16 paletteNum, bool8 restoreOriginalColor); void PrepareAffineAnimInTaskData(struct Task *task, u8 spriteId, const union AffineAnimCmd *affineAnimCmds); bool8 RunAffineAnimFromTaskData(struct Task *task); void AnimThrowProjectile(struct Sprite *sprite); -void GetBgDataForTransform(struct BattleAnimBgData *out, u8 battler); -u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, bool8 isShiny, u32 battler); +void GetBgDataForTransform(struct BattleAnimBgData *out, enum BattlerId battler); +u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, bool8 isShiny, enum BattlerId battler); void ResetSpriteRotScale_PreserveAffine(struct Sprite *sprite); void Trade_MoveSelectedMonToTarget(struct Sprite *sprite); void DestroyAnimVisualTaskAndDisableBlend(u8 taskId); @@ -210,17 +210,17 @@ enum BATTLER_COORD_ATTR_RAW_BOTTOM, }; -u8 GetBattlerSpriteCoord(u8 battler, u8 coordType); +u8 GetBattlerSpriteCoord(enum BattlerId battler, u8 coordType); -bool8 IsBattlerSpritePresent(u8 battler); +bool8 IsBattlerSpritePresent(enum BattlerId battler); void ClearBattleAnimBg(u32 bgId); -u8 GetAnimBattlerSpriteId(u8 wantedBattler); +u8 GetAnimBattlerSpriteId(enum AnimBattler wantedBattler); u8 GetBattleBgPaletteNum(void); -u8 GetBattlerSpriteBGPriorityRank(u8 battler); +u8 GetBattlerSpriteBGPriorityRank(enum BattlerId battler); void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*callback)(struct Sprite *)); void SetSpritePrimaryCoordsFromSecondaryCoords(struct Sprite *sprite); -u8 GetBattlerSpriteDefault_Y(u8 battler); -u8 GetSubstituteSpriteDefault_Y(u8 battler); +u8 GetBattlerSpriteDefault_Y(enum BattlerId battler); +u8 GetSubstituteSpriteDefault_Y(enum BattlerId battler); // battle_anim_status_effects.c #define STAT_ANIM_PLUS1 (MOVE_EFFECT_ATK_PLUS_1 - 1) @@ -244,7 +244,7 @@ enum StatAnimPal STAT_ANIM_PAL_MULTIPLE = 0xFF }; -void LaunchStatusAnimation(u8 battler, u8 statusAnimId); +void LaunchStatusAnimation(enum BattlerId battler, u8 statusAnimId); extern const union AnimCmd *const gAnims_SpinningSparkle[]; // battle_anim_ground.c @@ -258,17 +258,17 @@ extern const union AnimCmd *const sAnims_MudSlapMud[]; extern const union AffineAnimCmd *const gAffineAnims_SpinningBone[]; // battle_anim_throw.c -void TryShinyAnimation(u8 battler, struct Pokemon *mon); +void TryShinyAnimation(enum BattlerId battler, struct Pokemon *mon); u8 AnimateBallOpenParticles(u8 x, u8 y, u8 priority, u8 subpriority, u8 ballId); u8 LaunchBallFadeMonTask(bool8 unfadeLater, u8 spritePalNum, u32 selectedPalettes, u8 ballId); bool32 IsCriticalCapture(void); // battle_anim_utility_funcs.c void InitStatsChangeAnimation(u8 taskId); -void StartMonScrollingBgMask(u8 taskId, int UNUSED unused, u16 scrollSpeed, u8 battler, bool8 includePartner, u8 numFadeSteps, u8 fadeStepDelay, u8 duration, const u32 *gfx, const u32 *tilemap, const u16 *palette); +void StartMonScrollingBgMask(u8 taskId, int UNUSED unused, u16 scrollSpeed, enum BattlerId battler, bool8 includePartner, u8 numFadeSteps, u8 fadeStepDelay, u8 duration, const u32 *gfx, const u32 *tilemap, const u16 *palette); // battle_anim_effects_1.c void AnimFalseSwipeSlice_Step3(struct Sprite *); -void SetSpriteNextToMonHead(u8 battler, struct Sprite *sprite); +void SetSpriteNextToMonHead(enum BattlerId battler, struct Sprite *sprite); void AnimMoveTwisterParticle(struct Sprite *sprite); void AnimParticleBurst(struct Sprite *sprite); void AnimPowerAbsorptionOrb(struct Sprite *sprite); @@ -409,7 +409,7 @@ u8 SmokescreenImpact(s16 x, s16 y, bool8 persist); u32 UnpackSelectedBattlePalettes(s16 selector); -u8 GetBattlerSpriteFinal_Y(u8 battler, u16 species, bool8 a3); +u8 GetBattlerSpriteFinal_Y(enum BattlerId battler, u16 species, bool8 a3); extern const struct OamData gOamData_AffineOff_ObjNormal_8x16; extern const struct OamData gOamData_AffineNormal_ObjBlend_16x16; diff --git a/include/battle_arena.h b/include/battle_arena.h index b282009c60..c27e46be0d 100644 --- a/include/battle_arena.h +++ b/include/battle_arena.h @@ -6,9 +6,9 @@ void CallBattleArenaFunction(void); u8 BattleArena_ShowJudgmentWindow(u8 *state); void BattleArena_InitPoints(void); -void BattleArena_AddMindPoints(u8 battler); -void BattleArena_AddSkillPoints(u8 battler); -void BattleArena_DeductSkillPoints(u8 battler, enum StringID stringId); +void BattleArena_AddMindPoints(enum BattlerId battler); +void BattleArena_AddSkillPoints(enum BattlerId battler); +void BattleArena_DeductSkillPoints(enum BattlerId battler, enum StringID stringId); void DrawArenaRefereeTextBox(void); void EraseArenaRefereeTextBox(void); diff --git a/include/battle_controllers.h b/include/battle_controllers.h index 8990ad3065..c5c5efc666 100644 --- a/include/battle_controllers.h +++ b/include/battle_controllers.h @@ -1,7 +1,7 @@ #ifndef GUARD_BATTLE_CONTROLLERS_H #define GUARD_BATTLE_CONTROLLERS_H -typedef void (*BattleControllerFunc)(u32 battler); +typedef void (*BattleControllerFunc)(enum BattlerId battler); enum { REQUEST_ALL_BATTLE, @@ -90,47 +90,47 @@ enum BattleController // (e.g. MarkBattlerForControllerExec) instead of using these macros // directly. -static inline void MarkBattleControllerActiveOnLocal(u32 battler) +static inline void MarkBattleControllerActiveOnLocal(enum BattlerId battler) { gBattleControllerExecFlags |= (1u << battler); } -static inline void MarkBattleControllerIdleOnLocal(u32 battler) +static inline void MarkBattleControllerIdleOnLocal(enum BattlerId battler) { gBattleControllerExecFlags &= ~(1u << battler); } -static inline bool32 IsBattleControllerActiveOnLocal(u32 battler) +static inline bool32 IsBattleControllerActiveOnLocal(enum BattlerId battler) { return gBattleControllerExecFlags & (1u << battler); } -static inline void MarkBattleControllerMessageOutboundOverLink(u32 battler) +static inline void MarkBattleControllerMessageOutboundOverLink(enum BattlerId battler) { gBattleControllerExecFlags |= ((1u << battler) << (32 - MAX_BATTLERS_COUNT)); } -static inline void MarkBattleControllerMessageSynchronizedOverLink(u32 battler) +static inline void MarkBattleControllerMessageSynchronizedOverLink(enum BattlerId battler) { gBattleControllerExecFlags &= ~((1 << 28) << (battler)); } -static inline bool32 IsBattleControllerMessageSynchronizedOverLink(u32 battler) +static inline bool32 IsBattleControllerMessageSynchronizedOverLink(enum BattlerId battler) { return gBattleControllerExecFlags & (1u << (battler + 28)); } -static inline void MarkBattleControllerActiveForPlayer(u32 battler, u32 playerId) +static inline void MarkBattleControllerActiveForPlayer(enum BattlerId battler, u32 playerId) { gBattleControllerExecFlags |= ((1u << battler) << ((playerId) << 2)); } -static inline void MarkBattleControllerIdleForPlayer(u32 battler, u32 playerId) +static inline void MarkBattleControllerIdleForPlayer(enum BattlerId battler, u32 playerId) { gBattleControllerExecFlags &= ~((1u << battler) << ((playerId) * 4)); } -static inline bool32 IsBattleControllerActiveForPlayer(u32 battler, u32 playerId) +static inline bool32 IsBattleControllerActiveForPlayer(enum BattlerId battler, u32 playerId) { return gBattleControllerExecFlags & ((1u << battler) << ((playerId) * 4)); } @@ -138,7 +138,7 @@ static inline bool32 IsBattleControllerActiveForPlayer(u32 battler, u32 playerId // This actually checks if a specific controller is active on any player or if // *any* controller is pending sync over link communications, but the macro name // can only be so specific before it just gets ridiculous. -static inline bool32 IsBattleControllerActiveOrPendingSyncAnywhere(u32 battler) +static inline bool32 IsBattleControllerActiveOrPendingSyncAnywhere(enum BattlerId battler) { return gBattleControllerExecFlags & ( (1u << battler) @@ -283,8 +283,8 @@ enum }; extern struct UnusedControllerStruct gUnusedControllerStruct; -extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler); -extern void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(u32 battler); +extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(enum BattlerId battler); +extern void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(enum BattlerId battler); extern u8 gBattleControllerData[MAX_BATTLERS_COUNT]; extern u8 gBattlerBattleController[MAX_BATTLERS_COUNT]; @@ -294,175 +294,175 @@ void SetUpBattleVarsAndBirchZigzagoon(void); void InitBattleControllers(void); bool32 IsValidForBattle(struct Pokemon *mon); void TryReceiveLinkBattleData(void); -void PrepareBufferDataTransferLink(u32 battler, u32 bufferId, u16 size, u8 *data); -void UpdateFriendshipFromXItem(u32 battler); +void PrepareBufferDataTransferLink(enum BattlerId battler, u32 bufferId, u16 size, u8 *data); +void UpdateFriendshipFromXItem(enum BattlerId battler); bool32 IsAiVsAiBattle(void); -bool32 BattlerIsPlayer(u32 battlerId); -bool32 BattlerIsPartner(u32 battlerId); -bool32 BattlerIsOpponent(u32 battlerId); -bool32 BattlerIsRecorded(u32 battlerId); -bool32 BattlerIsLink(u32 battlerId); -bool32 BattlerIsWally(u32 battlerId); -bool32 BattlerHasAi(u32 battlerId); +bool32 BattlerIsPlayer(enum BattlerId battlerId); +bool32 BattlerIsPartner(enum BattlerId battlerId); +bool32 BattlerIsOpponent(enum BattlerId battlerId); +bool32 BattlerIsRecorded(enum BattlerId battlerId); +bool32 BattlerIsLink(enum BattlerId battlerId); +bool32 BattlerIsWally(enum BattlerId battlerId); +bool32 BattlerHasAi(enum BattlerId battlerId); // emitters -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 dontClearTransform, 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, enum Move move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, u8 multihit); -void BtlController_EmitPrintString(u32 battler, u32 bufferId, enum StringID stringId); -void BtlController_EmitPrintSelectionString(u32 battler, u32 bufferId, enum StringID stringId); -void BtlController_EmitChooseAction(u32 battler, u32 bufferId, u8 action, enum Item 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 battlerPreventingSwitchout, 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 status); -void BtlController_EmitStatusAnimation(u32 battler, u32 bufferId, bool8 isVolatile, 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 BtlController_EmitGetMonData(enum BattlerId battler, u32 bufferId, u8 requestId, u8 monToCheck); +void BtlController_EmitSetMonData(enum BattlerId battler, u32 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data); +void BtlController_EmitLoadMonSprite(enum BattlerId battler, u32 bufferId); +void BtlController_EmitSwitchInAnim(enum BattlerId battler, u32 bufferId, u8 partyId, bool8 dontClearTransform, bool8 dontClearSubstituteBit); +void BtlController_EmitReturnMonToBall(enum BattlerId battler, u32 bufferId, bool8 skipAnim); +void BtlController_EmitDrawTrainerPic(enum BattlerId battler, u32 bufferId); +void BtlController_EmitTrainerSlide(enum BattlerId battler, u32 bufferId); +void BtlController_EmitTrainerSlideBack(enum BattlerId battler, u32 bufferId); +void BtlController_EmitFaintAnimation(enum BattlerId battler, u32 bufferId); +void BtlController_EmitBallThrowAnim(enum BattlerId battler, u32 bufferId, u8 caseId); +void BtlController_EmitMoveAnimation(enum BattlerId battler, u32 bufferId, enum Move move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, u8 multihit); +void BtlController_EmitPrintString(enum BattlerId battler, u32 bufferId, enum StringID stringId); +void BtlController_EmitPrintSelectionString(enum BattlerId battler, u32 bufferId, enum StringID stringId); +void BtlController_EmitChooseAction(enum BattlerId battler, u32 bufferId, u8 action, enum Item itemId); +void BtlController_EmitYesNoBox(enum BattlerId battler, u32 bufferId); +void BtlController_EmitChooseMove(enum BattlerId battler, u32 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData); +void BtlController_EmitChooseItem(enum BattlerId battler, u32 bufferId, u8 *battlePartyOrder); +void BtlController_EmitChoosePokemon(enum BattlerId battler, u32 bufferId, u8 caseId, u8 slotId, u16 abilityId, enum BattlerId battlerPreventingSwitchout, u8 *data); +void BtlController_EmitHealthBarUpdate(enum BattlerId battler, u32 bufferId, u16 hpValue); +void BtlController_EmitExpUpdate(enum BattlerId battler, u32 bufferId, u8 partyId, s32 expPoints); +void BtlController_EmitStatusIconUpdate(enum BattlerId battler, u32 bufferId, u32 status); +void BtlController_EmitStatusAnimation(enum BattlerId battler, u32 bufferId, bool8 isVolatile, u32 status); +void BtlController_EmitDataTransfer(enum BattlerId battler, u32 bufferId, u16 size, void *data); +void BtlController_EmitTwoReturnValues(enum BattlerId battler, u32 bufferId, u8 ret8, u32 ret32); +void BtlController_EmitChosenMonReturnValue(enum BattlerId battler, u32 bufferId, u8 partyId, u8 *battlePartyOrder); +void BtlController_EmitOneReturnValue(enum BattlerId battler, u32 bufferId, u16 ret); +void BtlController_EmitOneReturnValue_Duplicate(enum BattlerId battler, u32 bufferId, u16 ret); +void BtlController_EmitHitAnimation(enum BattlerId battler, u32 bufferId); +void BtlController_EmitCantSwitch(enum BattlerId battler, u32 bufferId); +void BtlController_EmitPlaySE(enum BattlerId battler, u32 bufferId, u16 songId); +void BtlController_EmitPlayFanfareOrBGM(enum BattlerId battler, u32 bufferId, u16 songId, bool8 playBGM); +void BtlController_EmitFaintingCry(enum BattlerId battler, u32 bufferId); +void BtlController_EmitIntroSlide(enum BattlerId battler, u32 bufferId, u8 terrainId); +void BtlController_EmitIntroTrainerBallThrow(enum BattlerId battler, u32 bufferId); +void BtlController_EmitDrawPartyStatusSummary(enum BattlerId battler, u32 bufferId, struct HpAndStatus *hpAndStatus, u8 flags); +void BtlController_EmitHidePartyStatusSummary(enum BattlerId battler, u32 bufferId); +void BtlController_EmitEndBounceEffect(enum BattlerId battler, u32 bufferId); +void BtlController_EmitSpriteInvisibility(enum BattlerId battler, u32 bufferId, bool8 isInvisible); +void BtlController_EmitBattleAnimation(enum BattlerId battler, u32 bufferId, u8 animationId, u16 argument); +void BtlController_EmitLinkStandbyMsg(enum BattlerId battler, u32 bufferId, u8 mode, bool32 record); +void BtlController_EmitResetActionMoveSelection(enum BattlerId battler, u32 bufferId, u8 caseId); +void BtlController_EmitEndLinkBattle(enum BattlerId battler, u32 bufferId, u8 battleOutcome); +void BtlController_EmitDebugMenu(enum BattlerId battler, u32 bufferId); -void BtlController_Complete(u32 battler); // Can be used for all the controllers. -void BtlController_Empty(u32 battler); // Empty command, does nothing, only completes the execution. -void BtlController_TerminatorNop(u32 battler); // Dummy function at the end of the table. -void BattleControllerDummy(u32 battler); -void StartSendOutAnim(u32 battler, bool32 dontClearTransform, bool32 dontClearSubstituteBit, bool32 doSlideIn); -void Controller_WaitForString(u32 battler); -void Controller_WaitForHealthBar(u32 battler); +void BtlController_Complete(enum BattlerId battler); // Can be used for all the controllers. +void BtlController_Empty(enum BattlerId battler); // Empty command, does nothing, only completes the execution. +void BtlController_TerminatorNop(enum BattlerId battler); // Dummy function at the end of the table. +void BattleControllerDummy(enum BattlerId battler); +void StartSendOutAnim(enum BattlerId battler, bool32 dontClearTransform, bool32 dontClearSubstituteBit, bool32 doSlideIn); +void Controller_WaitForString(enum BattlerId battler); +void Controller_WaitForHealthBar(enum BattlerId battler); // handlers -void BtlController_HandleGetMonData(u32 battler); -void BtlController_HandleGetRawMonData(u32 battler); -void BtlController_HandleSetMonData(u32 battler); -void BtlController_HandleSetRawMonData(u32 battler); -void BtlController_HandleLoadMonSprite(u32 battler); -void BtlController_HandleSwitchInAnim(u32 battler); -void BtlController_HandleReturnMonToBall(u32 battler); -void BtlController_HandleDrawTrainerPic(u32 battlerId, enum TrainerPicID trainerPicId, bool32 isFrontPic, s16 xPos, s16 yPos, s32 subpriority); -void BtlController_HandleTrainerSlide(u32 battler, enum TrainerPicID trainerPicId); -void BtlController_HandleTrainerSlideBack(u32 battlerId, s16 data0, bool32 startAnim); -void BtlController_HandleFaintAnimation(u32 battler); -void BtlController_HandleBallThrowAnim(u32 battler); -void BtlController_HandleMoveAnimation(u32 battler); -void BtlController_HandlePrintString(u32 battler); -void BtlController_HandlePrintStringPlayerOnly(u32 battler); -void BtlController_HandleHealthBarUpdate(u32 battler); -void BtlController_HandleStatusIconUpdate(u32 battler); -void BtlController_HandleStatusAnimation(u32 battler); -void BtlController_HandleHitAnimation(u32 battler); -void BtlController_HandlePlaySE(u32 battler); -void BtlController_HandlePlayFanfareOrBGM(u32 battler); -void BtlController_HandleFaintingCry(u32 battler); -void BtlController_HandleIntroSlide(u32 battler); -void BtlController_HandleSpriteInvisibility(u32 battler); -bool32 TwoPlayerIntroMons(u32 battlerId); // Double battle with both player pokemon active. -bool32 TwoOpponentIntroMons(u32 battlerId); // Double battle with both opponent pokemon active. -void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u16 *trainerPal, s16 framesToWait, void (*controllerCallback)(u32 battler)); -void BtlController_HandleDrawPartyStatusSummary(u32 battler, enum BattleSide side, bool32 considerDelay); -void BtlController_HandleHidePartyStatusSummary(u32 battler); -void BtlController_HandleBattleAnimation(u32 battler); +void BtlController_HandleGetMonData(enum BattlerId battler); +void BtlController_HandleGetRawMonData(enum BattlerId battler); +void BtlController_HandleSetMonData(enum BattlerId battler); +void BtlController_HandleSetRawMonData(enum BattlerId battler); +void BtlController_HandleLoadMonSprite(enum BattlerId battler); +void BtlController_HandleSwitchInAnim(enum BattlerId battler); +void BtlController_HandleReturnMonToBall(enum BattlerId battler); +void BtlController_HandleDrawTrainerPic(enum BattlerId battlerId, enum TrainerPicID trainerPicId, bool32 isFrontPic, s16 xPos, s16 yPos, s32 subpriority); +void BtlController_HandleTrainerSlide(enum BattlerId battler, enum TrainerPicID trainerPicId); +void BtlController_HandleTrainerSlideBack(enum BattlerId battlerId, s16 data0, bool32 startAnim); +void BtlController_HandleFaintAnimation(enum BattlerId battler); +void BtlController_HandleBallThrowAnim(enum BattlerId battler); +void BtlController_HandleMoveAnimation(enum BattlerId battler); +void BtlController_HandlePrintString(enum BattlerId battler); +void BtlController_HandlePrintStringPlayerOnly(enum BattlerId battler); +void BtlController_HandleHealthBarUpdate(enum BattlerId battler); +void BtlController_HandleStatusIconUpdate(enum BattlerId battler); +void BtlController_HandleStatusAnimation(enum BattlerId battler); +void BtlController_HandleHitAnimation(enum BattlerId battler); +void BtlController_HandlePlaySE(enum BattlerId battler); +void BtlController_HandlePlayFanfareOrBGM(enum BattlerId battler); +void BtlController_HandleFaintingCry(enum BattlerId battler); +void BtlController_HandleIntroSlide(enum BattlerId battler); +void BtlController_HandleSpriteInvisibility(enum BattlerId battler); +bool32 TwoPlayerIntroMons(enum BattlerId battlerId); // Double battle with both player pokemon active. +bool32 TwoOpponentIntroMons(enum BattlerId battlerId); // Double battle with both opponent pokemon active. +void BtlController_HandleIntroTrainerBallThrow(enum BattlerId battler, u16 tagTrainerPal, const u16 *trainerPal, s16 framesToWait, void (*controllerCallback)(enum BattlerId battler)); +void BtlController_HandleDrawPartyStatusSummary(enum BattlerId battler, enum BattleSide side, bool32 considerDelay); +void BtlController_HandleHidePartyStatusSummary(enum BattlerId battler); +void BtlController_HandleBattleAnimation(enum BattlerId battler); // player controller -void SetControllerToPlayer(u32 battler); -void PlayerBufferExecCompleted(u32 battler); -void SetBattleEndCallbacks(u32 battler); -void PlayerHandleExpUpdate(u32 battler); +void SetControllerToPlayer(enum BattlerId battler); +void PlayerBufferExecCompleted(enum BattlerId battler); +void SetBattleEndCallbacks(enum BattlerId battler); +void PlayerHandleExpUpdate(enum BattlerId battler); enum TrainerPicID LinkPlayerGetTrainerPicId(u32 multiplayerId); void CB2_SetUpReshowBattleScreenAfterMenu(void); void CB2_SetUpReshowBattleScreenAfterMenu2(void); void Task_PlayerController_RestoreBgmAfterCry(u8 taskId); void ActionSelectionCreateCursorAt(u8 cursorPosition, u8 baseTileNum); void ActionSelectionDestroyCursorAt(u8 cursorPosition); -void InitMoveSelectionsVarsAndStrings(u32 battler); +void InitMoveSelectionsVarsAndStrings(enum BattlerId battler); void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1); void MoveSelectionDestroyCursorAt(u8 cursorPosition); -void PlayerHandleChooseMove(u32 battler); -void HandleInputChooseMove(u32 battler); -void HandleInputChooseTarget(u32 battler); -void HandleInputShowEntireFieldTargets(u32 battler); -void HandleInputShowTargets(u32 battler); -void HandleMoveSwitching(u32 battler); -void HandleChooseMoveAfterDma3(u32 battler); +void PlayerHandleChooseMove(enum BattlerId battler); +void HandleInputChooseMove(enum BattlerId battler); +void HandleInputChooseTarget(enum BattlerId battler); +void HandleInputShowEntireFieldTargets(enum BattlerId battler); +void HandleInputShowTargets(enum BattlerId battler); +void HandleMoveSwitching(enum BattlerId battler); +void HandleChooseMoveAfterDma3(enum BattlerId battler); // recorded player controller -void SetControllerToRecordedPlayer(u32 battler); -void RecordedPlayerBufferExecCompleted(u32 battler); +void SetControllerToRecordedPlayer(enum BattlerId battler); +void RecordedPlayerBufferExecCompleted(enum BattlerId battler); // recorded partner controller -void SetControllerToRecordedPartner(u32 battler); -void RecordedPartnerBufferExecCompleted(u32 battler); +void SetControllerToRecordedPartner(enum BattlerId battler); +void RecordedPartnerBufferExecCompleted(enum BattlerId battler); // opponent controller -void SetControllerToOpponent(u32 battler); -void OpponentBufferExecCompleted(u32 battler); -void OpponentHandleTrainerSlide(u32 battler); +void SetControllerToOpponent(enum BattlerId battler); +void OpponentBufferExecCompleted(enum BattlerId battler); +void OpponentHandleTrainerSlide(enum BattlerId battler); // player partner controller -void Controller_PlayerPartnerShowIntroHealthbox(u32 battler); // Also used by the link partner. -void SetControllerToPlayerPartner(u32 battler); -void PlayerPartnerBufferExecCompleted(u32 battler); +void Controller_PlayerPartnerShowIntroHealthbox(enum BattlerId battler); // Also used by the link partner. +void SetControllerToPlayerPartner(enum BattlerId battler); +void PlayerPartnerBufferExecCompleted(enum BattlerId battler); // safari controller -void SetControllerToSafari(u32 battler); -void SafariBufferExecCompleted(u32 battler); +void SetControllerToSafari(enum BattlerId battler); +void SafariBufferExecCompleted(enum BattlerId battler); // wally controller -void SetControllerToWally(u32 battler); -void WallyBufferExecCompleted(u32 battler); +void SetControllerToWally(enum BattlerId battler); +void WallyBufferExecCompleted(enum BattlerId battler); // recorded opponent controller -void SetControllerToRecordedOpponent(u32 battler); -void RecordedOpponentBufferExecCompleted(u32 battler); +void SetControllerToRecordedOpponent(enum BattlerId battler); +void RecordedOpponentBufferExecCompleted(enum BattlerId battler); // link opponent -void SetControllerToLinkOpponent(u32 battler); -void LinkOpponentBufferExecCompleted(u32 battler); +void SetControllerToLinkOpponent(enum BattlerId battler); +void LinkOpponentBufferExecCompleted(enum BattlerId battler); // link partner -void SetControllerToLinkPartner(u32 battler); -void LinkPartnerBufferExecCompleted(u32 battler); +void SetControllerToLinkPartner(enum BattlerId battler); +void LinkPartnerBufferExecCompleted(enum BattlerId battler); -void TrySetBattlerShadowSpriteCallback(u32 battler); +void TrySetBattlerShadowSpriteCallback(enum BattlerId battler); -void AnimateMonAfterPokeBallFail(u32 battler); -void TryShinyAnimAfterMonAnim(u32 battler); -void WaitForMonAnimAfterLoad(u32 battler); -void BtlController_HandleSwitchInWaitAndEnd(u32 battler); -void BtlController_Intro_DelayAndEnd(u32 battler); -void BtlController_HandleSwitchInShowHealthbox(u32 battler); -void BtlController_HandleSwitchInTryShinyAnim(u32 battler); -void BtlController_HandleSwitchInSoundAndEnd(u32 battler); -void BtlController_HandleSwitchInShowSubstitute(u32 battler); +void AnimateMonAfterPokeBallFail(enum BattlerId battler); +void TryShinyAnimAfterMonAnim(enum BattlerId battler); +void WaitForMonAnimAfterLoad(enum BattlerId battler); +void BtlController_HandleSwitchInWaitAndEnd(enum BattlerId battler); +void BtlController_Intro_DelayAndEnd(enum BattlerId battler); +void BtlController_HandleSwitchInShowHealthbox(enum BattlerId battler); +void BtlController_HandleSwitchInTryShinyAnim(enum BattlerId battler); +void BtlController_HandleSwitchInSoundAndEnd(enum BattlerId battler); +void BtlController_HandleSwitchInShowSubstitute(enum BattlerId battler); -bool32 ShouldBattleRestrictionsApply(u32 battler); +bool32 ShouldBattleRestrictionsApply(enum BattlerId battler); void FreeShinyStars(void); enum BattleTrainer GetBattlerTrainer(enum BattlerId battler); diff --git a/include/battle_dynamax.h b/include/battle_dynamax.h index 516d7db217..8ba4a99d67 100644 --- a/include/battle_dynamax.h +++ b/include/battle_dynamax.h @@ -3,16 +3,16 @@ #define DYNAMAX_TURNS_COUNT 3 -bool32 CanDynamax(u32 battler); -bool32 IsGigantamaxed(u32 battler); +bool32 CanDynamax(enum BattlerId battler); +bool32 IsGigantamaxed(enum BattlerId battler); void ApplyDynamaxHPMultiplier(struct Pokemon *mon); -void ActivateDynamax(u32 battler); -u32 GetNonDynamaxHP(u32 battler); -u32 GetNonDynamaxMaxHP(u32 battler); -void UndoDynamax(u32 battler); +void ActivateDynamax(enum BattlerId battler); +u32 GetNonDynamaxHP(enum BattlerId battler); +u32 GetNonDynamaxMaxHP(enum BattlerId battler); +void UndoDynamax(enum BattlerId battler); bool32 IsMoveBlockedByMaxGuard(enum Move move); -enum Move GetMaxMove(u32 battler, enum Move baseMove); +enum Move GetMaxMove(enum BattlerId battler, enum Move baseMove); u32 GetMaxMovePower(enum Move move); bool32 IsMaxMove(enum Move move); void ChooseDamageNonTypesString(enum Type type); diff --git a/include/battle_gfx_sfx_util.h b/include/battle_gfx_sfx_util.h index fc01638de6..9e92e8c211 100644 --- a/include/battle_gfx_sfx_util.h +++ b/include/battle_gfx_sfx_util.h @@ -3,42 +3,42 @@ void AllocateBattleSpritesData(void); void FreeBattleSpritesData(void); -u16 ChooseMoveAndTargetInBattlePalace(u32 battler); +u16 ChooseMoveAndTargetInBattlePalace(enum BattlerId battler); void SpriteCB_WaitForBattlerBallReleaseAnim(struct Sprite *sprite); void SpriteCB_TrainerSlideIn(struct Sprite *sprite); void SpriteCB_TrainerSpawn(struct Sprite *sprite); -void InitAndLaunchChosenStatusAnimation(u32 battler, bool32 isVolatile, u32 status); +void InitAndLaunchChosenStatusAnimation(enum BattlerId battler, bool32 isVolatile, u32 status); bool8 TryHandleLaunchBattleTableAnimation(u8 activeBattlerId, u8 attacker, u8 target, u8 tableId, u16 argument); -void InitAndLaunchSpecialAnimation(u8 activeBattlerId, u8 attacker, u8 target, u8 tableId); -bool8 IsBattleSEPlaying(u8 battler); -void BattleLoadMonSpriteGfx(struct Pokemon *mon, u32 battler); +void InitAndLaunchSpecialAnimation(enum BattlerId activeBattlerId, enum BattlerId attacker, enum BattlerId target, u8 tableId); +bool8 IsBattleSEPlaying(enum BattlerId battler); +void BattleLoadMonSpriteGfx(struct Pokemon *mon, enum BattlerId battler); void BattleGfxSfxDummy2(u16 species); -void DecompressTrainerFrontPic(u16 frontPicId, u8 battler); -void DecompressTrainerBackPic(enum TrainerPicID backPicId, u8 battler); +void DecompressTrainerFrontPic(u16 frontPicId, enum BattlerId battler); +void DecompressTrainerBackPic(enum TrainerPicID backPicId, enum BattlerId battler); void FreeTrainerFrontPicPalette(u16 frontPicId); bool8 BattleLoadAllHealthBoxesGfx(u8 state); void LoadBattleBarGfx(u8 unused); bool8 BattleInitAllSprites(u8 *state1, u8 *battler); void ClearSpritesHealthboxAnimData(void); void CopyAllBattleSpritesInvisibilities(void); -void CopyBattleSpriteInvisibility(u8 battler); -void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, u8 changeType); -void BattleLoadSubstituteOrMonSpriteGfx(u8 battler, bool8 loadMonSprite); -void LoadBattleMonGfxAndAnimate(u8 battler, bool8 loadMonSprite, u8 spriteId); -void TrySetBehindSubstituteSpriteBit(u8 battler, enum Move move); -void ClearBehindSubstituteBit(u8 battler); -void HandleLowHpMusicChange(struct Pokemon *mon, u8 battler); +void CopyBattleSpriteInvisibility(enum BattlerId battler); +void HandleSpeciesGfxDataChange(enum BattlerId battlerAtk, enum BattlerId battlerDef, u8 changeType); +void BattleLoadSubstituteOrMonSpriteGfx(enum BattlerId battler, bool8 loadMonSprite); +void LoadBattleMonGfxAndAnimate(enum BattlerId battler, bool8 loadMonSprite, u8 spriteId); +void TrySetBehindSubstituteSpriteBit(enum BattlerId battler, enum Move move); +void ClearBehindSubstituteBit(enum BattlerId battler); +void HandleLowHpMusicChange(struct Pokemon *mon, enum BattlerId battler); void BattleStopLowHpSound(void); u8 GetMonHPBarLevel(struct Pokemon *mon); void HandleBattleLowHpMusicChange(void); void SetBattlerSpriteAffineMode(u8 affineMode); -void CreateEnemyShadowSprite(u32 battler); +void CreateEnemyShadowSprite(enum BattlerId battler); void LoadAndCreateEnemyShadowSprites(void); void SpriteCB_SetInvisible(struct Sprite *sprite); -void SetBattlerShadowSpriteCallback(u8 battler, u16 species); -void HideBattlerShadowSprite(u8 battler); +void SetBattlerShadowSpriteCallback(enum BattlerId battler, u16 species); +void HideBattlerShadowSprite(enum BattlerId battler); void FillAroundBattleWindows(void); -void ClearTemporarySpeciesSpriteData(u32 battler, bool32 dontClearTransform, bool32 dontClearSubstitute); +void ClearTemporarySpeciesSpriteData(enum BattlerId battler, bool32 dontClearTransform, bool32 dontClearSubstitute); void AllocateMonSpritesGfx(void); void FreeMonSpritesGfx(void); bool32 ShouldPlayNormalMonCry(struct Pokemon *mon); diff --git a/include/battle_gimmick.h b/include/battle_gimmick.h index 84b1d6b26a..6322df2bdf 100644 --- a/include/battle_gimmick.h +++ b/include/battle_gimmick.h @@ -19,32 +19,32 @@ struct GimmickInfo const struct SpriteTemplate *triggerTemplate; const u32 indicatorPalTag; const u8 *indicatorData; - bool32 (*CanActivate)(u32 battler); - void (*ActivateGimmick)(u32 battler); + bool32 (*CanActivate)(enum BattlerId battler); + void (*ActivateGimmick)(enum BattlerId battler); }; void AssignUsableGimmicks(void); -bool32 CanActivateGimmick(u32 battler, enum Gimmick gimmick); -bool32 IsGimmickSelected(u32 battler, enum Gimmick gimmick); -void SetActiveGimmick(u32 battler, enum Gimmick gimmick); -enum Gimmick GetActiveGimmick(u32 battler); -bool32 ShouldTrainerBattlerUseGimmick(u32 battler, enum Gimmick gimmick); -bool32 HasTrainerUsedGimmick(u32 battler, enum Gimmick gimmick); -void SetGimmickAsActivated(u32 battler, enum Gimmick gimmick); +bool32 CanActivateGimmick(enum BattlerId battler, enum Gimmick gimmick); +bool32 IsGimmickSelected(enum BattlerId battler, enum Gimmick gimmick); +void SetActiveGimmick(enum BattlerId battler, enum Gimmick gimmick); +enum Gimmick GetActiveGimmick(enum BattlerId battler); +bool32 ShouldTrainerBattlerUseGimmick(enum BattlerId battler, enum Gimmick gimmick); +bool32 HasTrainerUsedGimmick(enum BattlerId battler, enum Gimmick gimmick); +void SetGimmickAsActivated(enum BattlerId battler, enum Gimmick gimmick); void ChangeGimmickTriggerSprite(u32 spriteId, u32 animId); -void CreateGimmickTriggerSprite(u32 battler); +void CreateGimmickTriggerSprite(enum BattlerId battler); bool32 IsGimmickTriggerSpriteActive(void); -bool32 IsGimmickTriggerSpriteMatchingBattler(u32 battler); +bool32 IsGimmickTriggerSpriteMatchingBattler(enum BattlerId battler); void HideGimmickTriggerSprite(void); void DestroyGimmickTriggerSprite(void); void LoadIndicatorSpritesGfx(void); -u32 GetIndicatorPalTag(u32 battler); +u32 GetIndicatorPalTag(enum BattlerId battler); void UpdateIndicatorVisibilityAndType(u32 healthboxId, bool32 invisible); void UpdateIndicatorOamPriority(u32 healthboxId, u32 oamPriority); void UpdateIndicatorLevelData(u32 healthboxId, u32 level); -void CreateIndicatorSprite(u32 battler); +void CreateIndicatorSprite(enum BattlerId battler); extern const struct GimmickInfo gGimmicksInfo[]; diff --git a/include/battle_hold_effects.h b/include/battle_hold_effects.h index 17c0cb5f48..70559d6887 100644 --- a/include/battle_hold_effects.h +++ b/include/battle_hold_effects.h @@ -25,7 +25,7 @@ struct HoldEffectInfo extern const struct HoldEffectInfo gHoldEffectsInfo[]; typedef bool32 (*ActivationTiming)(enum HoldEffect holdEffect); -enum ItemEffect ItemBattleEffects(u32 primaryBattler, u32 secondaryBattler, enum HoldEffect holdEffect, ActivationTiming timing); +enum ItemEffect ItemBattleEffects(enum BattlerId itemBattler, enum BattlerId battler, enum HoldEffect holdEffect, ActivationTiming timing); bool32 IsOnSwitchInActivation(enum HoldEffect holdEffect); bool32 IsMirrorHerbActivation(enum HoldEffect holdEffect); diff --git a/include/battle_interface.h b/include/battle_interface.h index ea5559d165..a1599a15dd 100644 --- a/include/battle_interface.h +++ b/include/battle_interface.h @@ -108,33 +108,33 @@ enum HEALTHBOX_SAFARI_BALLS_TEXT }; -enum BattleCoordTypes GetBattlerCoordsIndex(u32 battler); -u8 CreateBattlerHealthboxSprites(u8 battler); +enum BattleCoordTypes GetBattlerCoordsIndex(enum BattlerId battler); +u8 CreateBattlerHealthboxSprites(enum BattlerId battler); u8 CreateSafariPlayerHealthboxSprites(void); -void SetBattleBarStruct(u8 battler, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue); +void SetBattleBarStruct(enum BattlerId battler, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue); void SetHealthboxSpriteInvisible(u8 healthboxSpriteId); void SetHealthboxSpriteVisible(u8 healthboxSpriteId); void DummyBattleInterfaceFunc(u8 healthboxSpriteId, bool8 isDoubleBattleBattlerOnly); void UpdateOamPriorityInAllHealthboxes(u8 priority, bool32 hideHpBoxes); -void InitBattlerHealthboxCoords(u8 battler); -void GetBattlerHealthboxCoords(u8 battler, s16 *x, s16 *y); +void InitBattlerHealthboxCoords(enum BattlerId battler); +void GetBattlerHealthboxCoords(enum BattlerId battler, s16 *x, s16 *y); void UpdateHpTextInHealthbox(u32 healthboxSpriteId, u32 maxOrCurrent, s16 currHp, s16 maxHp); void SwapHpBarsWithHpText(void); -u8 CreatePartyStatusSummarySprites(u8 battler, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart); +u8 CreatePartyStatusSummarySprites(enum BattlerId battler, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart); void Task_HidePartyStatusSummary(u8 taskId); void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elementId); -s32 MoveBattleBar(u8 battler, u8 healthboxSpriteId, u8 whichBar, u8 unused); +s32 MoveBattleBar(enum BattlerId battler, u8 healthboxSpriteId, u8 whichBar, u8 unused); u8 GetScaledHPFraction(s16 hp, s16 maxhp, u8 scale); u8 GetHPBarLevel(s16 hp, s16 maxhp); -void CreateAbilityPopUp(u8 battlerId, enum Ability ability, bool32 isDoubleBattle); -void DestroyAbilityPopUp(u8 battlerId); +void CreateAbilityPopUp(enum BattlerId battlerId, enum Ability ability, bool32 isDoubleBattle); +void DestroyAbilityPopUp(enum BattlerId battlerId); bool32 CanThrowLastUsedBall(void); void TryHideLastUsedBall(void); void TryRestoreLastUsedBall(void); void TryAddLastUsedBallItemSprites(void); void SwapBallToDisplay(bool32 sameBall); void ArrowsChangeColorLastBallCycle(bool32 showArrows); -void UpdateAbilityPopup(u8 battlerId); +void UpdateAbilityPopup(enum BattlerId battlerId); void CategoryIcons_LoadSpritesGfx(void); void TryToAddMoveInfoWindow(void); void TryToHideMoveInfoWindow(void); diff --git a/include/battle_main.h b/include/battle_main.h index e3dfca98f0..a63e653392 100644 --- a/include/battle_main.h +++ b/include/battle_main.h @@ -81,31 +81,31 @@ void SpriteCB_HideAsMoveTarget(struct Sprite *sprite); void SpriteCB_OpponentMonFromBall(struct Sprite *sprite); void SpriteCB_BattleSpriteStartSlideLeft(struct Sprite *sprite); void SpriteCB_FaintSlideAnim(struct Sprite *sprite); -void DoBounceEffect(u8 battler, u8 which, s8 delta, s8 amplitude); -void EndBounceEffect(u8 battler, u8 which); +void DoBounceEffect(enum BattlerId battler, u8 which, s8 delta, s8 amplitude); +void EndBounceEffect(enum BattlerId battler, u8 which); void SpriteCB_PlayerMonFromBall(struct Sprite *sprite); void SpriteCB_PlayerMonSlideIn(struct Sprite *sprite); void SpriteCB_TrainerThrowObject(struct Sprite *sprite); void AnimSetCenterToCornerVecX(struct Sprite *sprite); void BeginBattleIntroDummy(void); void BeginBattleIntro(void); -void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy); -const u8 *FaintClearSetData(u32 battler); +void SwitchInClearSetData(enum BattlerId battler, struct Volatiles *volatilesCopy); +const u8 *FaintClearSetData(enum BattlerId battler); void BattleTurnPassed(void); -u8 IsRunningFromBattleImpossible(u32 battler); -void SwitchTwoBattlersInParty(u32 battler, u32 battler2); -void SwitchPartyOrder(u32 battler); +u8 IsRunningFromBattleImpossible(enum BattlerId battler); +void SwitchTwoBattlersInParty(enum BattlerId battler, enum BattlerId battler2); +void SwitchPartyOrder(enum BattlerId battler); void SwapTurnOrder(u8 id1, u8 id2); -u32 GetBattlerTotalSpeedStat(u32 battler, enum Ability ability, enum HoldEffect holdEffect); -s32 GetChosenMovePriority(u32 battler, enum Ability ability); -s32 GetBattleMovePriority(u32 battler, enum Ability ability, enum Move move); +u32 GetBattlerTotalSpeedStat(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect); +s32 GetChosenMovePriority(enum BattlerId battler, enum Ability ability); +s32 GetBattleMovePriority(enum BattlerId battler, enum Ability ability, enum Move move); s32 GetWhichBattlerFasterArgs(struct BattleCalcValues *calcValues, bool32 ignoreChosenMoves, u32 speedBattler1, u32 speedBattler2, s32 priority1, s32 priority2); s32 GetWhichBattlerFasterOrTies(struct BattleCalcValues *calcValues, bool32 ignoreChosenMoves); s32 GetWhichBattlerFaster(struct BattleCalcValues *calcValues, bool32 ignoreChosenMoves); void RunBattleScriptCommands_PopCallbacksStack(void); void RunBattleScriptCommands(void); -enum Type GetDynamicMoveType(struct Pokemon *mon, enum Move move, u32 battler, enum MonState monInBattle); -void SetTypeBeforeUsingMove(enum Move move, u32 battlerAtk); +enum Type GetDynamicMoveType(struct Pokemon *mon, enum Move move, enum BattlerId battler, enum MonState monInBattle); +void SetTypeBeforeUsingMove(enum Move move, enum BattlerId battler); bool32 IsWildMonSmart(void); u8 CreateNPCTrainerPartyFromTrainer(struct Pokemon *party, const struct Trainer *trainer, bool32 firstTrainer, u32 battleTypeFlags); void ModifyPersonalityForNature(u32 *personality, u32 newNature); diff --git a/include/battle_message.h b/include/battle_message.h index 9809589243..c7e4923a4b 100644 --- a/include/battle_message.h +++ b/include/battle_message.h @@ -249,11 +249,11 @@ struct BattleMsgData u8 textBuffs[3][TEXT_BUFF_ARRAY_COUNT]; }; -void BufferStringBattle(enum StringID stringID, u32 battler); +void BufferStringBattle(enum StringID stringID, enum BattlerId battler); u32 BattleStringExpandPlaceholdersToDisplayedString(const u8 *src); u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst, u32 dstSize); void BattlePutTextOnWindow(const u8 *text, u8 windowId); -void SetPpNumbersPaletteInMoveSelection(u32 battler); +void SetPpNumbersPaletteInMoveSelection(enum BattlerId battler); u8 GetCurrentPpToMaxPpState(u8 currentPp, u8 maxPp); void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst); diff --git a/include/battle_script_commands.h b/include/battle_script_commands.h index a17b213671..b3a4882b17 100644 --- a/include/battle_script_commands.h +++ b/include/battle_script_commands.h @@ -40,33 +40,33 @@ union TRANSPARENT StatChangeFlags }; }; -bool32 HasBattlerActedThisTurn(u32 battler); -u32 GetBattlerTurnOrderNum(u32 battler); -bool32 NoAliveMonsForBattlerSide(u32 battler); +bool32 HasBattlerActedThisTurn(enum BattlerId battler); +u32 GetBattlerTurnOrderNum(enum BattlerId battler); +bool32 NoAliveMonsForBattlerSide(enum BattlerId battler); bool32 NoAliveMonsForPlayer(void); bool32 NoAliveMonsForEitherParty(void); -void SetMoveEffect(u32 battler, u32 effectBattler, enum MoveEffect moveEffect, const u8 *battleScript, enum SetMoveEffectFlags effectFlags); -bool32 CanBattlerSwitch(u32 battlerId); +void SetMoveEffect(enum BattlerId battlerAtk, enum BattlerId effectBattler, enum MoveEffect moveEffect, const u8 *battleScript, enum SetMoveEffectFlags effectFlags); +bool32 CanBattlerSwitch(enum BattlerId battlerId); void BattleDestroyYesNoCursorAt(u8 cursorPosition); void BattleCreateYesNoCursorAt(u8 cursorPosition); void BufferMoveToLearnIntoBattleTextBuff2(void); void HandleBattleWindow(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags); -bool8 UproarWakeUpCheck(u8 battler); -bool32 DoesSubstituteBlockMove(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 DoesDisguiseBlockMove(u32 battler, enum Move move); -bool32 CanUseLastResort(u8 battlerId); -u32 IsFlowerVeilProtected(u32 battler); -u32 IsLeafGuardProtected(u32 battler, enum Ability ability); -bool32 IsShieldsDownProtected(u32 battler, enum Ability ability); -u32 IsAbilityStatusProtected(u32 battler, enum Ability ability); -bool32 TryResetBattlerStatChanges(u8 battler); -bool32 CanCamouflage(u8 battlerId); -void StealTargetItem(u8 battlerStealer, u8 battlerItem); +bool8 UproarWakeUpCheck(enum BattlerId battler); +bool32 DoesSubstituteBlockMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 DoesDisguiseBlockMove(enum BattlerId battler, enum Move move); +bool32 CanUseLastResort(enum BattlerId battlerId); +u32 IsFlowerVeilProtected(enum BattlerId battler); +u32 IsLeafGuardProtected(enum BattlerId battler, enum Ability ability); +bool32 IsShieldsDownProtected(enum BattlerId battler, enum Ability ability); +u32 IsAbilityStatusProtected(enum BattlerId battler, enum Ability ability); +bool32 TryResetBattlerStatChanges(enum BattlerId battler); +bool32 CanCamouflage(enum BattlerId battler); +void StealTargetItem(enum BattlerId battlerStealer, enum BattlerId battlerItem); u8 GetCatchingBattler(void); -bool32 ProteanTryChangeType(u32 battler, enum Ability ability, enum Move move, enum Type moveType); -u8 GetFirstFaintedPartyIndex(u8 battlerId); -void SaveBattlerTarget(u32 battler); -void SaveBattlerAttacker(u32 battler); +bool32 ProteanTryChangeType(enum BattlerId battler, enum Ability ability, enum Move move, enum Type moveType); +u8 GetFirstFaintedPartyIndex(enum BattlerId battler); +void SaveBattlerTarget(enum BattlerId battler); +void SaveBattlerAttacker(enum BattlerId battler); bool32 CanBurnHitThaw(enum Move move); extern void (*const gBattleScriptingCommandsTable[])(void); diff --git a/include/battle_terastal.h b/include/battle_terastal.h index 8237591690..3320eddd54 100644 --- a/include/battle_terastal.h +++ b/include/battle_terastal.h @@ -1,12 +1,12 @@ #ifndef GUARD_BATTLE_TERASTAL_H #define GUARD_BATTLE_TERASTAL_H -void ActivateTera(u32 battler); -void ApplyBattlerVisualsForTeraAnim(u32 battler); -bool32 CanTerastallize(u32 battler); -enum Type GetBattlerTeraType(u32 battler); -void ExpendTypeStellarBoost(u32 battler, enum Type type); -bool32 IsTypeStellarBoosted(u32 battler, enum Type type); +void ActivateTera(enum BattlerId battler); +void ApplyBattlerVisualsForTeraAnim(enum BattlerId battler); +bool32 CanTerastallize(enum BattlerId battler); +enum Type GetBattlerTeraType(enum BattlerId battler); +void ExpendTypeStellarBoost(enum BattlerId battler, enum Type type); +bool32 IsTypeStellarBoosted(enum BattlerId battler, enum Type type); uq4_12_t GetTeraMultiplier(struct BattleContext *ctx); u16 GetTeraTypeRGB(enum Type type); diff --git a/include/battle_tv.h b/include/battle_tv.h index cda259b8a5..1384ce1c18 100644 --- a/include/battle_tv.h +++ b/include/battle_tv.h @@ -6,6 +6,6 @@ void BattleTv_SetDataBasedOnMove(enum Move move, u16 weatherFlags); void BattleTv_SetDataBasedOnAnimation(u8 animationId); void TryPutLinkBattleTvShowOnAir(void); void BattleTv_ClearExplosionFaintCause(void); -u8 GetBattlerMoveSlotId(u8 battler, enum Move move); +u8 GetBattlerMoveSlotId(enum BattlerId battler, enum Move move); #endif // GUARD_BATTLE_TV_H diff --git a/include/battle_util.h b/include/battle_util.h index 267fadfbe5..cedd3ede0e 100644 --- a/include/battle_util.h +++ b/include/battle_util.h @@ -104,8 +104,8 @@ extern const struct TypePower gNaturalGiftTable[]; struct BattleContext { - u32 battlerAtk:3; - u32 battlerDef:3; + enum BattlerId battlerAtk:3; + enum BattlerId battlerDef:3; u32 fixedBasePower:8; u32 weather:16; u32 unused:2; @@ -138,8 +138,8 @@ struct BattleContext // Helper struct to keep the arg list small and prevent constant recalculations of abilities/hold effects. struct BattleCalcValues { - u32 battlerAtk:3; - u32 battlerDef:3; + enum BattlerId battlerAtk:3; + enum BattlerId battlerDef:3; enum Move move:16; u32 padding:10; enum Ability abilities[MAX_BATTLERS_COUNT]; @@ -173,17 +173,17 @@ enum EjectPackTiming }; void HandleAction_ThrowBall(void); -uq4_12_t CalcTypeEffectivenessMultiplierHelper(enum Move move, enum Type moveType, u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, bool32 recordAbilities); +uq4_12_t CalcTypeEffectivenessMultiplierHelper(enum Move move, enum Type moveType, enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, bool32 recordAbilities); u32 GetCurrentBattleWeather(void); bool32 EndOrContinueWeather(void); -enum DamageCategory GetReflectDamageMoveDamageCategory(u32 battler, enum Move move); -bool32 IsUnnerveBlocked(u32 battler, enum Item itemId); -bool32 IsAffectedByFollowMe(u32 battlerAtk, enum BattleSide defSide, enum Move move); +enum DamageCategory GetReflectDamageMoveDamageCategory(enum BattlerId battler, enum Move move); +bool32 IsUnnerveBlocked(enum BattlerId battler, enum Item itemId); +bool32 IsAffectedByFollowMe(enum BattlerId battlerAtk, enum BattleSide defSide, enum Move move); void DetermineTarget(enum MoveTarget moveTarget, bool32 overwriteTarget); void HandleAction_UseMove(void); void HandleAction_Switch(void); void HandleAction_UseItem(void); -bool32 TryRunFromBattle(u32 battler); +bool32 TryRunFromBattle(enum BattlerId battler); void HandleAction_Run(void); void HandleAction_WatchesCarefully(void); void HandleAction_SafariZoneBallThrow(void); @@ -194,71 +194,71 @@ void HandleAction_WallyBallThrow(void); void HandleAction_TryFinish(void); void HandleAction_NothingIsFainted(void); void HandleAction_ActionFinished(void); -u8 GetBattlerForBattleScript(u8 caseId); -bool32 IsBattlerMarkedForControllerExec(u32 battler); -void MarkBattlerForControllerExec(u32 battler); -void MarkBattlerReceivedLinkData(u32 battler); -const u8 *CancelMultiTurnMoves(u32 battler, enum SkyDropState skyDropState); -bool32 IsLastMonToMove(u32 battler); -bool32 ShouldDefiantCompetitiveActivate(u32 battler, enum Ability ability); -void PrepareStringBattle(enum StringID stringId, u32 battler); +enum BattlerId GetBattlerForBattleScript(u8 caseId); +bool32 IsBattlerMarkedForControllerExec(enum BattlerId battler); +void MarkBattlerForControllerExec(enum BattlerId battler); +void MarkBattlerReceivedLinkData(enum BattlerId battler); +const u8 *CancelMultiTurnMoves(enum BattlerId battler, enum SkyDropState skyDropState); +bool32 IsLastMonToMove(enum BattlerId battler); +bool32 ShouldDefiantCompetitiveActivate(enum BattlerId battler, enum Ability ability); +void PrepareStringBattle(enum StringID stringId, enum BattlerId battler); void ResetSentPokesToOpponentValue(void); -void OpponentSwitchInResetSentPokesToOpponentValue(u32 battler); -void UpdateSentPokesToOpponentValue(u32 battler); +void OpponentSwitchInResetSentPokesToOpponentValue(enum BattlerId battler); +void UpdateSentPokesToOpponentValue(enum BattlerId battler); void BattleScriptPush(const u8 *bsPtr); void BattleScriptPushCursor(void); void BattleScriptCall(const u8 *bsPtr); void BattleScriptPop(void); -u32 TrySetCantSelectMoveBattleScript(u32 battler); -u32 CheckMoveLimitations(u32 battler, u8 unusableMoves, u16 check); -bool32 AreAllMovesUnusable(u32 battler); -u8 GetImprisonedMovesCount(u32 battler, enum Move move); -s32 GetDrainedBigRootHp(u32 battler, s32 hp); -bool32 IsAbilityAndRecord(u32 battler, enum Ability battlerAbility, enum Ability abilityToCheck); +u32 TrySetCantSelectMoveBattleScript(enum BattlerId battler); +u32 CheckMoveLimitations(enum BattlerId battler, u8 unusableMoves, u16 check); +bool32 AreAllMovesUnusable(enum BattlerId battler); +u8 GetImprisonedMovesCount(enum BattlerId battler, enum Move move); +s32 GetDrainedBigRootHp(enum BattlerId battler, s32 hp); +bool32 IsAbilityAndRecord(enum BattlerId battler, enum Ability battlerAbility, enum Ability abilityToCheck); bool32 HandleFaintedMonActions(void); void TryClearRageAndFuryCutter(void); -bool32 HasNoMonsToSwitch(u32 battler, u8 partyIdBattlerOn1, u8 partyIdBattlerOn2); -bool32 TryChangeBattleWeather(u32 battler, u32 battleWeatherId, enum Ability ability); -bool32 TryChangeBattleTerrain(u32 battler, u32 statusFlag); -bool32 CanAbilityBlockMove(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, u32 move, enum ResultOption option); +bool32 HasNoMonsToSwitch(enum BattlerId battler, u8 partyIdBattlerOn1, u8 partyIdBattlerOn2); +bool32 TryChangeBattleWeather(enum BattlerId battler, u32 battleWeatherId, enum Ability ability); +bool32 TryChangeBattleTerrain(enum BattlerId battler, u32 statusFlag); +bool32 CanAbilityBlockMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, u32 move, enum ResultOption option); bool32 CanTargetBlockPranksterMove(struct BattleContext *ctx, s32 movePriority); bool32 CanPsychicTerrainProtectTarget(struct BattleContext *ctx, s32 movePriority); bool32 CanMoveBeBlockedByTarget(struct BattleContext *ctx, s32 movePriority); bool32 CanAbilityAbsorbMove(struct BattleContext *ctx); bool32 TryFieldEffects(enum FieldEffectCases caseId); -u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ability, enum Move move, bool32 shouldAbilityTrigger); -bool32 TryPrimalReversion(u32 battler); +u32 AbilityBattleEffects(enum AbilityEffect caseID, enum BattlerId battler, enum Ability ability, enum Move move, bool32 shouldAbilityTrigger); +bool32 TryPrimalReversion(enum BattlerId battler); bool32 IsNeutralizingGasOnField(void); -bool32 IsMoldBreakerTypeAbility(u32 battler, enum Ability ability); -enum Ability GetBattlerAbilityIgnoreMoldBreaker(u32 battler); -enum Ability GetBattlerAbilityNoAbilityShield(u32 battler); -enum Ability GetBattlerAbilityInternal(u32 battler, bool32 ignoreMoldBreaker, bool32 noAbilityShield); -enum Ability GetBattlerAbility(u32 battler); -u32 IsAbilityOnSide(u32 battler, enum Ability ability); -u32 IsAbilityOnOpposingSide(u32 battler, enum Ability ability); +bool32 IsMoldBreakerTypeAbility(enum BattlerId battler, enum Ability ability); +enum Ability GetBattlerAbilityIgnoreMoldBreaker(enum BattlerId battler); +enum Ability GetBattlerAbilityNoAbilityShield(enum BattlerId battler); +enum Ability GetBattlerAbilityInternal(enum BattlerId battler, bool32 ignoreMoldBreaker, bool32 noAbilityShield); +enum Ability GetBattlerAbility(enum BattlerId battler); +u32 IsAbilityOnSide(enum BattlerId battler, enum Ability ability); +u32 IsAbilityOnOpposingSide(enum BattlerId battler, enum Ability ability); u32 IsAbilityOnField(enum Ability ability); -u32 IsAbilityOnFieldExcept(u32 battler, enum Ability ability); -u32 IsAbilityPreventingEscape(u32 battler); +u32 IsAbilityOnFieldExcept(enum BattlerId battler, enum Ability ability); +u32 IsAbilityPreventingEscape(enum BattlerId battler); bool32 IsBattlerProtected(struct BattleContext *ctx); enum ProtectType GetProtectType(enum ProtectMethod method); -bool32 CanBattlerEscape(u32 battler); // no ability check +bool32 CanBattlerEscape(enum BattlerId battler); // no ability check void BattleScriptExecute(const u8 *BS_ptr); void BattleScriptPushCursorAndCallback(const u8 *BS_ptr); -void ClearVariousBattlerFlags(u32 battler); +void ClearVariousBattlerFlags(enum BattlerId battler); void HandleAction_RunBattleScript(void); -u32 SetRandomTarget(u32 battler); +u32 SetRandomTarget(enum BattlerId battlerAtk); u32 GetBattleMoveTarget(enum Move move, enum MoveTarget moveTarget); enum Obedience GetAttackerObedienceForAction(void); -enum HoldEffect GetBattlerHoldEffect(u32 battler); -enum HoldEffect GetBattlerHoldEffectIgnoreAbility(u32 battler); -enum HoldEffect GetBattlerHoldEffectIgnoreNegation(u32 battler); -enum HoldEffect GetBattlerHoldEffectInternal(u32 battler, enum Ability ability); -u32 GetBattlerHoldEffectParam(u32 battler); -bool32 CanBattlerAvoidContactEffects(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move); -bool32 IsMoveMakingContact(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move); -bool32 IsBattlerGrounded(u32 battler, enum Ability ability, enum HoldEffect holdEffect); +enum HoldEffect GetBattlerHoldEffect(enum BattlerId battler); +enum HoldEffect GetBattlerHoldEffectIgnoreAbility(enum BattlerId battler); +enum HoldEffect GetBattlerHoldEffectIgnoreNegation(enum BattlerId battler); +enum HoldEffect GetBattlerHoldEffectInternal(enum BattlerId battler, enum Ability ability); +u32 GetBattlerHoldEffectParam(enum BattlerId battler); +bool32 CanBattlerAvoidContactEffects(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move); +bool32 IsMoveMakingContact(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move); +bool32 IsBattlerGrounded(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect); u32 GetMoveSlot(u16 *moves, enum Move move); -u32 GetBattlerWeight(u32 battler); +u32 GetBattlerWeight(enum BattlerId battler); s32 CalcCritChanceStage(struct BattleContext *ctx); s32 CalcCritChanceStageGen1(struct BattleContext *ctx); s32 CalculateMoveDamage(struct BattleContext *ctx); @@ -270,160 +270,160 @@ uq4_12_t CalcPartyMonTypeEffectivenessMultiplier(enum Move move, u16 speciesDef, uq4_12_t GetTypeModifier(enum Type atkType, enum Type defType); uq4_12_t GetOverworldTypeEffectiveness(struct Pokemon *mon, enum Type moveType); void UpdateMoveResultFlags(uq4_12_t modifier, u16 *resultFlags); -s32 GetStealthHazardDamage(enum TypeSideHazard hazardType, u32 battler); +s32 GetStealthHazardDamage(enum TypeSideHazard hazardType, enum BattlerId battler); s32 GetStealthHazardDamageByTypesAndHP(enum TypeSideHazard hazardType, enum Type type1, enum Type type2, u32 maxHp); -bool32 CanMegaEvolve(u32 battler); -bool32 CanUltraBurst(u32 battler); -void ActivateMegaEvolution(u32 battler); -void ActivateUltraBurst(u32 battler); -bool32 IsBattlerMegaEvolved(u32 battler); -bool32 IsBattlerPrimalReverted(u32 battler); -bool32 IsBattlerUltraBursted(u32 battler); -u32 GetBattleFormChangeTargetSpecies(u32 battler, enum FormChanges method); +bool32 CanMegaEvolve(enum BattlerId battler); +bool32 CanUltraBurst(enum BattlerId battler); +void ActivateMegaEvolution(enum BattlerId battler); +void ActivateUltraBurst(enum BattlerId battler); +bool32 IsBattlerMegaEvolved(enum BattlerId battler); +bool32 IsBattlerPrimalReverted(enum BattlerId battler); +bool32 IsBattlerUltraBursted(enum BattlerId battler); +u32 GetBattleFormChangeTargetSpecies(enum BattlerId battler, enum FormChanges method); bool32 TryRevertPartyMonFormChange(u32 partyIndex); -bool32 TryBattleFormChange(u32 battler, enum FormChanges method); -bool32 DoBattlersShareType(u32 battler1, u32 battler2); -bool32 CanBattlerGetOrLoseItem(u32 fromBattler, u32 battler, enum Item itemId); -u32 GetBattlerVisualSpecies(u32 battler); -bool32 TryClearIllusion(u32 battler, enum Ability ability); -u32 GetIllusionMonSpecies(u32 battler); -struct Pokemon *GetIllusionMonPtr(u32 battler); -void ClearIllusionMon(u32 battler); -u32 GetIllusionMonPartyId(struct Pokemon *party, struct Pokemon *mon, struct Pokemon *partnerMon, u32 battler); -void SetIllusionMon(struct Pokemon *mon, u32 battler); -enum ImmunityHealStatusOutcome TryImmunityAbilityHealStatus(u32 battler); -bool32 ShouldGetStatBadgeBoost(u16 flagId, u32 battler); +bool32 TryBattleFormChange(enum BattlerId battler, enum FormChanges method); +bool32 DoBattlersShareType(enum BattlerId battler1, enum BattlerId battler2); +bool32 CanBattlerGetOrLoseItem(enum BattlerId fromBattler, enum BattlerId battler, enum Item itemId); +u32 GetBattlerVisualSpecies(enum BattlerId battler); +bool32 TryClearIllusion(enum BattlerId battler, enum Ability ability); +u32 GetIllusionMonSpecies(enum BattlerId battler); +struct Pokemon *GetIllusionMonPtr(enum BattlerId battler); +void ClearIllusionMon(enum BattlerId battler); +u32 GetIllusionMonPartyId(struct Pokemon *party, struct Pokemon *mon, struct Pokemon *partnerMon, enum BattlerId battler); +void SetIllusionMon(struct Pokemon *mon, enum BattlerId battler); +enum ImmunityHealStatusOutcome TryImmunityAbilityHealStatus(enum BattlerId battler); +bool32 ShouldGetStatBadgeBoost(u16 flagId, enum BattlerId battler); uq4_12_t GetBadgeBoostModifier(void); enum DamageCategory GetBattleMoveCategory(enum Move move); -void SetDynamicMoveCategory(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 CanFling(u32 battlerAtk, u32 battlerDef); +void SetDynamicMoveCategory(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 CanFling(enum BattlerId battlerAtk, enum BattlerId battlerDef); bool32 IsTelekinesisBannedSpecies(u16 species); -bool32 IsHealBlockPreventingMove(u32 battler, enum Move move); +bool32 IsHealBlockPreventingMove(enum BattlerId battler, enum Move move); bool32 IsGravityPreventingMove(enum Move move); -bool32 IsBelchPreventingMove(u32 battler, enum Move move); -bool32 HasEnoughHpToEatBerry(u32 battler, enum Ability ability, u32 hpFraction, enum Item itemId); -bool32 IsPartnerMonFromSameTrainer(u32 battler); -enum DamageCategory GetCategoryBasedOnStats(u32 battler); +bool32 IsBelchPreventingMove(enum BattlerId battler, enum Move move); +bool32 HasEnoughHpToEatBerry(enum BattlerId battler, enum Ability ability, u32 hpFraction, enum Item itemId); +bool32 IsPartnerMonFromSameTrainer(enum BattlerId battler); +enum DamageCategory GetCategoryBasedOnStats(enum BattlerId battler); void SetShellSideArmCategory(void); bool32 MoveIsAffectedBySheerForce(enum Move move); bool32 IsSheerForceAffected(enum Move move, enum Ability ability); void TryRestoreHeldItems(void); -bool32 CanStealItem(u32 battlerStealing, u32 battlerItem, enum Item item); -void TrySaveExchangedItem(u32 battler, enum Item stolenItem); -bool32 IsBattlerAffectedByHazards(u32 battler, enum HoldEffect holdEffect, bool32 toxicSpikes); -void SortBattlersBySpeed(u8 *battlers, bool32 slowToFast); -bool32 CompareStat(u32 battler, enum Stat statId, u32 cmpTo, u32 cmpKind, enum Ability ability); -bool32 BlocksPrankster(enum Move move, u32 battlerPrankster, u32 battlerDef, bool32 checkTarget); -bool32 PickupHasValidTarget(u32 battler); +bool32 CanStealItem(enum BattlerId battlerStealing, enum BattlerId battlerItem, enum Item item); +void TrySaveExchangedItem(enum BattlerId battler, enum Item stolenItem); +bool32 IsBattlerAffectedByHazards(enum BattlerId battler, enum HoldEffect holdEffect, bool32 toxicSpikes); +void SortBattlersBySpeed(enum BattlerId *battlers, bool32 slowToFast); +bool32 CompareStat(enum BattlerId battler, enum Stat statId, u32 cmpTo, u32 cmpKind, enum Ability ability); +bool32 BlocksPrankster(enum Move move, enum BattlerId battlerPrankster, enum BattlerId battlerDef, bool32 checkTarget); +bool32 PickupHasValidTarget(enum BattlerId battler); bool32 CantPickupItem(u32 battler); -bool32 IsBattlerWeatherAffected(u32 battler, u32 weatherFlags); -enum MoveTarget GetBattlerMoveTargetType(u32 battler, enum Move move); -bool32 CanTargetBattler(u32 battlerAtk, u32 battlerDef, enum Move move); +bool32 IsBattlerWeatherAffected(enum BattlerId battler, u32 weatherFlags); +enum MoveTarget GetBattlerMoveTargetType(enum BattlerId battler, enum Move move); +bool32 CanTargetBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); u32 GetNextTarget(u32 moveTarget, bool32 excludeCurrent); -void CopyMonLevelAndBaseStatsToBattleMon(u32 battler, struct Pokemon *mon); -void CopyMonAbilityAndTypesToBattleMon(u32 battler, struct Pokemon *mon); -void RecalcBattlerStats(u32 battler, struct Pokemon *mon, bool32 isDynamaxing); +void CopyMonLevelAndBaseStatsToBattleMon(enum BattlerId battler, struct Pokemon *mon); +void CopyMonAbilityAndTypesToBattleMon(enum BattlerId battler, struct Pokemon *mon); +void RecalcBattlerStats(enum BattlerId battler, struct Pokemon *mon, bool32 isDynamaxing); bool32 IsGen6ExpShareEnabled(void); bool32 MoveHasAdditionalEffect(enum Move move, enum MoveEffect moveEffect); bool32 MoveHasAdditionalEffectWithChance(enum Move move, enum MoveEffect moveEffect, u32 chance); bool32 MoveHasAdditionalEffectSelf(enum Move move, enum MoveEffect moveEffect); bool32 IsMoveEffectRemoveSpeciesType(enum Move move, enum MoveEffect moveEffect, u32 argument); bool32 MoveHasChargeTurnAdditionalEffect(enum Move move); -bool32 CanTargetPartner(u32 battlerAtk, u32 battlerDef); -bool32 IsBattlerUnaffectedByMove(u32 battler); +bool32 CanTargetPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef); +bool32 IsBattlerUnaffectedByMove(enum BattlerId battler); bool32 MoodyCantRaiseStat(u32 stat); bool32 MoodyCantLowerStat(u32 stat); -bool32 IsPsychicTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); -bool32 IsMistyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); -bool32 IsGrassyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); -bool32 IsElectricTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); -bool32 IsAnyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); -bool32 IsBattlerTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses, u32 terrainFlag); -enum Stat GetHighestStatId(u32 battler); -enum Stat GetParadoxHighestStatId(u32 battler); -enum Stat GetParadoxBoostedStatId(u32 battler); +bool32 IsPsychicTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); +bool32 IsMistyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); +bool32 IsGrassyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); +bool32 IsElectricTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); +bool32 IsAnyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses); +bool32 IsBattlerTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses, u32 terrainFlag); +enum Stat GetHighestStatId(enum BattlerId battler); +enum Stat GetParadoxHighestStatId(enum BattlerId battler); +enum Stat GetParadoxBoostedStatId(enum BattlerId battler); -bool32 CanBeSlept(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef, enum SleepClauseBlock isBlockedBySleepClause); -bool32 CanBePoisoned(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef); -bool32 CanBeBurned(u32 battlerAtk, u32 battlerDef, enum Ability ability); -bool32 CanBeParalyzed(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 CanBeFrozen(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 CanGetFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef); -bool32 CanSetNonVolatileStatus(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum MoveEffect secondaryMoveEffect, enum ResultOption option); -bool32 CanBeConfused(u32 battler); -u32 GetBattlerAffectionHearts(u32 battler); +bool32 CanBeSlept(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef, enum SleepClauseBlock isBlockedBySleepClause); +bool32 CanBePoisoned(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef); +bool32 CanBeBurned(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability ability); +bool32 CanBeParalyzed(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 CanBeFrozen(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 CanGetFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef); +bool32 CanSetNonVolatileStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum MoveEffect secondaryMoveEffect, enum ResultOption option); +bool32 CanBeConfused(enum BattlerId battler); +u32 GetBattlerAffectionHearts(enum BattlerId battler); void TryToRevertMimicryAndFlags(void); bool32 BattleArenaTurnEnd(void); -u32 CountBattlerStatIncreases(u32 battler, bool32 countEvasionAcc); -bool32 BattlerHasCopyableChanges(u32 battler); -bool32 ChangeTypeBasedOnTerrain(u32 battler); -void RemoveConfusionStatus(u32 battler); -u32 GetBattlerGender(u32 battler); -bool32 AreBattlersOfOppositeGender(u32 battler1, u32 battler2); -bool32 AreBattlersOfSameGender(u32 battler1, u32 battler2); -u32 CalcSecondaryEffectChance(u32 battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect); -bool32 MoveEffectIsGuaranteed(u32 battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect); -void GetBattlerTypes(u32 battler, bool32 ignoreTera, enum Type types[static 3]); -enum Type GetBattlerType(u32 battler, u32 typeIndex, bool32 ignoreTera); +u32 CountBattlerStatIncreases(enum BattlerId battler, bool32 countEvasionAcc); +bool32 BattlerHasCopyableChanges(enum BattlerId battler); +bool32 ChangeTypeBasedOnTerrain(enum BattlerId battler); +void RemoveConfusionStatus(enum BattlerId battler); +u32 GetBattlerGender(enum BattlerId battler); +bool32 AreBattlersOfOppositeGender(enum BattlerId battler1, enum BattlerId battler2); +bool32 AreBattlersOfSameGender(enum BattlerId battler1, enum BattlerId battler2); +u32 CalcSecondaryEffectChance(enum BattlerId battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect); +bool32 MoveEffectIsGuaranteed(enum BattlerId battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect); +void GetBattlerTypes(enum BattlerId battler, bool32 ignoreTera, enum Type types[static 3]); +enum Type GetBattlerType(enum BattlerId battler, u32 typeIndex, bool32 ignoreTera); bool32 CanMonParticipateInSkyBattle(struct Pokemon *mon); -void RemoveBattlerType(u32 battler, enum Type type); +void RemoveBattlerType(enum BattlerId battler, enum Type type); enum Type GetBattleMoveType(enum Move move); -void TryActivateSleepClause(u32 battler, u32 indexInParty); +void TryActivateSleepClause(enum BattlerId battler, u32 indexInParty); void TryDeactivateSleepClause(enum BattleSide battlerSide, u32 indexInParty); bool32 IsSleepClauseActiveForSide(enum BattleSide battlerSide); bool32 IsSleepClauseEnabled(void); void ClearDamageCalcResults(void); -u32 DoesDestinyBondFail(u32 battler); +u32 DoesDestinyBondFail(enum BattlerId battler); bool32 IsMoveEffectBlockedByTarget(enum Ability ability); -bool32 SetTargetToNextPursuiter(u32 battlerDef); +bool32 SetTargetToNextPursuiter(enum BattlerId battlerDef); bool32 IsPursuitTargetSet(void); -void ClearPursuitValuesIfSet(u32 battler); +void ClearPursuitValuesIfSet(enum BattlerId battler); void ClearPursuitValues(void); bool32 HasWeatherEffect(void); -bool32 IsFutureSightAttackerInParty(u32 battlerAtk, u32 battlerDef, enum Move move); -bool32 HadMoreThanHalfHpNowDoesnt(u32 battler); -void ChooseStatBoostAnimation(u32 battler); +bool32 IsFutureSightAttackerInParty(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move); +bool32 HadMoreThanHalfHpNowDoesnt(enum BattlerId battler); +void ChooseStatBoostAnimation(enum BattlerId battler); void UpdateStallMons(void); bool32 TrySwitchInEjectPack(enum EjectPackTiming timing); -bool32 EmergencyExitCanBeTriggered(u32 battler); -bool32 TryTriggerSymbiosis(u32 battler, u32 ally); -bool32 TrySymbiosis(u32 battler, enum Item itemId, bool32 moveEnd); -void BestowItem(u32 battlerAtk, u32 battlerDef); -ARM_FUNC u32 GetBattlerVolatile(u32 battler, enum Volatile _volatile); -void SetMonVolatile(u32 battler, enum Volatile _volatile, u32 newValue); -bool32 ItemHealMonVolatile(u32 battler, enum Item itemId); +bool32 EmergencyExitCanBeTriggered(enum BattlerId battler); +bool32 TryTriggerSymbiosis(enum BattlerId battler, u32 ally); +bool32 TrySymbiosis(enum BattlerId battler, enum Item itemId, bool32 moveEnd); +void BestowItem(enum BattlerId battlerAtk, enum BattlerId battlerDef); +ARM_FUNC u32 GetBattlerVolatile(enum BattlerId battler, enum Volatile _volatile); +void SetMonVolatile(enum BattlerId battler, enum Volatile _volatile, u32 newValue); +bool32 ItemHealMonVolatile(enum BattlerId battler, enum Item itemId); void PushHazardTypeToQueue(enum BattleSide side, enum Hazards hazardType); bool32 IsHazardOnSide(enum BattleSide side, enum Hazards hazardType); bool32 AreAnyHazardsOnSide(enum BattleSide side); void RemoveAllHazardsFromField(enum BattleSide side); bool32 IsHazardOnSideAndClear(enum BattleSide side, enum Hazards hazardType); void RemoveHazardFromField(enum BattleSide side, enum Hazards hazardType); -bool32 CanMoveSkipAccuracyCalc(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move, enum ResultOption option); -u32 GetTotalAccuracy(u32 battlerAtk, u32 battlerDef, enum Move move, enum Ability atkAbility, enum Ability defAbility, enum HoldEffect atkHoldEffect, enum HoldEffect defHoldEffect); +bool32 CanMoveSkipAccuracyCalc(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move, enum ResultOption option); +u32 GetTotalAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Ability atkAbility, enum Ability defAbility, enum HoldEffect atkHoldEffect, enum HoldEffect defHoldEffect); bool32 DoesOHKOMoveMissTarget(struct BattleCalcValues *cv); bool32 DoesMoveMissTarget(struct BattleCalcValues *cv); -bool32 IsSemiInvulnerable(u32 battler, enum SemiInvulnerableExclusion excludeCommander); -bool32 BreaksThroughSemiInvulnerablity(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move); -bool32 HasPartnerTrainer(u32 battler); -bool32 IsAffectedByPowderMove(u32 battler, enum Ability ability, enum HoldEffect holdEffect); -enum Move GetNaturePowerMove(u32 battler); -void RemoveAbilityFlags(u32 battler); -void CheckSetUnburden(u32 battler); +bool32 IsSemiInvulnerable(enum BattlerId battler, enum SemiInvulnerableExclusion excludeCommander); +bool32 BreaksThroughSemiInvulnerablity(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move); +bool32 HasPartnerTrainer(enum BattlerId battler); +bool32 IsAffectedByPowderMove(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect); +enum Move GetNaturePowerMove(void); +void RemoveAbilityFlags(enum BattlerId battler); +void CheckSetUnburden(enum BattlerId battler); bool32 IsDazzlingAbility(enum Ability ability); bool32 IsAllowedToUseBag(void); -bool32 IsAnyTargetTurnDamaged(u32 battlerAtk); +bool32 IsAnyTargetTurnDamaged(enum BattlerId battlerAtk); bool32 IsAnyTargetAffected(void); -bool32 IsMimikyuDisguised(u32 battler); +bool32 IsMimikyuDisguised(enum BattlerId battler); bool32 IsDoubleSpreadMove(void); -bool32 IsBattlerInvalidForSpreadMove(u32 battlerAtk, u32 battlerDef); +bool32 IsBattlerInvalidForSpreadMove(enum BattlerId battlerAtk, enum BattlerId battlerDef); void SetStartingStatus(enum StartingStatus status); void ResetStartingStatuses(void); bool32 IsUsableWhileAsleepEffect(enum BattleMoveEffects effect); -void SetWrapTurns(u32 battler, enum HoldEffect holdEffect); +void SetWrapTurns(enum BattlerId battler, enum HoldEffect holdEffect); bool32 ChangeOrderTargetAfterAttacker(void); void TryUpdateEvolutionTracker(enum EvolutionConditions evolutionCondition, u32 upAmount, enum Move usedMove); -bool32 CanUseMoveConsecutively(u32 battler); -void TryResetConsecutiveUseCounter(u32 battler); +bool32 CanUseMoveConsecutively(enum BattlerId battler); +void TryResetConsecutiveUseCounter(enum BattlerId battler); void SetOrClearRageVolatile(void); #endif // GUARD_BATTLE_UTIL_H diff --git a/include/battle_util2.h b/include/battle_util2.h index 51c9c03630..5f91ba6dd6 100644 --- a/include/battle_util2.h +++ b/include/battle_util2.h @@ -3,8 +3,8 @@ void AllocateBattleResources(void); void FreeBattleResources(void); -void AdjustFriendshipOnBattleFaint(u8 battler); -void SwitchPartyOrderInGameMulti(u8 battler, u8 arg1); -u32 BattlePalace_TryEscapeStatus(u8 battler); +void AdjustFriendshipOnBattleFaint(enum BattlerId battler); +void SwitchPartyOrderInGameMulti(enum BattlerId battler, u8 arg1); +u32 BattlePalace_TryEscapeStatus(enum BattlerId battler); #endif // GUARD_BATTLE_UTIL_H diff --git a/include/battle_z_move.h b/include/battle_z_move.h index e5d44ab8d2..6a039c21f0 100644 --- a/include/battle_z_move.h +++ b/include/battle_z_move.h @@ -12,16 +12,16 @@ struct SignatureZMove }; bool32 IsZMove(enum Move move); -bool32 CanUseZMove(u32 battler); -enum Move GetUsableZMove(u32 battler, enum Move move); -void ActivateZMove(u32 battler); -bool32 IsViableZMove(u32 battler, enum Move move); -bool32 TryChangeZTrigger(u32 battler, u32 moveIndex); +bool32 CanUseZMove(enum BattlerId battler); +enum Move GetUsableZMove(enum BattlerId battler, enum Move move); +void ActivateZMove(enum BattlerId battler); +bool32 IsViableZMove(enum BattlerId battler, enum Move move); +bool32 TryChangeZTrigger(enum BattlerId battler, u32 moveIndex); enum Move GetTypeBasedZMove(enum Move move); enum Move GetSignatureZMove(enum Move move, u32 species, enum Item item); -bool32 MoveSelectionDisplayZMove(enum Move zmove, u32 battler); +bool32 MoveSelectionDisplayZMove(enum Move zmove, enum BattlerId battler); void SetZEffect(void); -void AssignUsableZMoves(u32 battler, enum Move *moves); +void AssignUsableZMoves(enum BattlerId battler, enum Move *moves); u32 GetZMovePower(enum Move move); #endif // GUARD_BATTLE_Z_MOVE_H diff --git a/include/constants/battle.h b/include/constants/battle.h index 0a2f0ecb55..32b2596017 100644 --- a/include/constants/battle.h +++ b/include/constants/battle.h @@ -35,7 +35,7 @@ enum BattlerPosition B_POSITION_ABSENT = 0xFF, }; -enum BattlerId +enum __attribute__((packed)) BattlerId { B_BATTLER_0, B_BATTLER_1, diff --git a/include/constants/battle_anim.h b/include/constants/battle_anim.h index fd09cb2927..ffc1a82185 100644 --- a/include/constants/battle_anim.h +++ b/include/constants/battle_anim.h @@ -426,17 +426,18 @@ #define ANIM_TAG_COUNT GET_TRUE_SPRITE_INDEX(ANIM_TAG_TATSUGIRI_STRETCHY + 1) // battlers -#define ANIM_ATTACKER 0 -#define ANIM_TARGET 1 -#define ANIM_ATK_PARTNER 2 -#define ANIM_DEF_PARTNER 3 - -// Below are used by AnimTask_ShakeMon2 and AnimTask_SetGrayscaleOrOriginalPal -#define ANIM_PLAYER_LEFT (MAX_BATTLERS_COUNT + 0) -#define ANIM_OPPONENT_LEFT (MAX_BATTLERS_COUNT + 1) -#define ANIM_PLAYER_RIGHT (MAX_BATTLERS_COUNT + 2) -#define ANIM_OPPONENT_RIGHT (MAX_BATTLERS_COUNT + 3) -#define ANIM_ATTACKER_FORCE (MAX_BATTLERS_COUNT + 4) +enum AnimBattler +{ + ANIM_ATTACKER, + ANIM_TARGET, + ANIM_ATK_PARTNER, + ANIM_DEF_PARTNER, + ANIM_PLAYER_LEFT = MAX_BATTLERS_COUNT, + ANIM_OPPONENT_LEFT, + ANIM_PLAYER_RIGHT, + ANIM_OPPONENT_RIGHT, + ANIM_ATTACKER_FORCE, +}; // stereo panning constants [0-255] // diff --git a/include/party_menu.h b/include/party_menu.h index 40530c7c3a..6e4a2a4a03 100644 --- a/include/party_menu.h +++ b/include/party_menu.h @@ -89,8 +89,8 @@ void ChooseMonForWirelessMinigame(void); void OpenPartyMenuInBattle(u8 partyAction); void ChooseMonForInBattleItem(void); void BufferBattlePartyCurrentOrder(void); -void BufferBattlePartyCurrentOrderBySide(u8 battler, u8 flankId); -void SwitchPartyOrderLinkMulti(u8 battler, u8 slot, u8 slot2); +void BufferBattlePartyCurrentOrderBySide(enum BattlerId battler, u8 flankId); +void SwitchPartyOrderLinkMulti(enum BattlerId battler, u8 slot, u8 slot2); void SwitchPartyMonSlots(u8 slot, u8 slot2); u8 GetPartyIdFromBattlePartyId(u8 battlePartyId); void ShowPartyMenuToShowcaseMultiBattleParty(void); diff --git a/include/pokeball.h b/include/pokeball.h index e9f8864f18..8052df4620 100644 --- a/include/pokeball.h +++ b/include/pokeball.h @@ -56,11 +56,11 @@ extern const struct PokeBallSprite gPokeBalls[]; #define POKEBALL_OPPONENT_SENDOUT 0xFE #define POKEBALL_PLAYER_SLIDEIN 0xFD -u8 DoPokeballSendOutAnimation(u32 battler, s16 pan, u8 kindOfThrow); +u8 DoPokeballSendOutAnimation(enum BattlerId 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); -void DoHitAnimHealthboxEffect(u8 battler); +void StartHealthboxSlideIn(enum BattlerId battler); +void DoHitAnimHealthboxEffect(enum BattlerId battler); void LoadBallGfx(u8 ballId); void FreeBallGfx(u8 ballId); enum PokeBall ItemIdToBallId(u32 ballItem); diff --git a/include/pokemon.h b/include/pokemon.h index 5d5dacca13..3b76739927 100644 --- a/include/pokemon.h +++ b/include/pokemon.h @@ -743,8 +743,8 @@ enum Move MonTryLearningNewMoveAtLevel(struct Pokemon *mon, bool32 firstMove, u3 enum Move MonTryLearningNewMove(struct Pokemon *mon, bool8 firstMove); void DeleteFirstMoveAndGiveMoveToMon(struct Pokemon *mon, enum Move move); void DeleteFirstMoveAndGiveMoveToBoxMon(struct BoxPokemon *boxMon, enum Move move); -u8 CountAliveMonsInBattle(u8 caseId, u32 battler); -u8 GetDefaultMoveTarget(u8 battler); +u8 CountAliveMonsInBattle(u8 caseId, enum BattlerId battler); +u8 GetDefaultMoveTarget(enum BattlerId battler); u8 GetMonGender(struct Pokemon *mon); u8 GetBoxMonGender(struct BoxPokemon *boxMon); u8 GetGenderFromSpeciesAndPersonality(u16 species, u32 personality); @@ -773,7 +773,7 @@ u8 GiveCapturedMonToPlayer(struct Pokemon *mon); u8 CopyMonToPC(struct Pokemon *mon); u8 CalculatePlayerPartyCount(void); u8 CalculateEnemyPartyCount(void); -u8 CalculateEnemyPartyCountInSide(u32 battler); +u8 CalculateEnemyPartyCountInSide(enum BattlerId battler); u8 GetMonsStateToDoubles(void); u8 GetMonsStateToDoubles_2(void); enum Ability GetAbilityBySpecies(u16 species, u8 abilityNum); @@ -808,11 +808,11 @@ void RemoveMonPPBonus(struct Pokemon *mon, u8 moveIndex); void RemoveBoxMonPPBonus(struct BoxPokemon *mon, u8 moveIndex); void RemoveBattleMonPPBonus(struct BattlePokemon *mon, u8 moveIndex); void PokemonToBattleMon(struct Pokemon *src, struct BattlePokemon *dst); -void CopyPartyMonToBattleData(u32 battler, u32 partyIndex); +void CopyPartyMonToBattleData(enum BattlerId battler, u32 partyIndex); bool8 ExecuteTableBasedItemEffect(struct Pokemon *mon, enum Item item, u8 partyIndex, u8 moveIndex); bool8 PokemonUseItemEffects(struct Pokemon *mon, enum Item item, u8 partyIndex, u8 moveIndex, u8 usedByAI); -bool8 HealStatusConditions(struct Pokemon *mon, u32 healMask, u8 battler); -u8 GetItemEffectParamOffset(u32 battler, enum Item itemId, u8 effectByte, u8 effectBit); +bool8 HealStatusConditions(struct Pokemon *mon, u32 healMask, enum BattlerId battler); +u8 GetItemEffectParamOffset(enum BattlerId battler, enum Item itemId, u8 effectByte, u8 effectBit); u8 *UseStatIncreaseItem(enum Item itemId); u8 GetNature(struct Pokemon *mon); u8 GetNatureFromPersonality(u32 personality); @@ -900,7 +900,7 @@ void HealPokemon(struct Pokemon *mon); void HealBoxPokemon(struct BoxPokemon *boxMon); void UpdateDaysPassedSinceFormChange(u16 days); void TrySetDayLimitToFormChange(struct Pokemon *mon); -enum Type CheckDynamicMoveType(struct Pokemon *mon, enum Move move, u32 battler, enum MonState state); +enum Type CheckDynamicMoveType(struct Pokemon *mon, enum Move move, enum BattlerId battler, enum MonState state); uq4_12_t GetDynamaxLevelHPMultiplier(u32 dynamaxLevel, bool32 inverseMultiplier); u32 GetRegionalFormByRegion(u32 species, u32 region); bool32 IsSpeciesForeignRegionalForm(u32 species, u32 currentRegion); diff --git a/include/recorded_battle.h b/include/recorded_battle.h index 787cf4606c..5c36b81b7e 100644 --- a/include/recorded_battle.h +++ b/include/recorded_battle.h @@ -60,9 +60,9 @@ extern u8 gRecordedBattleMultiplayerId; void RecordedBattle_Init(u8 mode); void RecordedBattle_SetTrainerInfo(void); -void RecordedBattle_SetBattlerAction(u8 battler, u8 action); -void RecordedBattle_ClearBattlerAction(u8 battler, u8 bytesToClear); -u8 RecordedBattle_GetBattlerAction(u32 actionType, u8 battler); +void RecordedBattle_SetBattlerAction(enum BattlerId battler, u8 action); +void RecordedBattle_ClearBattlerAction(enum BattlerId battler, u8 bytesToClear); +u8 RecordedBattle_GetBattlerAction(u32 actionType, enum BattlerId battler); u8 RecordedBattle_BufferNewBattlerData(u8 *dst); void RecordedBattle_RecordAllBattlerData(u8 *src); bool32 CanCopyRecordedBattleSaveData(void); @@ -73,15 +73,15 @@ void PlayRecordedBattle(void (*CB2_After)(void)); u8 GetRecordedBattleFrontierFacility(void); u8 GetRecordedBattleFronterBrainSymbol(void); void RecordedBattle_SaveParties(void); -u8 GetBattlerLinkPlayerGender(u32 battler); +u8 GetBattlerLinkPlayerGender(enum BattlerId battler); void RecordedBattle_ClearFrontierPassFlag(void); void RecordedBattle_SetFrontierPassFlagFromHword(u16 flags); u8 RecordedBattle_GetFrontierPassFlag(void); u8 GetBattleSceneInRecordedBattle(void); u8 GetTextSpeedInRecordedBattle(void); -void RecordedBattle_CopyBattlerMoves(u32 battler); +void RecordedBattle_CopyBattlerMoves(enum BattlerId battler); void RecordedBattle_CheckMovesetChanges(u8 mode); -u64 GetAiScriptsInRecordedBattle(u32 battler); +u64 GetAiScriptsInRecordedBattle(enum BattlerId battler); void RecordedBattle_SetPlaybackFinished(void); bool8 RecordedBattle_CanStopPlayback(void); void GetRecordedBattleRecordMixFriendName(u8 *dst); diff --git a/include/reshow_battle_screen.h b/include/reshow_battle_screen.h index 59f9c79106..a772cbb2a6 100644 --- a/include/reshow_battle_screen.h +++ b/include/reshow_battle_screen.h @@ -4,6 +4,6 @@ void ReshowBattleScreenDummy(void); void ReshowBattleScreenAfterMenu(void); void ReshowBlankBattleScreenAfterMenu(void); -void CreateBattlerSprite(u32 battler); +void CreateBattlerSprite(enum BattlerId battler); #endif // GUARD_RESHOW_BATTLE_SCREEN_H diff --git a/include/test/battle.h b/include/test/battle.h index 449b83b287..711e7ab928 100644 --- a/include/test/battle.h +++ b/include/test/battle.h @@ -621,7 +621,7 @@ enum struct QueuedAbilityEvent { - u8 battlerId; + enum BattlerId battlerId; enum Ability ability; }; @@ -638,14 +638,14 @@ enum { EXP_EVENT_NEW_EXP, EXP_EVENT_DELTA_EXP }; struct QueuedHPEvent { - u32 battlerId:3; + enum BattlerId battlerId:3; u32 type:1; u32 address:28; }; struct QueuedSubHitEvent { - u32 battlerId:3; + enum BattlerId battlerId:3; u32 checkBreak:1; u32 breakSub:1; u32 address:27; @@ -653,7 +653,7 @@ struct QueuedSubHitEvent struct QueuedExpEvent { - u32 battlerId:3; + enum BattlerId battlerId:3; u32 type:1; u32 address:28; }; @@ -665,7 +665,7 @@ struct QueuedMessageEvent struct QueuedStatusEvent { - u32 battlerId:3; + enum BattlerId battlerId:3; u32 mask:29; }; @@ -1064,7 +1064,7 @@ void ClosePokemon(u32 sourceLine); void RNGSeed_(u32 sourceLine, rng_value_t seed); void AIFlags_(u32 sourceLine, u64 flags); -void BattlerAIFlags_(u32 sourceLine, u32 battler, u64 flags); +void BattlerAIFlags_(u32 sourceLine, enum BattlerId battler, u64 flags); void AILogScores(u32 sourceLine); void Gender_(u32 sourceLine, u32 gender); void Nature_(u32 sourceLine, u32 nature); diff --git a/include/test_runner.h b/include/test_runner.h index 539086b877..13e75e2d76 100644 --- a/include/test_runner.h +++ b/include/test_runner.h @@ -13,23 +13,23 @@ extern const bool8 gTestRunnerSkipIsFail; enum Gimmick; -void TestRunner_Battle_RecordAbilityPopUp(u32 battlerId, enum Ability ability); +void TestRunner_Battle_RecordAbilityPopUp(enum BattlerId battlerId, enum Ability ability); void TestRunner_Battle_RecordAnimation(u32 animType, u32 animId); -void TestRunner_Battle_RecordHP(u32 battlerId, u32 oldHP, u32 newHP); -void TestRunner_Battle_RecordSubHit(u32 battlerId, u32 damage, bool32 broke); -void TestRunner_Battle_RecordExp(u32 battlerId, u32 oldExp, u32 newExp); +void TestRunner_Battle_RecordHP(enum BattlerId battlerId, u32 oldHP, u32 newHP); +void TestRunner_Battle_RecordSubHit(enum BattlerId battlerId, u32 damage, bool32 broke); +void TestRunner_Battle_RecordExp(enum BattlerId battlerId, u32 oldExp, u32 newExp); void TestRunner_Battle_RecordMessage(const u8 *message); -void TestRunner_Battle_RecordStatus1(u32 battlerId, u32 status1); +void TestRunner_Battle_RecordStatus1(enum BattlerId battlerId, u32 status1); void TestRunner_Battle_RecordCatchChance(u32 catchChance); void TestRunner_Battle_AfterLastTurn(void); -void TestRunner_Battle_CheckChosenMove(u32 battlerId, enum Move moveId, u32 target, enum Gimmick gimmick); -void TestRunner_Battle_CheckSwitch(u32 battlerId, u32 partyIndex); -void TestRunner_Battle_CheckAiMoveScores(u32 battlerId); -void TestRunner_Battle_AISetScore(const char *file, u32 line, u32 battlerId, u32 moveIndex, s32 score); -void TestRunner_Battle_AIAdjustScore(const char *file, u32 line, u32 battlerId, u32 moveIndex, s32 score); +void TestRunner_Battle_CheckChosenMove(enum BattlerId battlerId, enum Move moveId, u32 target, enum Gimmick gimmick); +void TestRunner_Battle_CheckSwitch(enum BattlerId battlerId, u32 partyIndex); +void TestRunner_Battle_CheckAiMoveScores(enum BattlerId battlerId); +void TestRunner_Battle_AISetScore(const char *file, u32 line, enum BattlerId battlerId, u32 moveIndex, s32 score); +void TestRunner_Battle_AIAdjustScore(const char *file, u32 line, enum BattlerId battlerId, u32 moveIndex, s32 score); void TestRunner_CheckMemory(void); -void TestRunner_Battle_CheckBattleRecordActionType(u32 battlerId, u32 recordIndex, u32 actionType); +void TestRunner_Battle_CheckBattleRecordActionType(enum BattlerId battlerId, u32 recordIndex, u32 actionType); u32 TestRunner_Battle_GetForcedAbility(enum BattleTrainer trainer, u32 partyIndex); u32 TestRunner_Battle_GetChosenGimmick(enum BattleTrainer trainer, u32 partyIndex); diff --git a/include/trainer_slide.h b/include/trainer_slide.h index 7ff0bca665..3a00e1155d 100644 --- a/include/trainer_slide.h +++ b/include/trainer_slide.h @@ -11,16 +11,16 @@ struct MessageStatus }; void SetTrainerSlideMessage(enum DifficultyLevel difficulty, u32 trainerId, u32 slideId); -enum TrainerSlideTargets ShouldDoTrainerSlide(u32 battler, enum TrainerSlideType slideId); -void TryInitializeFirstSTABMoveTrainerSlide(u32 battlerDef, u32 battlerAtk, enum Type moveType); +enum TrainerSlideTargets ShouldDoTrainerSlide(enum BattlerId battler, enum TrainerSlideType slideId); +void TryInitializeFirstSTABMoveTrainerSlide(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Type moveType); void TryInitializeTrainerSlidePlayerLandsFirstCriticalHit(u32 target); void TryInitializeTrainerSlideEnemyLandsFirstCriticalHit(u32 target); void TryInitializeTrainerSlidePlayerLandsFirstSuperEffectiveHit(u32 target); void TryInitializeTrainerSlideEnemyMonUnaffected(u32 target); -bool32 IsTrainerSlideInitialized(u32 battler, enum TrainerSlideType slideId); -bool32 IsTrainerSlidePlayed(u32 battler, enum TrainerSlideType slideId); -void InitalizeTrainerSlide(u32 battler, enum TrainerSlideType slideId); -void MarkTrainerSlideAsPlayed(u32 battler, enum TrainerSlideType slideId); -void MarkInitializedTrainerSlidesAsPlayed(u32 battler, enum TrainerSlideType slideId); +bool32 IsTrainerSlideInitialized(enum BattlerId battler, enum TrainerSlideType slideId); +bool32 IsTrainerSlidePlayed(enum BattlerId battler, enum TrainerSlideType slideId); +void InitalizeTrainerSlide(enum BattlerId battler, enum TrainerSlideType slideId); +void MarkTrainerSlideAsPlayed(enum BattlerId battler, enum TrainerSlideType slideId); +void MarkInitializedTrainerSlidesAsPlayed(enum BattlerId battler, enum TrainerSlideType slideId); #endif // GUARD_TRAINER_SLIDE_H diff --git a/include/type_icons.h b/include/type_icons.h index c84e44f53d..2a69def76b 100644 --- a/include/type_icons.h +++ b/include/type_icons.h @@ -1,7 +1,7 @@ #ifndef GUARD_TYPE_ICONS_H #define GUARD_TYPE_ICONS_H -void LoadTypeIcons(u32 battler); +void LoadTypeIcons(enum BattlerId battler); #define TYPE_ICON_TAG 0x2720 #define TYPE_ICON_TAG_2 0x2721 diff --git a/src/battle_ai_field_statuses.c b/src/battle_ai_field_statuses.c index 0e395abdcd..44cd78a912 100644 --- a/src/battle_ai_field_statuses.c +++ b/src/battle_ai_field_statuses.c @@ -26,26 +26,26 @@ static bool32 DoesAbilityBenefitFromWeather(enum Ability ability, u32 weather); static bool32 DoesAbilityBenefitFromFieldStatus(enum Ability ability, u32 fieldStatus); // A move is light sensitive if it is boosted by Sunny Day and weakened by low light weathers. static bool32 IsLightSensitiveMove(enum Move move); -static bool32 HasLightSensitiveMove(u32 battler); +static bool32 HasLightSensitiveMove(enum BattlerId battler); // The following functions all feed into WeatherChecker, which is then called by ShouldSetWeather and ShouldClearWeather. // BenefitsFrom functions all return FIELD_EFFECT_POSITIVE if the weather or field effect is good to have in place from the perspective of the battler, FIELD_EFFECT_NEUTRAL if it is neither good nor bad, and FIELD_EFFECT_NEGATIVE if it is bad. // The purpose of WeatherChecker and FieldStatusChecker is to cleanly homogenize the logic that's the same with all of them, and to more easily apply single battle logic to double battles. // ShouldSetWeather and ShouldClearWeather are looking for a positive or negative result respectively, and check the entire side. // If one pokemon has a positive result and the other has a negative result, it defaults to the opinion of the battler that may change the weather or field status. -static enum FieldEffectOutcome BenefitsFromSun(u32 battler); -static enum FieldEffectOutcome BenefitsFromSandstorm(u32 battler); -static enum FieldEffectOutcome BenefitsFromHailOrSnow(u32 battler, u32 weather); -static enum FieldEffectOutcome BenefitsFromRain(u32 battler); +static enum FieldEffectOutcome BenefitsFromSun(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromSandstorm(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromHailOrSnow(enum BattlerId battler, u32 weather); +static enum FieldEffectOutcome BenefitsFromRain(enum BattlerId battler); // The following functions all feed into FieldStatusChecker, which is then called by ShouldSetFieldStatus and ShouldClearFieldStatus. // They work approximately the same as the weather functions. -static enum FieldEffectOutcome BenefitsFromElectricTerrain(u32 battler); -static enum FieldEffectOutcome BenefitsFromGrassyTerrain(u32 battler); -static enum FieldEffectOutcome BenefitsFromMistyTerrain(u32 battler); -static enum FieldEffectOutcome BenefitsFromPsychicTerrain(u32 battler); -static enum FieldEffectOutcome BenefitsFromGravity(u32 battler); -static enum FieldEffectOutcome BenefitsFromTrickRoom(u32 battler); +static enum FieldEffectOutcome BenefitsFromElectricTerrain(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromGrassyTerrain(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromMistyTerrain(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromPsychicTerrain(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromGravity(enum BattlerId battler); +static enum FieldEffectOutcome BenefitsFromTrickRoom(enum BattlerId battler); -static bool32 HasBattlerTerrainBoostMove(u32 battler, u32 terrain) +static bool32 HasBattlerTerrainBoostMove(enum BattlerId battler, u32 terrain) { if (!IsBattlerAlive(battler)) return FALSE; @@ -62,7 +62,7 @@ static bool32 HasBattlerTerrainBoostMove(u32 battler, u32 terrain) return FALSE; } -bool32 WeatherChecker(u32 battler, u32 weather, enum FieldEffectOutcome desiredResult) +bool32 WeatherChecker(enum BattlerId battler, u32 weather, enum FieldEffectOutcome desiredResult) { if (IsWeatherActive(B_WEATHER_PRIMAL_ANY) != WEATHER_INACTIVE) return (FIELD_EFFECT_BLOCKED == desiredResult); @@ -99,7 +99,7 @@ bool32 WeatherChecker(u32 battler, u32 weather, enum FieldEffectOutcome desiredR return (result == desiredResult); } -bool32 FieldStatusChecker(u32 battler, u32 fieldStatus, enum FieldEffectOutcome desiredResult) +bool32 FieldStatusChecker(enum BattlerId battler, u32 fieldStatus, enum FieldEffectOutcome desiredResult) { enum FieldEffectOutcome result = FIELD_EFFECT_NEUTRAL; enum FieldEffectOutcome firstResult = FIELD_EFFECT_NEUTRAL; @@ -215,13 +215,13 @@ static bool32 IsLightSensitiveMove(enum Move move) } } -static bool32 HasLightSensitiveMove(u32 battler) +static bool32 HasLightSensitiveMove(enum BattlerId battler) { enum Move *moves = GetMovesArray(battler); - for (u32 battlerIndex = 0; battlerIndex < MAX_MON_MOVES; battlerIndex++) + for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) { - if (moves[battlerIndex] != MOVE_NONE && moves[battlerIndex] != MOVE_UNAVAILABLE && IsLightSensitiveMove(moves[battlerIndex])) + if (moves[moveIndex] != MOVE_NONE && moves[moveIndex] != MOVE_UNAVAILABLE && IsLightSensitiveMove(moves[moveIndex])) return TRUE; } @@ -230,7 +230,7 @@ static bool32 HasLightSensitiveMove(u32 battler) // Sun // Utility Umbrella does NOT block Ancient Pokemon from their stat boosts. -static enum FieldEffectOutcome BenefitsFromSun(u32 battler) +static enum FieldEffectOutcome BenefitsFromSun(enum BattlerId battler) { enum Ability ability = gAiLogicData->abilities[battler]; @@ -255,7 +255,7 @@ static enum FieldEffectOutcome BenefitsFromSun(u32 battler) } // Sandstorm -static enum FieldEffectOutcome BenefitsFromSandstorm(u32 battler) +static enum FieldEffectOutcome BenefitsFromSandstorm(enum BattlerId battler) { if (DoesAbilityBenefitFromWeather(gAiLogicData->abilities[battler], B_WEATHER_SANDSTORM) || IS_BATTLER_OF_TYPE(battler, TYPE_ROCK)) @@ -275,7 +275,7 @@ static enum FieldEffectOutcome BenefitsFromSandstorm(u32 battler) } // Hail or Snow -static enum FieldEffectOutcome BenefitsFromHailOrSnow(u32 battler, u32 weather) +static enum FieldEffectOutcome BenefitsFromHailOrSnow(enum BattlerId battler, u32 weather) { if (DoesAbilityBenefitFromWeather(gAiLogicData->abilities[battler], weather) || IS_BATTLER_OF_TYPE(battler, TYPE_ICE) @@ -296,7 +296,7 @@ static enum FieldEffectOutcome BenefitsFromHailOrSnow(u32 battler, u32 weather) } // Rain -static enum FieldEffectOutcome BenefitsFromRain(u32 battler) +static enum FieldEffectOutcome BenefitsFromRain(enum BattlerId battler) { if (gAiLogicData->holdEffects[battler] == HOLD_EFFECT_UTILITY_UMBRELLA) return FIELD_EFFECT_NEUTRAL; @@ -316,7 +316,7 @@ static enum FieldEffectOutcome BenefitsFromRain(u32 battler) } //TODO: when is electric terrain bad? -static enum FieldEffectOutcome BenefitsFromElectricTerrain(u32 battler) +static enum FieldEffectOutcome BenefitsFromElectricTerrain(enum BattlerId battler) { if (DoesAbilityBenefitFromFieldStatus(gAiLogicData->abilities[battler], STATUS_FIELD_ELECTRIC_TERRAIN)) return FIELD_EFFECT_POSITIVE; @@ -345,7 +345,7 @@ static enum FieldEffectOutcome BenefitsFromElectricTerrain(u32 battler) } //TODO: when is grassy terrain bad? -static enum FieldEffectOutcome BenefitsFromGrassyTerrain(u32 battler) +static enum FieldEffectOutcome BenefitsFromGrassyTerrain(enum BattlerId battler) { if (DoesAbilityBenefitFromFieldStatus(gAiLogicData->abilities[battler], STATUS_FIELD_GRASSY_TERRAIN)) return FIELD_EFFECT_POSITIVE; @@ -373,7 +373,7 @@ static enum FieldEffectOutcome BenefitsFromGrassyTerrain(u32 battler) } //TODO: when is misty terrain bad? -static enum FieldEffectOutcome BenefitsFromMistyTerrain(u32 battler) +static enum FieldEffectOutcome BenefitsFromMistyTerrain(enum BattlerId battler) { if (DoesAbilityBenefitFromFieldStatus(gAiLogicData->abilities[battler], STATUS_FIELD_MISTY_TERRAIN)) return FIELD_EFFECT_POSITIVE; @@ -407,7 +407,7 @@ static enum FieldEffectOutcome BenefitsFromMistyTerrain(u32 battler) } //TODO: when is Psychic Terrain negative? -static enum FieldEffectOutcome BenefitsFromPsychicTerrain(u32 battler) +static enum FieldEffectOutcome BenefitsFromPsychicTerrain(enum BattlerId battler) { if (DoesAbilityBenefitFromFieldStatus(gAiLogicData->abilities[battler], STATUS_FIELD_PSYCHIC_TERRAIN)) return FIELD_EFFECT_POSITIVE; @@ -446,7 +446,7 @@ static enum FieldEffectOutcome BenefitsFromPsychicTerrain(u32 battler) return FIELD_EFFECT_NEUTRAL; } -static enum FieldEffectOutcome BenefitsFromGravity(u32 battler) +static enum FieldEffectOutcome BenefitsFromGravity(enum BattlerId battler) { if (!AI_IsBattlerGrounded(battler)) return FIELD_EFFECT_NEGATIVE; @@ -474,7 +474,7 @@ static enum FieldEffectOutcome BenefitsFromGravity(u32 battler) return FIELD_EFFECT_NEUTRAL; } -static enum FieldEffectOutcome BenefitsFromTrickRoom(u32 battler) +static enum FieldEffectOutcome BenefitsFromTrickRoom(enum BattlerId battler) { // If we're in singles, we literally only care about speed. if (IsBattle1v1()) @@ -509,7 +509,7 @@ static enum FieldEffectOutcome BenefitsFromTrickRoom(u32 battler) return FIELD_EFFECT_POSITIVE; } -s32 CalcWeatherScore(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +s32 CalcWeatherScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { s32 score = 0; diff --git a/src/battle_ai_items.c b/src/battle_ai_items.c index f081bc38e1..66900b5e79 100644 --- a/src/battle_ai_items.c +++ b/src/battle_ai_items.c @@ -22,10 +22,10 @@ #include "constants/moves.h" // this file's functions -static bool32 AI_ShouldHeal(u32 battler, u32 healAmount); +static bool32 AI_ShouldHeal(enum BattlerId battler, u32 healAmount); static u32 GetHPHealAmount(u8 itemEffectParam, struct Pokemon *mon); -bool32 ShouldUseItem(u32 battler) +bool32 ShouldUseItem(enum BattlerId battler) { struct Pokemon *party; u32 validMons = 0; @@ -194,7 +194,7 @@ bool32 ShouldUseItem(u32 battler) return FALSE; } -static bool32 AI_ShouldHeal(u32 battler, u32 healAmount) +static bool32 AI_ShouldHeal(enum BattlerId battler, u32 healAmount) { bool32 shouldHeal = FALSE; u32 maxDamage = 0; @@ -209,7 +209,7 @@ static bool32 AI_ShouldHeal(u32 battler, u32 healAmount) } //calculate max expected damage from the opponent - for (u32 battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) { if (IsOnPlayerSide(battlerIndex)) { diff --git a/src/battle_ai_main.c b/src/battle_ai_main.c index f695f14e7e..35d82bff1f 100644 --- a/src/battle_ai_main.c +++ b/src/battle_ai_main.c @@ -38,15 +38,15 @@ #define AI_ACTION_WATCH (1 << 2) #define AI_ACTION_DO_NOT_ATTACK (1 << 3) -static u32 ChooseMoveOrAction(u32 battler); -static u32 ChooseMoveOrAction_Singles(u32 battler); -static u32 ChooseMoveOrAction_Doubles(u32 battler); -static inline void BattleAI_DoAIProcessing(struct AiThinkingStruct *aiThink, u32 battlerAtk, u32 battlerDef); -static inline void BattleAI_DoAIProcessing_PredictedSwitchin(struct AiThinkingStruct *aiThink, struct AiLogicData *aiData, u32 battlerAtk, u32 battlerDef); +static u32 ChooseMoveOrAction(enum BattlerId battler); +static u32 ChooseMoveOrAction_Singles(enum BattlerId battler); +static u32 ChooseMoveOrAction_Doubles(enum BattlerId battler); +static inline void BattleAI_DoAIProcessing(struct AiThinkingStruct *aiThink, enum BattlerId battlerAtk, enum BattlerId battlerDef); +static inline void BattleAI_DoAIProcessing_PredictedSwitchin(struct AiThinkingStruct *aiThink, struct AiLogicData *aiData, enum BattlerId battlerAtk, enum BattlerId battlerDef); static bool32 IsPinchBerryItemEffect(enum HoldEffect holdEffect); -static bool32 DoesAbilityBenefitFromSunOrRain(u32 battler, enum Ability ability, u32 weather); -static void AI_CompareDamagingMoves(u32 battlerAtk, u32 battlerDef); -static u32 GetWindAbilityScore(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData); +static bool32 DoesAbilityBenefitFromSunOrRain(enum BattlerId battler, enum Ability ability, u32 weather); +static void AI_CompareDamagingMoves(enum BattlerId battlerAtk, enum BattlerId battlerDef); +static u32 GetWindAbilityScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData); // ewram EWRAM_DATA const u8 *gAIScriptPtr = NULL; // Still used in contests @@ -54,25 +54,25 @@ EWRAM_DATA AiScoreFunc sDynamicAiFunc = NULL; EWRAM_DATA AiSwitchFunc gDynamicAiSwitchFunc = NULL; // const rom data -static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_TryToFaint(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_ForceSetupFirstTurn(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_Risky(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_TryTo2HKO(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_AttacksPartner(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_PreferBatonPass(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_HPAware(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_Roaming(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_Safari(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_FirstBattle(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_DoubleBattle(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_PowerfulStatus(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_DynamicFunc(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_PredictSwitch(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); -static s32 AI_CheckPpStall(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score); +static s32 AI_CheckBadMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_TryToFaint(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_CheckViability(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_ForceSetupFirstTurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_Risky(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_TryTo2HKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_AttacksPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_PreferBatonPass(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_HPAware(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_Roaming(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_Safari(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_FirstBattle(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_DoubleBattle(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_PowerfulStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_DynamicFunc(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_PredictSwitch(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); +static s32 AI_CheckPpStall(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score); -static s32 (*const sBattleAiFuncTable[])(u32, u32, enum Move, s32) = +static s32 (*const sBattleAiFuncTable[])(enum BattlerId, enum BattlerId, enum Move, s32) = { [0] = AI_CheckBadMove, // AI_FLAG_CHECK_BAD_MOVE [1] = AI_TryToFaint, // AI_FLAG_TRY_TO_FAINT @@ -190,7 +190,7 @@ static u64 GetWildAiFlags(void) return flags; } -static u64 GetAiFlags(u16 trainerId, u32 battler) +static u64 GetAiFlags(u16 trainerId, enum BattlerId battler) { u64 flags = 0; @@ -240,22 +240,22 @@ static u64 GetAiFlags(u16 trainerId, u32 battler) void BattleAI_SetupFlags(void) { if (IsAiVsAiBattle()) - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = GetAiFlags(gPartnerTrainerId, B_POSITION_PLAYER_LEFT); + gAiThinkingStruct->aiFlags[B_BATTLER_0] = GetAiFlags(gPartnerTrainerId, B_BATTLER_0); else - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = 0; // player has no AI + gAiThinkingStruct->aiFlags[B_BATTLER_0] = 0; // player has no AI if (DEBUG_OVERWORLD_MENU && gIsDebugBattle) { - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = gDebugAIFlags; - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = gDebugAIFlags; + gAiThinkingStruct->aiFlags[B_BATTLER_1] = gDebugAIFlags; + gAiThinkingStruct->aiFlags[B_BATTLER_3] = gDebugAIFlags; return; } if (IsWildMonSmart() && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER))) { // smart wild AI - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(0xFFFF, B_POSITION_OPPONENT_LEFT); - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(0xFFFF, B_POSITION_OPPONENT_RIGHT); + gAiThinkingStruct->aiFlags[B_BATTLER_1] = GetAiFlags(0xFFFF, B_BATTLER_1); + gAiThinkingStruct->aiFlags[B_BATTLER_3] = GetAiFlags(0xFFFF, B_BATTLER_3); // The check is here because wild natural enemies are not symmetrical. if (B_WILD_NATURAL_ENEMIES && IsDoubleBattle()) @@ -263,38 +263,38 @@ void BattleAI_SetupFlags(void) u32 speciesLeft = GetMonData(&gEnemyParty[0], MON_DATA_SPECIES); u32 speciesRight = GetMonData(&gEnemyParty[1], MON_DATA_SPECIES); if (IsNaturalEnemy(speciesLeft, speciesRight)) - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] |= AI_FLAG_ATTACKS_PARTNER; + gAiThinkingStruct->aiFlags[B_BATTLER_1] |= AI_FLAG_ATTACKS_PARTNER; if (IsNaturalEnemy(speciesRight, speciesLeft)) - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] |= AI_FLAG_ATTACKS_PARTNER; + gAiThinkingStruct->aiFlags[B_BATTLER_3] |= AI_FLAG_ATTACKS_PARTNER; } } else { - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_POSITION_OPPONENT_LEFT); + gAiThinkingStruct->aiFlags[B_BATTLER_1] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_BATTLER_1); if ((TRAINER_BATTLE_PARAM.opponentB != 0) && (TRAINER_BATTLE_PARAM.opponentB != 0xFFFF)) - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_POSITION_OPPONENT_RIGHT); + gAiThinkingStruct->aiFlags[B_BATTLER_3] = GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_BATTLER_3); else - gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_RIGHT] = gAiThinkingStruct->aiFlags[B_POSITION_OPPONENT_LEFT]; + gAiThinkingStruct->aiFlags[B_BATTLER_3] = gAiThinkingStruct->aiFlags[B_BATTLER_1]; } if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) { - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = GetAiFlags(gPartnerTrainerId, B_POSITION_PLAYER_RIGHT); + gAiThinkingStruct->aiFlags[B_BATTLER_2] = GetAiFlags(gPartnerTrainerId, B_BATTLER_1); } else if (IsDoubleBattle() && IsAiVsAiBattle()) { - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT]; + gAiThinkingStruct->aiFlags[B_BATTLER_2] = gAiThinkingStruct->aiFlags[B_BATTLER_0]; } else // Assign ai flags for player for prediction { - u64 aiFlags = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_POSITION_OPPONENT_LEFT) - | GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_POSITION_OPPONENT_RIGHT); - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_RIGHT] = aiFlags; - gAiThinkingStruct->aiFlags[B_POSITION_PLAYER_LEFT] = aiFlags; + u64 aiFlags = GetAiFlags(TRAINER_BATTLE_PARAM.opponentA, B_BATTLER_1) + | GetAiFlags(TRAINER_BATTLE_PARAM.opponentB, B_BATTLER_3); + gAiThinkingStruct->aiFlags[B_BATTLER_2] = aiFlags; + gAiThinkingStruct->aiFlags[B_BATTLER_0] = aiFlags; } } -void BattleAI_SetupAIData(u8 defaultScoreMoves, u32 battler) +void BattleAI_SetupAIData(u8 defaultScoreMoves, enum BattlerId battler) { u32 moveLimitations; u64 flags[MAX_BATTLERS_COUNT]; @@ -340,7 +340,7 @@ bool32 BattlerChooseNonMoveAction(void) return FALSE; } -void SetupAIPredictionData(u32 battler, enum SwitchType switchType) +void SetupAIPredictionData(enum BattlerId battler, enum SwitchType switchType) { s32 opposingBattler = GetOppositeBattler(battler); gAiLogicData->aiPredictionInProgress = TRUE; @@ -360,7 +360,7 @@ void SetupAIPredictionData(u32 battler, enum SwitchType switchType) gAiLogicData->aiPredictionInProgress = FALSE; } -void ComputeBattlerDecisions(u32 battler) +void ComputeBattlerDecisions(enum BattlerId battler) { bool32 isAiBattler = (gBattleTypeFlags & BATTLE_TYPE_HAS_AI || IsWildMonSmart()) && (BattlerHasAi(battler) && !(gBattleTypeFlags & BATTLE_TYPE_PALACE)); if (isAiBattler || CanAiPredictMove(battler)) @@ -393,7 +393,7 @@ void ComputeBattlerDecisions(u32 battler) } } -void ReconsiderGimmick(u32 battlerAtk, u32 battlerDef, enum Move move) +void ReconsiderGimmick(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { // After choosing a move for battlerAtk assuming that a gimmick will be used, reconsider whether the gimmick is necessary. @@ -404,23 +404,23 @@ void ReconsiderGimmick(u32 battlerAtk, u32 battlerDef, enum Move move) SetAIUsingGimmick(battlerAtk, NO_GIMMICK); } -static u32 ChooseMoveOrAction(u32 battler) +static u32 ChooseMoveOrAction(enum BattlerId battler) { if (IsDoubleBattle()) return ChooseMoveOrAction_Doubles(battler); return ChooseMoveOrAction_Singles(battler); } -static void SetupRandomRollsForAIMoveSelection(u32 battler) +static void SetupRandomRollsForAIMoveSelection(enum BattlerId battler) { gAiLogicData->shouldConsiderExplosion = RandomPercentage(RNG_AI_CONSIDER_EXPLOSION, GetAIExplosionChanceFromHP(gAiLogicData->hpPercents[battler])); gAiLogicData->shouldConsiderFinalGambit = RandomPercentage(RNG_AI_FINAL_GAMBIT, FINAL_GAMBIT_CHANCE); } -void AI_TrySwitchOrUseItem(u32 battler) +void AI_TrySwitchOrUseItem(enum BattlerId battler) { struct Pokemon *party; - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; s32 firstId; s32 lastId; // + 1 party = GetBattlerParty(battler); @@ -469,7 +469,7 @@ void AI_TrySwitchOrUseItem(u32 battler) BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, BATTLE_OPPOSITE(battler) << 8); } -u32 BattleAI_ChooseMoveIndex(u32 battler) +u32 BattleAI_ChooseMoveIndex(enum BattlerId battler) { u32 chosenMoveIndex; @@ -496,7 +496,7 @@ u32 BattleAI_ChooseMoveIndex(u32 battler) static void CopyBattlerDataToAIParty(u32 bPosition, enum BattleSide side) { - u32 battler = GetBattlerAtPosition(bPosition); + enum BattlerId battler = GetBattlerAtPosition(bPosition); struct AiPartyMon *aiMon = &gAiPartyData->mons[side][gBattlerPartyIndexes[battler]]; struct BattlePokemon *bMon = &gBattleMons[battler]; @@ -554,7 +554,7 @@ void Ai_InitPartyStruct(void) } } -void Ai_UpdateSwitchInData(u32 battler) +void Ai_UpdateSwitchInData(enum BattlerId battler) { enum BattleSide side = GetBattlerSide(battler); struct AiPartyMon *aiMon = &gAiPartyData->mons[side][gBattlerPartyIndexes[battler]]; @@ -583,7 +583,7 @@ void Ai_UpdateSwitchInData(u32 battler) } } -void Ai_UpdateFaintData(u32 battler) +void Ai_UpdateFaintData(enum BattlerId battler) { struct AiPartyMon *aiMon = &gAiPartyData->mons[GetBattlerSide(battler)][gBattlerPartyIndexes[battler]]; ClearBattlerMoveHistory(battler); @@ -592,7 +592,7 @@ void Ai_UpdateFaintData(u32 battler) aiMon->isFainted = TRUE; } -void RecordMovesBasedOnStab(u32 battler) +void RecordMovesBasedOnStab(enum BattlerId battler) { for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) { @@ -602,7 +602,7 @@ void RecordMovesBasedOnStab(u32 battler) } } -void RecordStatusMoves(u32 battler) +void RecordStatusMoves(enum BattlerId battler) { for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) { @@ -612,7 +612,7 @@ void RecordStatusMoves(u32 battler) } } -void SetBattlerAiData(u32 battler, struct AiLogicData *aiData) +void SetBattlerAiData(enum BattlerId battler, struct AiLogicData *aiData) { enum Ability ability; enum HoldEffect holdEffect; @@ -634,7 +634,7 @@ void SetBattlerAiData(u32 battler, struct AiLogicData *aiData) } #define BYPASSES_ACCURACY_CALC 101 // 101 indicates for ai that the move will always hit -static u32 Ai_SetMoveAccuracy(struct AiLogicData *aiData, u32 battlerAtk, u32 battlerDef, enum Move move) +static u32 Ai_SetMoveAccuracy(struct AiLogicData *aiData, enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { u32 accuracy; enum Ability abilityAtk = aiData->abilities[battlerAtk]; @@ -655,7 +655,7 @@ static u32 Ai_SetMoveAccuracy(struct AiLogicData *aiData, u32 battlerAtk, u32 ba } #undef BYPASSES_ACCURACY_CALC -void CalcBattlerAiMovesData(struct AiLogicData *aiData, u32 battlerAtk, u32 battlerDef, u32 weather, u32 fieldStatus) +void CalcBattlerAiMovesData(struct AiLogicData *aiData, enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 weather, u32 fieldStatus) { enum Move move; enum Move *moves = GetMovesArray(battlerAtk); @@ -679,13 +679,13 @@ void CalcBattlerAiMovesData(struct AiLogicData *aiData, u32 battlerAtk, u32 batt } } -static void SetBattlerAiMovesData(struct AiLogicData *aiData, u32 battlerAtk, u32 battlersCount, u32 weather) +static void SetBattlerAiMovesData(struct AiLogicData *aiData, enum BattlerId battlerAtk, u32 battlersCount, u32 weather) { SaveBattlerData(battlerAtk); SetBattlerData(battlerAtk); // Simulate dmg for both ai controlled mons and for player controlled mons. - for (u32 battlerDef = 0; battlerDef < battlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < battlersCount; battlerDef++) { if (battlerAtk == battlerDef || !IsBattlerAlive(battlerDef)) continue; @@ -719,7 +719,7 @@ void SetAiLogicDataForTurn(struct AiLogicData *aiData) gAiLogicData->aiCalcInProgress = TRUE; if (DEBUG_AI_DELAY_TIMER) CycleCountStart(); - for (u32 battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) + for (enum BattlerId battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) { if (!IsBattlerAlive(battlerAtk)) continue; @@ -727,7 +727,7 @@ void SetAiLogicDataForTurn(struct AiLogicData *aiData) SetBattlerAiData(battlerAtk, aiData); } - for (u32 battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) + for (enum BattlerId battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) { if (!IsBattlerAlive(battlerAtk)) continue; @@ -735,7 +735,7 @@ void SetAiLogicDataForTurn(struct AiLogicData *aiData) SetBattlerAiMovesData(aiData, battlerAtk, battlersCount, weather); } - for (u32 battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) + for (enum BattlerId battlerAtk = 0; battlerAtk < battlersCount; battlerAtk++) { // Prediction limited to player side but can be expanded to read partners move in the future if (!IsOnPlayerSide(battlerAtk) || !CanAiPredictMove(battlerAtk)) @@ -762,7 +762,7 @@ enum Ability GetPartyMonAbility(struct Pokemon *mon) return ability; } -static u32 PpStallReduction(enum Move move, u32 battlerAtk) +static u32 PpStallReduction(enum Move move, enum BattlerId battlerAtk) { if (move == MOVE_NONE) return 0; @@ -801,13 +801,13 @@ static u32 PpStallReduction(enum Move move, u32 battlerAtk) return returnValue; } -static u32 ChooseMoveOrAction_Singles(u32 battler) +static u32 ChooseMoveOrAction_Singles(enum BattlerId battler) { u8 currentMoveArray[MAX_MON_MOVES]; u8 consideredMoveArray[MAX_MON_MOVES]; u32 numOfBestMoves; u64 flags = gAiThinkingStruct->aiFlags[battler]; - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); gAiThinkingStruct->aiLogicId = 0; gAiThinkingStruct->movesetIndex = 0; @@ -863,7 +863,7 @@ static u32 ChooseMoveOrAction_Singles(u32 battler) return consideredMoveArray[RandomUniform(RNG_AI_SCORE_TIE_SINGLES, 0, numOfBestMoves - 1)]; } -static u32 ChooseMoveOrAction_Doubles(u32 battler) +static u32 ChooseMoveOrAction_Doubles(enum BattlerId battler) { u64 flags; s32 bestMovePointsForTarget[MAX_BATTLERS_COUNT]; @@ -875,7 +875,7 @@ static u32 ChooseMoveOrAction_Doubles(u32 battler) u32 mostViableMovesNo; s32 mostMovePoints; - for (u32 battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) { if (battlerIndex == battler || gBattleMons[battlerIndex].hp == 0) { @@ -960,7 +960,7 @@ static u32 ChooseMoveOrAction_Doubles(u32 battler) mostViableTargetsArray[0] = 0; mostViableTargetsNo = 1; - for (u32 battlerIndex = 1; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) + for (enum BattlerId battlerIndex = 1; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) { if (mostMovePoints == bestMovePointsForTarget[battlerIndex]) { @@ -985,7 +985,7 @@ static u32 ChooseMoveOrAction_Doubles(u32 battler) return actionOrMoveIndex[gBattlerTarget]; } -static inline bool32 ShouldConsiderMoveForBattler(u32 battlerAi, u32 battlerDef, enum Move move) +static inline bool32 ShouldConsiderMoveForBattler(enum BattlerId battlerAi, enum BattlerId battlerDef, enum Move move) { if (battlerAi == BATTLE_PARTNER(battlerDef)) { @@ -996,7 +996,7 @@ static inline bool32 ShouldConsiderMoveForBattler(u32 battlerAi, u32 battlerDef, return TRUE; } -static inline void BattleAI_DoAIProcessing(struct AiThinkingStruct *aiThink, u32 battlerAtk, u32 battlerDef) +static inline void BattleAI_DoAIProcessing(struct AiThinkingStruct *aiThink, enum BattlerId battlerAtk, enum BattlerId battlerDef) { do { @@ -1031,7 +1031,7 @@ static inline void BattleAI_DoAIProcessing(struct AiThinkingStruct *aiThink, u32 aiThink->movesetIndex = 0; } -void BattleAI_DoAIProcessing_PredictedSwitchin(struct AiThinkingStruct *aiThink, struct AiLogicData *aiData, u32 battlerAtk, u32 battlerDef) +void BattleAI_DoAIProcessing_PredictedSwitchin(struct AiThinkingStruct *aiThink, struct AiLogicData *aiData, enum BattlerId battlerAtk, enum BattlerId battlerDef) { struct BattlePokemon switchoutCandidate = gBattleMons[battlerDef]; struct SimulatedDamage simulatedDamageSwitchout[MAX_MON_MOVES]; @@ -1144,7 +1144,7 @@ void BattleAI_DoAIProcessing_PredictedSwitchin(struct AiThinkingStruct *aiThink, // AI Score Functions // AI_FLAG_CHECK_BAD_MOVE - decreases move scores -static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_CheckBadMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (IsTargetingPartner(battlerAtk, battlerDef)) return score; @@ -2540,9 +2540,9 @@ static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, enum Move move, s32 s ADJUST_SCORE(-10); break; case EFFECT_NATURE_POWER: - predictedMove = GetNaturePowerMove(battlerAtk); + predictedMove = GetNaturePowerMove(); if (GetMoveEffect(predictedMove) != GetMoveEffect(move)) - return AI_CheckBadMove(battlerAtk, battlerDef, GetNaturePowerMove(battlerAtk), score); + return AI_CheckBadMove(battlerAtk, battlerDef, GetNaturePowerMove(), score); break; case EFFECT_TAUNT: if (gBattleMons[battlerDef].volatiles.tauntTimer > 0 @@ -3113,7 +3113,7 @@ static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, enum Move move, s32 s return score; } -static s32 AI_GetWhichBattlerFasterOrTies(u32 battlerAtk, u32 battlerDef, bool32 ignoreChosenMoves) +static s32 AI_GetWhichBattlerFasterOrTies(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 ignoreChosenMoves) { struct BattleCalcValues calcValues = {0}; calcValues.battlerAtk = battlerAtk; @@ -3126,7 +3126,7 @@ static s32 AI_GetWhichBattlerFasterOrTies(u32 battlerAtk, u32 battlerDef, bool32 return GetWhichBattlerFasterOrTies(&calcValues, ignoreChosenMoves); } -static s32 AI_TryToFaint(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_TryToFaint(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { u32 movesetIndex = gAiThinkingStruct->movesetIndex; enum Move predictedMoveSpeedCheck = GetIncomingMoveSpeedCheck(battlerAtk, battlerDef, gAiLogicData); @@ -3160,14 +3160,14 @@ static s32 AI_TryToFaint(u32 battlerAtk, u32 battlerDef, enum Move move, s32 sco } // double battle logic -static s32 AI_DoubleBattle(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_DoubleBattle(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { // move data enum Type moveType = GetMoveType(move); enum BattleMoveEffects effect = GetMoveEffect(move); enum MoveTarget moveTarget = AI_GetBattlerMoveTargetType(battlerAtk, move); // ally data - u32 battlerAtkPartner = BATTLE_PARTNER(battlerAtk); + enum BattlerId battlerAtkPartner = BATTLE_PARTNER(battlerAtk); struct AiLogicData *aiData = gAiLogicData; enum Ability atkPartnerAbility = aiData->abilities[BATTLE_PARTNER(battlerAtk)]; enum HoldEffect atkPartnerHoldEffect = aiData->holdEffects[BATTLE_PARTNER(battlerAtk)]; @@ -3918,7 +3918,7 @@ static bool32 IsPinchBerryItemEffect(enum HoldEffect holdEffect) } } -static bool32 DoesAbilityBenefitFromSunOrRain(u32 battler, enum Ability ability, u32 weather) +static bool32 DoesAbilityBenefitFromSunOrRain(enum BattlerId battler, enum Ability ability, u32 weather) { switch (ability) { @@ -3946,7 +3946,7 @@ static bool32 DoesAbilityBenefitFromSunOrRain(u32 battler, enum Ability ability, return FALSE; } -static u32 GetWindAbilityScore(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData) +static u32 GetWindAbilityScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData) { u32 score = 0; @@ -3966,7 +3966,7 @@ static u32 GetWindAbilityScore(u32 battlerAtk, u32 battlerDef, struct AiLogicDat return score; } -static enum MoveComparisonResult CompareMoveAccuracies(u32 battlerAtk, u32 battlerDef, u32 moveSlot1, u32 moveSlot2) +static enum MoveComparisonResult CompareMoveAccuracies(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveSlot1, u32 moveSlot2) { u32 acc1 = gAiLogicData->moveAccuracy[battlerAtk][battlerDef][moveSlot1]; u32 acc2 = gAiLogicData->moveAccuracy[battlerAtk][battlerDef][moveSlot2]; @@ -3978,7 +3978,7 @@ static enum MoveComparisonResult CompareMoveAccuracies(u32 battlerAtk, u32 battl return MOVE_NEUTRAL_COMPARISON; } -static enum MoveComparisonResult CompareMoveSpeeds(u32 battlerAtk, u32 battlerDef, bool32 move1Faster, bool32 move2Faster) +static enum MoveComparisonResult CompareMoveSpeeds(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 move1Faster, bool32 move2Faster) { if (move1Faster && !move2Faster) return MOVE_WON_COMPARISON; @@ -3987,7 +3987,7 @@ static enum MoveComparisonResult CompareMoveSpeeds(u32 battlerAtk, u32 battlerDe return MOVE_NEUTRAL_COMPARISON; } -static enum MoveComparisonResult CompareGuaranteeFaintTarget(u32 battlerAtk, u32 battlerDef, u16 moveSlot1, u16 moveSlot2, u16 *moves) +static enum MoveComparisonResult CompareGuaranteeFaintTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef, u16 moveSlot1, u16 moveSlot2, u16 *moves) { s32 dmg1, dmg2; bool32 guarantee1, guarantee2; @@ -4008,7 +4008,7 @@ static enum MoveComparisonResult CompareGuaranteeFaintTarget(u32 battlerAtk, u32 return MOVE_NEUTRAL_COMPARISON; } -static enum MoveComparisonResult CompareResistBerryEffects(u32 battlerAtk, u32 battlerDef, u32 moveSlot1, u32 moveSlot2) +static enum MoveComparisonResult CompareResistBerryEffects(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveSlot1, u32 moveSlot2) { // Check for resist berries in OHKOs if (gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_RESIST_BERRY) @@ -4023,7 +4023,7 @@ static enum MoveComparisonResult CompareResistBerryEffects(u32 battlerAtk, u32 b return MOVE_NEUTRAL_COMPARISON; } -static enum MoveComparisonResult CompareMoveSelfSacrifice(u32 battlerAtk, u32 battlerDef, enum Move move1, enum Move move2) +static enum MoveComparisonResult CompareMoveSelfSacrifice(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move1, enum Move move2) { bool32 selfSacrifice1 = IsSelfSacrificeEffect(move1); bool32 selfSacrifice2 = IsSelfSacrificeEffect(move2); @@ -4035,7 +4035,7 @@ static enum MoveComparisonResult CompareMoveSelfSacrifice(u32 battlerAtk, u32 ba return MOVE_NEUTRAL_COMPARISON; } -static enum MoveComparisonResult CompareMoveTwoTurnEffect(u32 battlerAtk, enum Move move1, enum Move move2) +static enum MoveComparisonResult CompareMoveTwoTurnEffect(enum BattlerId battlerAtk, enum Move move1, enum Move move2) { bool32 twoTurn1 = IsTwoTurnNotSemiInvulnerableMove(battlerAtk, move1); bool32 twoTurn2 = IsTwoTurnNotSemiInvulnerableMove(battlerAtk, move2); @@ -4047,9 +4047,9 @@ static enum MoveComparisonResult CompareMoveTwoTurnEffect(u32 battlerAtk, enum M return MOVE_NEUTRAL_COMPARISON; } -static inline bool32 ShouldUseSpreadDamageMove(u32 battlerAtk, enum Move move, u32 moveIndex, u32 hitsToFaintOpposingBattler) +static inline bool32 ShouldUseSpreadDamageMove(enum BattlerId battlerAtk, enum Move move, u32 moveIndex, u32 hitsToFaintOpposingBattler) { - u32 partnerBattler = BATTLE_PARTNER(battlerAtk); + enum BattlerId partnerBattler = BATTLE_PARTNER(battlerAtk); u32 noOfHitsToFaintPartner = GetNoOfHitsToKOBattler(battlerAtk, partnerBattler, moveIndex, AI_ATTACKING, CONSIDER_ENDURE); u32 friendlyFireThreshold = GetFriendlyFireKOThreshold(battlerAtk); return (HasPartnerIgnoreFlags(battlerAtk) @@ -4059,7 +4059,7 @@ static inline bool32 ShouldUseSpreadDamageMove(u32 battlerAtk, enum Move move, u && noOfHitsToFaintPartner < (friendlyFireThreshold * 2)); } -static bool32 ShouldCompareMove(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum Move move) +static bool32 ShouldCompareMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum Move move) { if (IsTargetingPartner(battlerAtk, battlerDef)) return FALSE; @@ -4072,7 +4072,7 @@ static bool32 ShouldCompareMove(u32 battlerAtk, u32 battlerDef, u32 moveIndex, e return TRUE; } -static void AI_CompareDamagingMoves(u32 battlerAtk, u32 battlerDef) +static void AI_CompareDamagingMoves(enum BattlerId battlerAtk, enum BattlerId battlerDef) { u32 tempMoveScores[MAX_MON_MOVES]; u32 moveComparisonScores[MAX_MON_MOVES]; @@ -4246,7 +4246,7 @@ static void AI_CompareDamagingMoves(u32 battlerAtk, u32 battlerDef) } } -static s32 AI_CalcHoldEffectMoveScore(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +static s32 AI_CalcHoldEffectMoveScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { enum HoldEffect holdEffect = aiData->holdEffects[battlerAtk]; @@ -4275,7 +4275,7 @@ static s32 AI_CalcHoldEffectMoveScore(u32 battlerAtk, u32 battlerDef, enum Move return score; } -static s32 AI_CalcMoveEffectScore(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +static s32 AI_CalcMoveEffectScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { // move data enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -5847,7 +5847,7 @@ static s32 AI_CalcMoveEffectScore(u32 battlerAtk, u32 battlerDef, enum Move move return score; } -static s32 AI_CalcAdditionalEffectScore(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +static s32 AI_CalcAdditionalEffectScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { // move data s32 score = 0; @@ -6201,7 +6201,7 @@ static s32 AI_CalcAdditionalEffectScore(u32 battlerAtk, u32 battlerDef, enum Mov } // AI_FLAG_CHECK_VIABILITY - Chooses best possible move to hit player -static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_CheckViability(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { struct AiLogicData *aiData = gAiLogicData; @@ -6229,7 +6229,7 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, enum Move move, s32 } // Effects that are encouraged on the first turn of battle -static s32 AI_ForceSetupFirstTurn(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_ForceSetupFirstTurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (IsTargetingPartner(battlerAtk, battlerDef) || gBattleResults.battleTurnCounter != 0) @@ -6337,7 +6337,7 @@ static s32 AI_ForceSetupFirstTurn(u32 battlerAtk, u32 battlerDef, enum Move move } // Adds score bonus to 'riskier' move effects and high crit moves -static s32 AI_Risky(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_Risky(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { struct AiLogicData *aiData = gAiLogicData; @@ -6413,7 +6413,7 @@ static s32 AI_Risky(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) } // Adds score bonus to OHKOs and 2HKOs -static s32 AI_TryTo2HKO(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_TryTo2HKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (IsTargetingPartner(battlerAtk, battlerDef)) return score; @@ -6427,7 +6427,7 @@ static s32 AI_TryTo2HKO(u32 battlerAtk, u32 battlerDef, enum Move move, s32 scor } // Adds score bonus to targeting "partner" -static s32 AI_AttacksPartner(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_AttacksPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (battlerDef == BATTLE_PARTNER(battlerAtk) // natural enemies in wild battles try to kill each other @@ -6452,7 +6452,7 @@ static s32 AI_AttacksPartner(u32 battlerAtk, u32 battlerDef, enum Move move, s32 } // Prefers moves that are good for baton pass -static s32 AI_PreferBatonPass(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_PreferBatonPass(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (IsTargetingPartner(battlerAtk, battlerDef) || CountUsablePartyMons(battlerAtk) == 0 @@ -6504,7 +6504,7 @@ static s32 AI_PreferBatonPass(u32 battlerAtk, u32 battlerDef, enum Move move, s3 return score; } -static s32 AI_HPAware(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_HPAware(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { enum BattleMoveEffects effect = GetMoveEffect(move); enum Type moveType = 0; @@ -6702,7 +6702,7 @@ static s32 AI_HPAware(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) return score; } -static s32 AI_PowerfulStatus(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_PowerfulStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -6814,7 +6814,7 @@ bool32 DoesSideHaveDamagingHazards(enum BattleSide side) return FALSE; } -static s32 AI_PredictSwitch(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_PredictSwitch(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { u32 unmodifiedScore = score; enum Ability ability = gBattleMons[battlerAtk].ability; @@ -6968,7 +6968,7 @@ static s32 AI_PredictSwitch(u32 battlerAtk, u32 battlerDef, enum Move move, s32 return score; } -static s32 AI_CheckPpStall(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_CheckPpStall(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (!IsOnPlayerSide(battlerAtk)) score -= PpStallReduction(move, battlerAtk); @@ -6986,7 +6986,7 @@ static void AI_Watch(void) } // Roaming pokemon logic -static s32 AI_Roaming(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_Roaming(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { bool32 roamerCanFlee = FALSE; @@ -7005,7 +7005,7 @@ static s32 AI_Roaming(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) } // Safari pokemon logic -static s32 AI_Safari(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_Safari(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { u32 safariFleeRate = gBattleStruct->safariEscapeFactor * 5; // Safari flee rate, from 0-20. @@ -7018,7 +7018,7 @@ static s32 AI_Safari(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) } // First battle logic -static s32 AI_FirstBattle(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_FirstBattle(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (gAiLogicData->hpPercents[battlerDef] <= 20) AI_Flee(); @@ -7030,7 +7030,7 @@ static s32 AI_FirstBattle(u32 battlerAtk, u32 battlerDef, enum Move move, s32 sc // For specific battle scenarios // Example - prefer attacking opposite foe in a tag battle -s32 AI_TagBattlePreferFoe(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +s32 AI_TagBattlePreferFoe(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (!(gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)) { @@ -7051,7 +7051,7 @@ s32 AI_TagBattlePreferFoe(u32 battlerAtk, u32 battlerDef, enum Move move, s32 sc return score; } -static s32 AI_DynamicFunc(u32 battlerAtk, u32 battlerDef, enum Move move, s32 score) +static s32 AI_DynamicFunc(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 score) { if (sDynamicAiFunc != NULL) score = sDynamicAiFunc(battlerAtk, battlerDef, move, score); diff --git a/src/battle_ai_switch.c b/src/battle_ai_switch.c index 5393f84172..8727099d8f 100644 --- a/src/battle_ai_switch.c +++ b/src/battle_ai_switch.c @@ -32,23 +32,23 @@ struct IncomingHealInfo u16 healEndOfTurn:1; u16 curesStatus:1; }; -static bool32 CanUseSuperEffectiveMoveAgainstOpponents(u32 battler); -static bool32 FindMonWithFlagsAndSuperEffective(u32 battler, u16 flags, u32 moduloPercent); -static u32 GetSwitchinHazardsDamage(u32 battler); -static bool32 AI_CanSwitchinAbilityTrapOpponent(enum Ability ability, u32 opponent); -static u32 GetBattlerTypeMatchup(u32 opposingBattler, u32 battler); -static u32 GetSwitchinHitsToKO(s32 damageTaken, u32 battler, const struct IncomingHealInfo *healInfo, u32 originalHp); -static void GetIncomingHealInfo(u32 battler, struct IncomingHealInfo *healInfo); -static u32 GetWishHealAmountForBattler(u32 battler); +static bool32 CanUseSuperEffectiveMoveAgainstOpponents(enum BattlerId battler); +static bool32 FindMonWithFlagsAndSuperEffective(enum BattlerId battler, u16 flags, u32 moduloPercent); +static u32 GetSwitchinHazardsDamage(enum BattlerId battler); +static bool32 AI_CanSwitchinAbilityTrapOpponent(enum Ability ability, enum BattlerId opposingBattler); +static u32 GetBattlerTypeMatchup(enum BattlerId opposingBattler, enum BattlerId battler); +static u32 GetSwitchinHitsToKO(s32 damageTaken, enum BattlerId battler, const struct IncomingHealInfo *healInfo, u32 originalHp); +static void GetIncomingHealInfo(enum BattlerId battler, struct IncomingHealInfo *healInfo); +static u32 GetWishHealAmountForBattler(enum BattlerId battler); -static void InitializeSwitchinCandidate(u32 switchinBattler, struct Pokemon *mon) +static void InitializeSwitchinCandidate(enum BattlerId switchinBattler, struct Pokemon *mon) { PokemonToBattleMon(mon, &gBattleMons[switchinBattler]); // Setup switchin battler data gAiThinkingStruct->saved[switchinBattler].saved = TRUE; SetBattlerAiData(switchinBattler, gAiLogicData); SetBattlerFieldStatusForSwitchin(switchinBattler); - for (u32 battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) { if (switchinBattler == battlerIndex || !IsBattlerAlive(battlerIndex)) continue; @@ -60,7 +60,7 @@ static void InitializeSwitchinCandidate(u32 switchinBattler, struct Pokemon *mon gAiThinkingStruct->saved[switchinBattler].saved = FALSE; } -static u32 GetWishHealAmountForBattler(u32 battler) +static u32 GetWishHealAmountForBattler(enum BattlerId battler) { u32 wishHeal = 0; @@ -82,7 +82,7 @@ static u32 GetWishHealAmountForBattler(u32 battler) return wishHeal; } -static void GetIncomingHealInfo(u32 battler, struct IncomingHealInfo *healInfo) +static void GetIncomingHealInfo(enum BattlerId battler, struct IncomingHealInfo *healInfo) { memset(healInfo, 0, sizeof(*healInfo)); @@ -189,7 +189,7 @@ u32 GetSwitchChance(enum ShouldSwitchScenario shouldSwitchScenario) } } -bool32 IsAceMon(u32 battler, u32 monPartyId) +bool32 IsAceMon(enum BattlerId battler, u32 monPartyId) { if (gAiThinkingStruct->aiFlags[battler] & AI_FLAG_ACE_POKEMON && !gProtectStructs[battler].forcedSwitch @@ -202,7 +202,7 @@ bool32 IsAceMon(u32 battler, u32 monPartyId) return FALSE; } -static bool32 AreStatsRaised(u32 battler) +static bool32 AreStatsRaised(enum BattlerId battler) { u8 buffedStatsValue = 0; @@ -215,13 +215,13 @@ static bool32 AreStatsRaised(u32 battler) return (buffedStatsValue > STAY_IN_STATS_RAISED); } -static inline bool32 SetSwitchinAndSwitch(u32 battler, u32 switchinId) +static inline bool32 SetSwitchinAndSwitch(enum BattlerId battler, u32 switchinId) { gBattleStruct->AI_monToSwitchIntoId[battler] = switchinId; return TRUE; } -static bool32 AI_DoesChoiceEffectBlockMove(u32 battler, enum Move move) +static bool32 AI_DoesChoiceEffectBlockMove(enum BattlerId battler, enum Move move) { // Choice locked into something else if (gAiLogicData->lastUsedMove[battler] != MOVE_NONE && gAiLogicData->lastUsedMove[battler] != move @@ -262,11 +262,11 @@ static inline bool32 CanBattlerWin1v1(u32 hitsToKOAI, u32 hitsToKOPlayer, bool32 // Note that as many return statements as possible are INTENTIONALLY put after all of the loops; // the function can take a max of about 0.06s to run, and this prevents the player from identifying // whether the mon will switch or not by seeing how long the delay is before they select a move -static bool32 ShouldSwitchIfHasBadOdds(u32 battler) +static bool32 ShouldSwitchIfHasBadOdds(enum BattlerId battler) { //Variable initialization enum BattlerPosition opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); - u32 opposingBattler = GetBattlerAtPosition(opposingPosition); + enum BattlerId opposingBattler = GetBattlerAtPosition(opposingPosition); enum Move *playerMoves = GetMovesArray(opposingBattler); enum Move aiMove, playerMove, bestPlayerPriorityMove = MOVE_NONE, bestPlayerMove = MOVE_NONE, expectedMove = MOVE_NONE; enum Ability aiAbility = gAiLogicData->abilities[battler]; @@ -394,7 +394,7 @@ static bool32 ShouldSwitchIfHasBadOdds(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfTruant(u32 battler) +static bool32 ShouldSwitchIfTruant(enum BattlerId battler) { // Switch if mon with truant is bodied by Protect or invulnerability spam if (gAiLogicData->abilities[battler] == ABILITY_TRUANT @@ -409,7 +409,7 @@ static bool32 ShouldSwitchIfTruant(u32 battler) return FALSE; } -static u32 FindMonWithMoveOfEffectiveness(u32 battler, u32 opposingBattler, uq4_12_t effectiveness) +static u32 FindMonWithMoveOfEffectiveness(enum BattlerId battler, enum BattlerId opposingBattler, uq4_12_t effectiveness) { enum Move move; s32 firstId; @@ -441,16 +441,16 @@ static u32 FindMonWithMoveOfEffectiveness(u32 battler, u32 opposingBattler, uq4_ return FALSE; // There is not a single Pokémon in the party that has a move with this effectiveness threshold } -static bool32 ShouldSwitchIfAllMovesBad(u32 battler) +static bool32 ShouldSwitchIfAllMovesBad(enum BattlerId battler) { u32 moveIndex; - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); enum Move aiMove; // Switch if no moves affect opponents if (IsDoubleBattle()) { - u32 opposingPartner = BATTLE_PARTNER(opposingBattler); + enum BattlerId opposingPartner = BATTLE_PARTNER(opposingBattler); for (moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) { aiMove = gBattleMons[battler].moves[moveIndex]; @@ -494,9 +494,9 @@ static bool32 ShouldSwitchIfAllMovesBad(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfWonderGuard(u32 battler) +static bool32 ShouldSwitchIfWonderGuard(enum BattlerId battler) { - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); if (IsDoubleBattle()) return FALSE; @@ -522,9 +522,9 @@ static bool32 ShouldSwitchIfWonderGuard(u32 battler) return FALSE; } -static bool32 FindMonThatAbsorbsOpponentsMove(u32 battler) +static bool32 FindMonThatAbsorbsOpponentsMove(enum BattlerId battler) { - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; u8 numAbsorbingAbilities = 0; enum Ability absorbingTypeAbilities[8]; // Max needed for type + move property absorbers s32 firstId; @@ -532,7 +532,7 @@ static bool32 FindMonThatAbsorbsOpponentsMove(u32 battler) struct Pokemon *party; enum Ability monAbility; enum Move aiMove; - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); enum Move incomingMove = GetIncomingMove(battler, opposingBattler, gAiLogicData); enum Type incomingType = CheckDynamicMoveType(GetBattlerMon(opposingBattler), incomingMove, opposingBattler, MON_IN_BATTLE); bool32 isOpposingBattlerChargingOrInvulnerable = !BreaksThroughSemiInvulnerablity(battler, opposingBattler, gAiLogicData->abilities[battler], gAiLogicData->abilities[opposingBattler], incomingMove) || IsTwoTurnNotSemiInvulnerableMove(opposingBattler, incomingMove); @@ -654,9 +654,9 @@ static bool32 FindMonThatAbsorbsOpponentsMove(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfOpponentChargingOrInvulnerable(u32 battler) +static bool32 ShouldSwitchIfOpponentChargingOrInvulnerable(enum BattlerId battler) { - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); enum Move incomingMove = GetIncomingMove(battler, opposingBattler, gAiLogicData); bool32 isOpposingBattlerChargingOrInvulnerable = !BreaksThroughSemiInvulnerablity(battler, opposingBattler, gAiLogicData->abilities[battler], gAiLogicData->abilities[opposingBattler], incomingMove) || IsTwoTurnNotSemiInvulnerableMove(opposingBattler, incomingMove); @@ -671,7 +671,7 @@ static bool32 ShouldSwitchIfOpponentChargingOrInvulnerable(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfTrapperInParty(u32 battler) +static bool32 ShouldSwitchIfTrapperInParty(enum BattlerId battler) { s32 firstId; s32 lastId; @@ -708,13 +708,13 @@ static bool32 ShouldSwitchIfTrapperInParty(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfBadlyStatused(u32 battler) +static bool32 ShouldSwitchIfBadlyStatused(enum BattlerId battler) { bool32 switchMon = FALSE; enum Ability monAbility = gAiLogicData->abilities[battler]; enum HoldEffect holdEffect = gAiLogicData->holdEffects[battler]; enum BattlerPosition opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); - u8 opposingBattler = GetBattlerAtPosition(opposingPosition); + enum BattlerId opposingBattler = GetBattlerAtPosition(opposingPosition); bool32 hasStatRaised = AnyUsefulStatIsRaised(battler); //Perish Song @@ -808,7 +808,7 @@ static bool32 ShouldSwitchIfBadlyStatused(u32 battler) return FALSE; } -static bool32 GetHitEscapeTransformState(u32 battlerAtk, enum Move move) +static bool32 GetHitEscapeTransformState(enum BattlerId battlerAtk, enum Move move) { u32 moveIndex; bool32 hasValidTarget = FALSE; @@ -841,7 +841,7 @@ static bool32 GetHitEscapeTransformState(u32 battlerAtk, enum Move move) ctx.abilityAtk = gAiLogicData->abilities[battlerAtk]; - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (!IsBattlerAlive(battlerDef) || IsBattlerAlly(battlerDef, battlerAtk)) continue; @@ -883,7 +883,7 @@ static bool32 GetHitEscapeTransformState(u32 battlerAtk, enum Move move) return isFasterThanAll; } -static bool32 ShouldSwitchIfAbilityBenefit(u32 battler) +static bool32 ShouldSwitchIfAbilityBenefit(enum BattlerId battler) { bool32 hasStatRaised = AnyUsefulStatIsRaised(battler); @@ -948,7 +948,7 @@ static bool32 ShouldSwitchIfAbilityBenefit(u32 battler) return SetSwitchinAndSwitch(battler, PARTY_SIZE); } -static bool32 CanUseSuperEffectiveMoveAgainstOpponent(u32 battler, u32 opposingBattler) +static bool32 CanUseSuperEffectiveMoveAgainstOpponent(enum BattlerId battler, enum BattlerId opposingBattler) { enum Move move; @@ -967,23 +967,23 @@ static bool32 CanUseSuperEffectiveMoveAgainstOpponent(u32 battler, u32 opposingB return FALSE; } -static bool32 CanUseSuperEffectiveMoveAgainstOpponents(u32 battler) +static bool32 CanUseSuperEffectiveMoveAgainstOpponents(enum BattlerId battler) { - u32 opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battler)); - u32 opposingBattler = GetBattlerAtPosition(opposingPosition); + enum BattlerPosition opposingPosition = GetBattlerPosition(BATTLE_OPPOSITE(battler)); + enum BattlerId opposingBattler = GetBattlerAtPosition(opposingPosition); if (CanUseSuperEffectiveMoveAgainstOpponent(battler, opposingBattler)) return TRUE; - if (IsDoubleBattle() && CanUseSuperEffectiveMoveAgainstOpponent(battler, BATTLE_PARTNER(opposingPosition))) + if (IsDoubleBattle() && CanUseSuperEffectiveMoveAgainstOpponent(battler, BATTLE_PARTNER(BATTLE_OPPOSITE(battler)))) return TRUE; return FALSE; } -static bool32 FindMonWithFlagsAndSuperEffective(u32 battler, u16 flags, u32 percentChance) +static bool32 FindMonWithFlagsAndSuperEffective(enum BattlerId battler, u16 flags, u32 percentChance) { - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; s32 firstId; s32 lastId; // + 1 struct Pokemon *party; @@ -1044,9 +1044,9 @@ static bool32 FindMonWithFlagsAndSuperEffective(u32 battler, u16 flags, u32 perc return FALSE; } -static bool32 CanMonSurviveHazardSwitchin(u32 battler) +static bool32 CanMonSurviveHazardSwitchin(enum BattlerId battler) { - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; u32 hazardDamage = 0, battlerHp = gBattleMons[battler].hp; enum Ability ability = gAiLogicData->abilities[battler]; enum Move aiMove; @@ -1087,10 +1087,10 @@ static bool32 CanMonSurviveHazardSwitchin(u32 battler) return TRUE; } -static bool32 ShouldSwitchIfEncored(u32 battler) +static bool32 ShouldSwitchIfEncored(enum BattlerId battler) { enum Move encoredMove = gBattleMons[battler].volatiles.encoredMove; - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); // Only use this if AI_FLAG_SMART_SWITCHING is set for the trainer if (!(gAiThinkingStruct->aiFlags[battler] & AI_FLAG_SMART_SWITCHING)) @@ -1115,10 +1115,10 @@ static bool32 ShouldSwitchIfEncored(u32 battler) return FALSE; } -static bool32 ShouldSwitchIfBadChoiceLock(u32 battler) +static bool32 ShouldSwitchIfBadChoiceLock(enum BattlerId battler) { enum Move lastUsedMove = gAiLogicData->lastUsedMove[battler]; - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); bool32 moveAffectsTarget = TRUE; struct BattleContext ctx = {0}; @@ -1145,7 +1145,7 @@ static bool32 ShouldSwitchIfBadChoiceLock(u32 battler) } // AI should switch if it's become setup fodder and has something better to switch to -static bool32 ShouldSwitchIfAttackingStatsLowered(u32 battler) +static bool32 ShouldSwitchIfAttackingStatsLowered(enum BattlerId battler) { s8 attackingStage = gBattleMons[battler].statStages[STAT_ATK]; s8 spAttackingStage = gBattleMons[battler].statStages[STAT_SPATK]; @@ -1190,7 +1190,7 @@ static bool32 ShouldSwitchIfAttackingStatsLowered(u32 battler) return FALSE; } -bool32 ShouldSwitchDynFuncExample(u32 battler) +bool32 ShouldSwitchDynFuncExample(enum BattlerId battler) { // Chance to switch if trainer class is Guitarist, perhaps thematic for Jugglers if (GetTrainerClassFromId(TRAINER_BATTLE_PARAM.opponentA) == TRAINER_CLASS_GUITARIST @@ -1201,7 +1201,7 @@ bool32 ShouldSwitchDynFuncExample(u32 battler) return FALSE; } -static bool32 CanBattlerConsiderSwitch(u32 battler) +static bool32 CanBattlerConsiderSwitch(enum BattlerId battler) { if (gBattleMons[battler].volatiles.wrapped) return FALSE; @@ -1218,9 +1218,9 @@ static bool32 CanBattlerConsiderSwitch(u32 battler) return TRUE; } -bool32 ShouldSwitch(u32 battler) +bool32 ShouldSwitch(enum BattlerId battler) { - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; s32 firstId; s32 lastId; // + 1 struct Pokemon *party; @@ -1311,7 +1311,7 @@ bool32 ShouldSwitch(u32 battler) return FALSE; } -bool32 ShouldSwitchIfAllScoresBad(u32 battler) +bool32 ShouldSwitchIfAllScoresBad(enum BattlerId battler) { u32 score, opposingBattler = GetOppositeBattler(battler); if (!(gAiThinkingStruct->aiFlags[battler] & AI_FLAG_SMART_SWITCHING)) @@ -1329,7 +1329,7 @@ bool32 ShouldSwitchIfAllScoresBad(u32 battler) return FALSE; } -bool32 ShouldStayInToUseMove(u32 battler) +bool32 ShouldStayInToUseMove(enum BattlerId battler) { enum Move aiMove; u32 opposingBattler = GetOppositeBattler(battler); @@ -1354,9 +1354,9 @@ bool32 ShouldStayInToUseMove(u32 battler) return FALSE; } -void ModifySwitchAfterMoveScoring(u32 battler) +void ModifySwitchAfterMoveScoring(enum BattlerId battler) { - u32 battlerIn1, battlerIn2; + enum BattlerId battlerIn1, battlerIn2; s32 firstId; s32 lastId; // + 1 struct Pokemon *party; @@ -1402,12 +1402,12 @@ void ModifySwitchAfterMoveScoring(u32 battler) gAiLogicData->shouldSwitch &= ~(1u << battler); } -bool32 IsSwitchinValid(u32 battler) +bool32 IsSwitchinValid(enum BattlerId battler) { // Edge case: See if partner already chose to switch into the same mon if (IsDoubleBattle()) { - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId partner = BATTLE_PARTNER(battler); if (gBattleStruct->AI_monToSwitchIntoId[battler] == PARTY_SIZE) // Generic switch { if ((gAiLogicData->shouldSwitch & (1u << partner)) && gAiLogicData->monToSwitchInId[partner] == gAiLogicData->mostSuitableMonId[battler]) @@ -1427,7 +1427,7 @@ bool32 IsSwitchinValid(u32 battler) } // Gets hazard damage -static u32 GetSwitchinHazardsDamage(u32 battler) +static u32 GetSwitchinHazardsDamage(enum BattlerId battler) { u8 tSpikesLayers; enum HoldEffect heldItemEffect = gAiLogicData->holdEffects[battler]; @@ -1486,7 +1486,7 @@ static u32 GetSwitchinHazardsDamage(u32 battler) } // Gets damage / healing from weather -static s32 GetSwitchinWeatherImpact(u32 battler) +static s32 GetSwitchinWeatherImpact(enum BattlerId battler) { s32 weatherImpact = 0, maxHP = gBattleMons[battler].maxHP; enum Ability ability = gAiLogicData->abilities[battler]; @@ -1549,7 +1549,7 @@ static s32 GetSwitchinWeatherImpact(u32 battler) } // Gets one turn of recurring healing -static u32 GetSwitchinRecurringHealing(u32 battler) +static u32 GetSwitchinRecurringHealing(enum BattlerId battler) { u32 recurringHealing = 0, maxHP = gBattleMons[battler].maxHP; enum Ability ability = gAiLogicData->abilities[battler]; @@ -1584,7 +1584,7 @@ static u32 GetSwitchinRecurringHealing(u32 battler) } // Gets one turn of recurring damage -static u32 GetSwitchinRecurringDamage(u32 battler) +static u32 GetSwitchinRecurringDamage(enum BattlerId battler) { u32 passiveDamage = 0, maxHP = gBattleMons[battler].maxHP; enum Ability ability = gAiLogicData->abilities[battler]; @@ -1616,7 +1616,7 @@ static u32 GetSwitchinRecurringDamage(u32 battler) } // Gets one turn of status damage -static u32 GetSwitchinStatusDamage(u32 battler) +static u32 GetSwitchinStatusDamage(enum BattlerId battler) { u8 tSpikesLayers = gSideTimers[GetBattlerSide(battler)].toxicSpikesAmount; enum HoldEffect heldItemEffect = gAiLogicData->holdEffects[battler]; @@ -1689,7 +1689,7 @@ static u32 GetSwitchinStatusDamage(u32 battler) } // Gets number of hits to KO factoring in hazards, healing held items, status, weather, and incoming heals -static u32 GetSwitchinHitsToKO(s32 damageTaken, u32 battler, const struct IncomingHealInfo *healInfo, u32 originalHp) +static u32 GetSwitchinHitsToKO(s32 damageTaken, enum BattlerId battler, const struct IncomingHealInfo *healInfo, u32 originalHp) { u32 hazardDamage = GetSwitchinHazardsDamage(battler); u32 hazardCheckHp = healInfo->healBeforeHazards ? gBattleMons[battler].maxHP : gBattleMons[battler].hp; @@ -1716,7 +1716,7 @@ static u32 GetSwitchinHitsToKO(s32 damageTaken, u32 battler, const struct Incomi u32 hitsToKO = 0; u16 maxHP = gBattleMons[battler].maxHP, item = gAiLogicData->items[battler], heldItemEffect = GetItemHoldEffect(item); u8 weatherDuration = gBattleStruct->weatherDuration, holdEffectParam = GetItemHoldEffectParam(item); - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); enum Ability opposingAbility = gAiLogicData->abilities[opposingBattler], ability = gAiLogicData->abilities[battler]; bool32 usedSingleUseHealingItem = FALSE, opponentCanBreakMold = IsMoldBreakerTypeAbility(opposingBattler, opposingAbility); s32 currentHP = startingHP, singleUseItemHeal = 0; @@ -1822,7 +1822,7 @@ static u32 GetSwitchinHitsToKO(s32 damageTaken, u32 battler, const struct Incomi return hitsToKO; } -static u32 GetBattlerTypeMatchup(u32 opposingBattler, u32 battler) +static u32 GetBattlerTypeMatchup(enum BattlerId opposingBattler, enum BattlerId battler) { // Check type matchup uq4_12_t typeEffectiveness1 = UQ_4_12(1.0), typeEffectiveness2 = UQ_4_12(1.0); @@ -1852,7 +1852,7 @@ static u32 GetBattlerTypeMatchup(u32 opposingBattler, u32 battler) return typeEffectiveness1 + typeEffectiveness2; } -static u32 GetSwitchinCandidate(u32 switchinCategory, u32 battler, int firstId, int lastId, enum SwitchType switchType) +static u32 GetSwitchinCandidate(u32 switchinCategory, enum BattlerId battler, int firstId, int lastId, enum SwitchType switchType) { if (switchinCategory == 0) return PARTY_SIZE; @@ -1877,7 +1877,7 @@ static u32 GetSwitchinCandidate(u32 switchinCategory, u32 battler, int firstId, return PARTY_SIZE; } -static u32 GetValidSwitchinCandidate(u32 validMonIds, u32 battler, u32 firstId, u32 lastId, enum SwitchType switchType) +static u32 GetValidSwitchinCandidate(u32 validMonIds, enum BattlerId battler, u32 firstId, u32 lastId, enum SwitchType switchType) { if (validMonIds == 0) return PARTY_SIZE; @@ -1902,7 +1902,7 @@ static u32 GetValidSwitchinCandidate(u32 validMonIds, u32 battler, u32 firstId, return PARTY_SIZE; } -static s32 GetMaxDamagePlayerCouldDealToSwitchin(u32 battler, u32 opposingBattler, enum Move *bestPlayerMove) +static s32 GetMaxDamagePlayerCouldDealToSwitchin(enum BattlerId battler, enum BattlerId opposingBattler, enum Move *bestPlayerMove) { enum Move playerMove; enum Move *playerMoves = GetMovesArray(opposingBattler); @@ -1929,7 +1929,7 @@ static s32 GetMaxDamagePlayerCouldDealToSwitchin(u32 battler, u32 opposingBattle return maxDamageTaken; } -static s32 GetMaxPriorityDamagePlayerCouldDealToSwitchin(u32 battler, u32 opposingBattler, enum Move *bestPlayerPriorityMove) +static s32 GetMaxPriorityDamagePlayerCouldDealToSwitchin(enum BattlerId battler, enum BattlerId opposingBattler, enum Move *bestPlayerPriorityMove) { enum Move playerMove; enum Move *playerMoves = GetMovesArray(opposingBattler); @@ -1960,7 +1960,7 @@ static s32 GetMaxPriorityDamagePlayerCouldDealToSwitchin(u32 battler, u32 opposi return maxDamageTaken; } -static bool32 AI_CanSwitchinAbilityTrapOpponent(enum Ability ability, u32 opposingBattler) +static bool32 AI_CanSwitchinAbilityTrapOpponent(enum Ability ability, enum BattlerId opposingBattler) { if (AI_CanBattlerEscape(opposingBattler)) return FALSE; @@ -1981,7 +1981,7 @@ static bool32 AI_CanSwitchinAbilityTrapOpponent(enum Ability ability, u32 opposi return FALSE; } -static inline bool32 IsFreeSwitch(enum SwitchType switchType, u32 battlerSwitchingOut, u32 opposingBattler) +static inline bool32 IsFreeSwitch(enum SwitchType switchType, enum BattlerId battlerSwitchingOut, enum BattlerId opposingBattler) { bool32 movedSecond = GetBattlerTurnOrderNum(battlerSwitchingOut) > GetBattlerTurnOrderNum(opposingBattler) ? TRUE : FALSE; @@ -2038,7 +2038,7 @@ static inline bool32 CanSwitchinWin1v1(u32 hitsToKOAI, u32 hitsToKOPlayer, bool3 // This function splits switching behaviour depending on whether the switch is free. // Everything runs in the same loop to minimize computation time. This makes it harder to read, but hopefully the comments can guide you! -static u32 GetBestMonIntegrated(struct Pokemon *party, int firstId, int lastId, u32 battler, u32 opposingBattler, u32 battlerIn1, u32 battlerIn2, enum SwitchType switchType) +static u32 GetBestMonIntegrated(struct Pokemon *party, int firstId, int lastId, enum BattlerId battler, enum BattlerId opposingBattler, enum BattlerId battlerIn1, enum BattlerId battlerIn2, enum SwitchType switchType) { struct IncomingHealInfo healInfoData; const struct IncomingHealInfo *healInfo = &healInfoData; @@ -2279,7 +2279,7 @@ static u32 GetBestMonIntegrated(struct Pokemon *party, int firstId, int lastId, return PARTY_SIZE; } -static u32 GetBestMonVanilla(struct Pokemon *party, int firstId, int lastId, u32 battler, u32 opposingBattler, u32 battlerIn1, u32 battlerIn2, enum SwitchType switchType) +static u32 GetBestMonVanilla(struct Pokemon *party, int firstId, int lastId, enum BattlerId battler, enum BattlerId opposingBattler, enum BattlerId battlerIn1, enum BattlerId battlerIn2, enum SwitchType switchType) { s32 aceMonCount = 0; u32 validMonIds = 0, batonPassIds = 0, typeMatchupIds = 0, bestDamageId = PARTY_SIZE, aceMonId = PARTY_SIZE; @@ -2374,7 +2374,7 @@ static u32 GetBestMonVanilla(struct Pokemon *party, int firstId, int lastId, u32 return PARTY_SIZE; } -static u32 GetNextMonInParty(struct Pokemon *party, int firstId, int lastId, u32 battlerIn1, u32 battlerIn2) +static u32 GetNextMonInParty(struct Pokemon *party, int firstId, int lastId, enum BattlerId battlerIn1, enum BattlerId battlerIn2) { // Iterate through mons for (u32 monIndex = firstId; monIndex < lastId; monIndex++) @@ -2389,11 +2389,11 @@ static u32 GetNextMonInParty(struct Pokemon *party, int firstId, int lastId, u32 return PARTY_SIZE; } -u32 GetMostSuitableMonToSwitchInto(u32 battler, enum SwitchType switchType) +u32 GetMostSuitableMonToSwitchInto(enum BattlerId battler, enum SwitchType switchType) { - u32 opposingBattler = 0; + enum BattlerId opposingBattler = 0; u32 bestMonId = PARTY_SIZE; - u32 battlerIn1 = 0, battlerIn2 = 0; + enum BattlerId battlerIn1 = 0, battlerIn2 = 0; s32 firstId = 0; s32 lastId = 0; // + 1 struct Pokemon *party; @@ -2428,10 +2428,10 @@ u32 GetMostSuitableMonToSwitchInto(u32 battler, enum SwitchType switchType) } } -u32 AI_SelectRevivalBlessingMon(u32 battler) +u32 AI_SelectRevivalBlessingMon(enum BattlerId battler) { s32 firstId = 0, lastId = 0; - u32 opposingBattler = 0; + enum BattlerId opposingBattler = 0; struct Pokemon *party = GetBattlerParty(battler); u32 bestMonId = PARTY_SIZE; s32 bestScore = -1; diff --git a/src/battle_ai_util.c b/src/battle_ai_util.c index 8750225f52..ce438edf21 100644 --- a/src/battle_ai_util.c +++ b/src/battle_ai_util.c @@ -24,10 +24,10 @@ #include "constants/items.h" static u32 GetAIEffectGroup(enum BattleMoveEffects effect); -static u32 GetAIEffectGroupFromMove(u32 battler, enum Move move); +static u32 GetAIEffectGroupFromMove(enum BattlerId battler, enum Move move); // Functions -enum Ability AI_GetMoldBreakerSanitizedAbility(u32 battlerAtk, enum Ability abilityAtk, enum Ability abilityDef, enum HoldEffect holdEffectDef, enum Move move) +enum Ability AI_GetMoldBreakerSanitizedAbility(enum BattlerId battlerAtk, enum Ability abilityAtk, enum Ability abilityDef, enum HoldEffect holdEffectDef, enum Move move) { if (MoveIgnoresTargetAbility(move)) return ABILITY_NONE; @@ -38,7 +38,7 @@ enum Ability AI_GetMoldBreakerSanitizedAbility(u32 battlerAtk, enum Ability abil return abilityDef; } -static bool32 AI_IsDoubleSpreadMove(u32 battlerAtk, enum Move move) +static bool32 AI_IsDoubleSpreadMove(enum BattlerId battlerAtk, enum Move move) { u32 numOfTargets = 0; enum MoveTarget moveTargetType = AI_GetBattlerMoveTargetType(battlerAtk, move); @@ -46,7 +46,7 @@ static bool32 AI_IsDoubleSpreadMove(u32 battlerAtk, enum Move move) if (!IsSpreadMove(moveTargetType)) return FALSE; - for (u32 battlerDef = 0; battlerDef < MAX_BATTLERS_COUNT; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < MAX_BATTLERS_COUNT; battlerDef++) { if (battlerAtk == battlerDef) continue; @@ -64,19 +64,19 @@ static bool32 AI_IsDoubleSpreadMove(u32 battlerAtk, enum Move move) return FALSE; } -bool32 AI_IsBattlerGrounded(u32 battler) +bool32 AI_IsBattlerGrounded(enum BattlerId battler) { return IsBattlerGrounded(battler, gAiLogicData->abilities[battler], gAiLogicData->holdEffects[battler]); } -static bool32 AI_CanBattlerHitBothFoesInTerrain(u32 battler, enum Move move, enum BattleMoveEffects effect) +static bool32 AI_CanBattlerHitBothFoesInTerrain(enum BattlerId battler, enum Move move, enum BattleMoveEffects effect) { return effect == EFFECT_TERRAIN_BOOST && GetMoveTerrainBoost_HitsBothFoes(move) && IsBattlerTerrainAffected(battler, gAiLogicData->abilities[battler], gAiLogicData->holdEffects[battler], gFieldStatuses, GetMoveTerrainBoost_Terrain(move)); } -enum MoveTarget AI_GetBattlerMoveTargetType(u32 battler, enum Move move) +enum MoveTarget AI_GetBattlerMoveTargetType(enum BattlerId battler, enum Move move) { enum BattleMoveEffects effect = GetMoveEffect(move); if (effect == EFFECT_CURSE && !IS_BATTLER_OF_TYPE(battler, TYPE_GHOST)) @@ -89,7 +89,7 @@ enum MoveTarget AI_GetBattlerMoveTargetType(u32 battler, enum Move move) return GetMoveTarget(move); } -u32 AI_GetDamage(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, struct AiLogicData *aiData) +u32 AI_GetDamage(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, struct AiLogicData *aiData) { if (calcContext == AI_ATTACKING && BattlerHasAi(battlerAtk)) { @@ -113,17 +113,17 @@ u32 AI_GetDamage(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcC } } -bool32 AI_IsFaster(u32 battlerAi, u32 battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority) +bool32 AI_IsFaster(enum BattlerId battlerAi, enum BattlerId battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority) { return (AI_WhoStrikesFirst(battlerAi, battlerDef, aiMove, playerMove, considerPriority) == AI_IS_FASTER); } -bool32 AI_IsSlower(u32 battlerAi, u32 battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority) +bool32 AI_IsSlower(enum BattlerId battlerAi, enum BattlerId battlerDef, enum Move aiMove, enum Move playerMove, enum ConsiderPriority considerPriority) { return (AI_WhoStrikesFirst(battlerAi, battlerDef, aiMove, playerMove, considerPriority) == AI_IS_SLOWER); } -enum Move GetAIChosenMove(u32 battlerId) +enum Move GetAIChosenMove(enum BattlerId battlerId) { return (gBattleMons[battlerId].moves[gAiBattleData->chosenMoveIndex[battlerId]]); } @@ -137,7 +137,7 @@ bool32 AI_RandLessThan(u32 val) bool32 IsAiFlagPresent(u64 flag) { - for (u32 battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) { if (gAiThinkingStruct->aiFlags[battlerIndex] & flag) return TRUE; @@ -146,7 +146,7 @@ bool32 IsAiFlagPresent(u64 flag) return FALSE; } -bool32 IsAiBattlerAware(u32 battlerId) +bool32 IsAiBattlerAware(enum BattlerId battlerId) { if (IsAiFlagPresent(AI_FLAG_OMNISCIENT)) return TRUE; @@ -154,7 +154,7 @@ bool32 IsAiBattlerAware(u32 battlerId) return BattlerHasAi(battlerId); } -bool32 IsAiBattlerAssumingStab(u32 battlerId) +bool32 IsAiBattlerAssumingStab(enum BattlerId battlerId) { if (IsAiFlagPresent(AI_FLAG_ASSUME_STAB)) return TRUE; @@ -162,7 +162,7 @@ bool32 IsAiBattlerAssumingStab(u32 battlerId) return FALSE; } -bool32 IsAiBattlerAssumingStatusMoves(u32 battlerId) +bool32 IsAiBattlerAssumingStatusMoves(enum BattlerId battlerId) { if (IsAiFlagPresent(AI_FLAG_ASSUME_STATUS_MOVES)) return TRUE; @@ -170,7 +170,7 @@ bool32 IsAiBattlerAssumingStatusMoves(u32 battlerId) return FALSE; } -bool32 IsAiBattlerPredictingAbility(u32 battlerId) +bool32 IsAiBattlerPredictingAbility(enum BattlerId battlerId) { if (IsAiFlagPresent(AI_FLAG_WEIGH_ABILITY_PREDICTION)) return TRUE; @@ -178,7 +178,7 @@ bool32 IsAiBattlerPredictingAbility(u32 battlerId) return FALSE; } -bool32 CanAiPredictMove(u32 battlerId) +bool32 CanAiPredictMove(enum BattlerId battlerId) { if (IsAiFlagPresent(AI_FLAG_PREDICT_MOVE)) return TRUE; @@ -186,10 +186,10 @@ bool32 CanAiPredictMove(u32 battlerId) return FALSE; } -bool32 IsBattlerPredictedToSwitch(u32 battler) +bool32 IsBattlerPredictedToSwitch(enum BattlerId battler) { // Check for prediction flag on AI, whether they're using those predictions this turn, and whether the AI thinks the player should switch - for (u32 battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < MAX_BATTLERS_COUNT; battlerIndex++) { if (gAiThinkingStruct->aiFlags[battlerIndex] & AI_FLAG_PREDICT_SWITCH) { @@ -201,7 +201,7 @@ bool32 IsBattlerPredictedToSwitch(u32 battler) } // Either a predicted move or the last used move from an opposing battler -enum Move GetIncomingMove(u32 battler, u32 opposingBattler, struct AiLogicData *aiData) +enum Move GetIncomingMove(enum BattlerId battler, enum BattlerId opposingBattler, struct AiLogicData *aiData) { if (aiData->predictingMove && CanAiPredictMove(battler)) return aiData->predictedMove[opposingBattler]; @@ -209,7 +209,7 @@ enum Move GetIncomingMove(u32 battler, u32 opposingBattler, struct AiLogicData * } // When not predicting, don't want to reference player's previous move; leads to weird behaviour for cases like Fake Out or Protect, especially in doubles -enum Move GetIncomingMoveSpeedCheck(u32 battler, u32 opposingBattler, struct AiLogicData *aiData) +enum Move GetIncomingMoveSpeedCheck(enum BattlerId battler, enum BattlerId opposingBattler, struct AiLogicData *aiData) { if (aiData->predictingMove && CanAiPredictMove(battler)) { @@ -221,14 +221,14 @@ enum Move GetIncomingMoveSpeedCheck(u32 battler, u32 opposingBattler, struct AiL return MOVE_NONE; } -void ClearBattlerMoveHistory(u32 battlerId) +void ClearBattlerMoveHistory(enum BattlerId battlerId) { memset(gBattleHistory->usedMoves[battlerId], 0, sizeof(gBattleHistory->usedMoves[battlerId])); memset(gBattleHistory->moveHistory[battlerId], 0, sizeof(gBattleHistory->moveHistory[battlerId])); gBattleHistory->moveHistoryIndex[battlerId] = 0; } -void RecordLastUsedMoveBy(u32 battlerId, enum Move move) +void RecordLastUsedMoveBy(enum BattlerId battlerId, enum Move move) { u8 *index = &gBattleHistory->moveHistoryIndex[battlerId]; @@ -237,7 +237,7 @@ void RecordLastUsedMoveBy(u32 battlerId, enum Move move) gBattleHistory->moveHistory[battlerId][*index] = move; } -void RecordKnownMove(u32 battler, enum Move move) +void RecordKnownMove(enum BattlerId battler, enum Move move) { s32 moveIndex; @@ -254,34 +254,34 @@ void RecordKnownMove(u32 battler, enum Move move) } } -void RecordAllMoves(u32 battler) +void RecordAllMoves(enum BattlerId battler) { memcpy(gAiPartyData->mons[GetBattlerSide(battler)][gBattlerPartyIndexes[battler]].moves, gBattleMons[battler].moves, MAX_MON_MOVES * sizeof(u16)); } -void RecordAbilityBattle(u32 battlerId, enum Ability abilityId) +void RecordAbilityBattle(enum BattlerId battlerId, enum Ability abilityId) { gBattleHistory->abilities[battlerId] = abilityId; gAiPartyData->mons[GetBattlerSide(battlerId)][gBattlerPartyIndexes[battlerId]].ability = abilityId; } -void ClearBattlerAbilityHistory(u32 battlerId) +void ClearBattlerAbilityHistory(enum BattlerId battlerId) { gBattleHistory->abilities[battlerId] = ABILITY_NONE; } -void RecordItemEffectBattle(u32 battlerId, enum HoldEffect itemEffect) +void RecordItemEffectBattle(enum BattlerId battlerId, enum HoldEffect itemEffect) { gBattleHistory->itemEffects[battlerId] = itemEffect; gAiPartyData->mons[GetBattlerSide(battlerId)][gBattlerPartyIndexes[battlerId]].heldEffect = itemEffect; } -void ClearBattlerItemEffectHistory(u32 battlerId) +void ClearBattlerItemEffectHistory(enum BattlerId battlerId) { gBattleHistory->itemEffects[battlerId] = HOLD_EFFECT_NONE; } -void SaveBattlerData(u32 battlerId) +void SaveBattlerData(enum BattlerId battlerId) { if (!BattlerHasAi(battlerId) && !gAiThinkingStruct->saved[battlerId].saved) { @@ -357,7 +357,7 @@ bool32 ShouldRecordStatusMove(enum Move move) return RandomPercentage(RNG_AI_ASSUME_ALL_STATUS, ASSUME_ALL_STATUS_ODDS) && IsBattleMoveStatus(move); } -static bool32 ShouldFailForIllusion(u32 illusionSpecies, u32 battlerId) +static bool32 ShouldFailForIllusion(u32 illusionSpecies, enum BattlerId battlerId) { u32 learnsetMoveIndex; const struct LevelUpMove *learnset; @@ -393,7 +393,7 @@ static bool32 ShouldFailForIllusion(u32 illusionSpecies, u32 battlerId) return TRUE; } -void SetBattlerData(u32 battlerId) +void SetBattlerData(enum BattlerId battlerId) { if (!BattlerHasAi(battlerId) && gAiThinkingStruct->saved[battlerId].saved) { @@ -437,7 +437,7 @@ void SetBattlerData(u32 battlerId) } } -void RestoreBattlerData(u32 battlerId) +void RestoreBattlerData(enum BattlerId battlerId) { if (!BattlerHasAi(battlerId) && gAiThinkingStruct->saved[battlerId].saved) { @@ -452,12 +452,12 @@ void RestoreBattlerData(u32 battlerId) gBattleMons[battlerId].types[1] = gAiThinkingStruct->saved[battlerId].types[1]; } -u32 GetHealthPercentage(u32 battlerId) +u32 GetHealthPercentage(enum BattlerId battlerId) { return (u32)((100 * gBattleMons[battlerId].hp) / gBattleMons[battlerId].maxHP); } -bool32 AI_BattlerAtMaxHp(u32 battlerId) +bool32 AI_BattlerAtMaxHp(enum BattlerId battlerId) { if (gAiLogicData->hpPercents[battlerId] == 100) return TRUE; @@ -465,7 +465,7 @@ bool32 AI_BattlerAtMaxHp(u32 battlerId) } -bool32 AI_CanBattlerEscape(u32 battler) +bool32 AI_CanBattlerEscape(enum BattlerId battler) { enum HoldEffect holdEffect = gAiLogicData->holdEffects[battler]; @@ -477,7 +477,7 @@ bool32 AI_CanBattlerEscape(u32 battler) return FALSE; } -bool32 IsBattlerTrapped(u32 battlerAtk, u32 battlerDef) +bool32 IsBattlerTrapped(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (AI_CanBattlerEscape(battlerDef)) return FALSE; @@ -518,7 +518,7 @@ u32 GetTotalBaseStat(u32 species) + GetSpeciesBaseSpDefense(species); } -bool32 IsTruantMonVulnerable(u32 battlerAI, u32 opposingBattler) +bool32 IsTruantMonVulnerable(enum BattlerId battlerAI, enum BattlerId opposingBattler) { enum Move predictedMoveSpeedCheck = GetIncomingMoveSpeedCheck(battlerAI, opposingBattler, gAiLogicData); @@ -534,7 +534,7 @@ bool32 IsTruantMonVulnerable(u32 battlerAI, u32 opposingBattler) return FALSE; } -bool32 Ai_IsPriorityBlocked(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +bool32 Ai_IsPriorityBlocked(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { s32 atkPriority = GetBattleMovePriority(battlerAtk, aiData->abilities[battlerAtk], move); @@ -595,7 +595,7 @@ bool32 MovesWithCategoryUnusable(u32 attacker, u32 target, enum DamageCategory c } // To save computation time this function has 2 variants. One saves, sets and restores battlers, while the other doesn't. -struct SimulatedDamage AI_CalcDamageSaveBattlers(enum Move move, u32 battlerAtk, u32 battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef) +struct SimulatedDamage AI_CalcDamageSaveBattlers(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef) { struct SimulatedDamage dmg; @@ -723,7 +723,7 @@ bool32 IsDamageMoveUnusable(struct BattleContext *ctx) return FALSE; } -bool32 IsAdditionalEffectBlocked(u32 battlerAtk, u32 abilityAtk, u32 battlerDef, enum Ability abilityDef) +bool32 IsAdditionalEffectBlocked(enum BattlerId battlerAtk, u32 abilityAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_COVERT_CLOAK) return TRUE; @@ -744,14 +744,14 @@ static inline s32 GetDamageByRollType(s32 dmg, enum DamageRollType rollType) return DmgRoll(dmg); } -static inline void AI_StoreBattlerTypes(u32 battlerAtk, enum Type *types) +static inline void AI_StoreBattlerTypes(enum BattlerId battlerAtk, enum Type *types) { types[0] = gBattleMons[battlerAtk].types[0]; types[1] = gBattleMons[battlerAtk].types[1]; types[2] = gBattleMons[battlerAtk].types[2]; } -static inline void AI_RestoreBattlerTypes(u32 battlerAtk, enum Type *types) +static inline void AI_RestoreBattlerTypes(enum BattlerId battlerAtk, enum Type *types) { gBattleMons[battlerAtk].types[0] = types[0]; gBattleMons[battlerAtk].types[1] = types[1]; @@ -892,7 +892,7 @@ static s32 AI_ApplyModifiersAfterDmgRoll(struct BattleContext *ctx, s32 dmg) return dmg; } -struct SimulatedDamage AI_CalcDamage(enum Move move, u32 battlerAtk, u32 battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef, u32 weather, u32 fieldStatuses) +struct SimulatedDamage AI_CalcDamage(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef, uq4_12_t *typeEffectiveness, enum AIConsiderGimmick considerGimmickAtk, enum AIConsiderGimmick considerGimmickDef, u32 weather, u32 fieldStatuses) { struct SimulatedDamage simDamage = {0}; enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -906,7 +906,7 @@ struct SimulatedDamage AI_CalcDamage(enum Move move, u32 battlerAtk, u32 battler return simDamage; if (moveEffect == EFFECT_NATURE_POWER) - move = GetNaturePowerMove(battlerAtk); + move = GetNaturePowerMove(); // Temporarily enable gimmicks for damage calcs if planned if (gBattleStruct->gimmick.usableGimmick[battlerAtk] && GetActiveGimmick(battlerAtk) == GIMMICK_NONE @@ -1020,7 +1020,7 @@ struct SimulatedDamage AI_CalcDamage(enum Move move, u32 battlerAtk, u32 battler return simDamage; } -bool32 AI_IsDamagedByRecoil(u32 battler) +bool32 AI_IsDamagedByRecoil(enum BattlerId battler) { enum Ability ability = gAiLogicData->abilities[battler]; if (ability == ABILITY_MAGIC_GUARD || ability == ABILITY_ROCK_HEAD) @@ -1029,7 +1029,7 @@ bool32 AI_IsDamagedByRecoil(u32 battler) } // Decide whether move having an additional effect for . -static bool32 AI_IsMoveEffectInPlus(u32 battlerAtk, u32 battlerDef, enum Move move, s32 noOfHitsToKo) +static bool32 AI_IsMoveEffectInPlus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 noOfHitsToKo) { enum Ability abilityDef = gAiLogicData->abilities[battlerDef]; enum Ability abilityAtk = gAiLogicData->abilities[battlerAtk]; @@ -1213,7 +1213,7 @@ static bool32 AI_IsMoveEffectInPlus(u32 battlerAtk, u32 battlerDef, enum Move mo return FALSE; } -static bool32 AI_IsMoveEffectInMinus(u32 battlerAtk, u32 battlerDef, enum Move move, s32 noOfHitsToKo) +static bool32 AI_IsMoveEffectInMinus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 noOfHitsToKo) { enum Ability abilityAtk = gAiLogicData->abilities[battlerAtk]; enum Ability abilityDef = gAiLogicData->abilities[battlerDef]; @@ -1318,7 +1318,7 @@ static bool32 AI_IsMoveEffectInMinus(u32 battlerAtk, u32 battlerDef, enum Move m } // Checks if one of the moves has side effects or perks, assuming equal dmg or equal no of hits to KO -enum MoveComparisonResult CompareMoveEffects(enum Move move1, enum Move move2, u32 battlerAtk, u32 battlerDef, s32 noOfHitsToKo) +enum MoveComparisonResult CompareMoveEffects(enum Move move1, enum Move move2, enum BattlerId battlerAtk, enum BattlerId battlerDef, s32 noOfHitsToKo) { bool32 effect1, effect2; enum Ability defAbility = gAiLogicData->abilities[battlerDef]; @@ -1362,12 +1362,12 @@ u32 GetNoOfHitsToKO(u32 dmg, s32 hp) return (hp + dmg - 1) / dmg; } -u32 GetNoOfHitsToKOBattlerDmg(u32 dmg, u32 battlerDef) +u32 GetNoOfHitsToKOBattlerDmg(u32 dmg, enum BattlerId battlerDef) { return GetNoOfHitsToKO(dmg, gBattleMons[battlerDef].hp); } -u32 GetNoOfHitsToKOBattler(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, enum AiConsiderEndure considerEndure) +u32 GetNoOfHitsToKOBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum DamageCalcContext calcContext, enum AiConsiderEndure considerEndure) { u32 hitsToKO = GetNoOfHitsToKOBattlerDmg(AI_GetDamage(battlerAtk, battlerDef, moveIndex, calcContext, gAiLogicData), battlerDef); enum Move *moves = GetMovesArray(battlerAtk); @@ -1378,7 +1378,7 @@ u32 GetNoOfHitsToKOBattler(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum D return hitsToKO; } -u32 GetBestNoOfHitsToKO(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext) +u32 GetBestNoOfHitsToKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext) { u32 result = 100; u32 tempResult = 0; @@ -1400,14 +1400,14 @@ u32 GetBestNoOfHitsToKO(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext c return result; } -u32 GetCurrDamageHpPercent(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext) +u32 GetCurrDamageHpPercent(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext) { int bestDmg = AI_GetDamage(battlerAtk, battlerDef, gAiThinkingStruct->movesetIndex, calcContext, gAiLogicData); return (bestDmg * 100) / gBattleMons[battlerDef].maxHP; } -uq4_12_t AI_GetMoveEffectiveness(enum Move move, u32 battlerAtk, u32 battlerDef) +uq4_12_t AI_GetMoveEffectiveness(enum Move move, enum BattlerId battlerAtk, enum BattlerId battlerDef) { uq4_12_t typeEffectiveness; @@ -1443,7 +1443,7 @@ uq4_12_t AI_GetMoveEffectiveness(enum Move move, u32 battlerAtk, u32 battlerDef) * AI_IS_FASTER: is user(ai) faster * AI_IS_SLOWER: is target faster */ -s32 AI_WhoStrikesFirst(u32 battlerAI, u32 battler, enum Move aiMoveConsidered, enum Move playerMoveConsidered, enum ConsiderPriority considerPriority) +s32 AI_WhoStrikesFirst(enum BattlerId battlerAI, enum BattlerId battler, enum Move aiMoveConsidered, enum Move playerMoveConsidered, enum ConsiderPriority considerPriority) { u32 speedBattlerAI, speedBattler; enum HoldEffect holdEffectAI = gAiLogicData->holdEffects[battlerAI]; @@ -1497,7 +1497,7 @@ s32 AI_WhoStrikesFirst(u32 battlerAI, u32 battler, enum Move aiMoveConsidered, e return AI_IS_SLOWER; } -bool32 CanEndureHit(u32 battler, u32 battlerTarget, enum Move move) +bool32 CanEndureHit(enum BattlerId battler, enum BattlerId battlerTarget, enum Move move) { if (!AI_BattlerAtMaxHp(battlerTarget) || IsMultiHitMove(move) || gAiLogicData->abilities[battler] == ABILITY_PARENTAL_BOND) return FALSE; @@ -1521,7 +1521,7 @@ bool32 CanEndureHit(u32 battler, u32 battlerTarget, enum Move move) } // Check if target has means to faint ai mon. -bool32 CanTargetFaintAi(u32 battlerDef, u32 battlerAtk) +bool32 CanTargetFaintAi(enum BattlerId battlerDef, enum BattlerId battlerAtk) { struct AiLogicData *aiData = gAiLogicData; enum Move *moves = GetMovesArray(battlerDef); @@ -1540,7 +1540,7 @@ bool32 CanTargetFaintAi(u32 battlerDef, u32 battlerAtk) return FALSE; } -u32 NoOfHitsForTargetToFaintBattler(u32 battlerDef, u32 battlerAtk, enum AiConsiderEndure considerEndure) +u32 NoOfHitsForTargetToFaintBattler(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum AiConsiderEndure considerEndure) { u32 currNumberOfHits; u32 leastNumberOfHits = UNKNOWN_NO_OF_HITS; @@ -1557,7 +1557,7 @@ u32 NoOfHitsForTargetToFaintBattler(u32 battlerDef, u32 battlerAtk, enum AiConsi return leastNumberOfHits; } -u32 NoOfHitsForTargetToFaintBattlerWithMod(u32 battlerDef, u32 battlerAtk, s32 hpMod) +u32 NoOfHitsForTargetToFaintBattlerWithMod(enum BattlerId battlerDef, enum BattlerId battlerAtk, s32 hpMod) { u32 currNumberOfHits; u32 leastNumberOfHits = UNKNOWN_NO_OF_HITS; @@ -1582,7 +1582,7 @@ u32 NoOfHitsForTargetToFaintBattlerWithMod(u32 battlerDef, u32 battlerAtk, s32 h return leastNumberOfHits; } -void GetBestDmgMovesFromBattler(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum Move *bestMoves) +void GetBestDmgMovesFromBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum Move *bestMoves) { struct AiLogicData *aiData = gAiLogicData; u32 bestDmg = 0; @@ -1622,7 +1622,7 @@ void GetBestDmgMovesFromBattler(u32 battlerAtk, u32 battlerDef, enum DamageCalcC } } -u32 GetMoveIndex(u32 battler, enum Move move) +u32 GetMoveIndex(enum BattlerId battler, enum Move move) { enum Move *moves = GetMovesArray(battler); @@ -1635,7 +1635,7 @@ u32 GetMoveIndex(u32 battler, enum Move move) return MAX_MON_MOVES; } -bool32 IsBestDmgMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum Move move) +bool32 IsBestDmgMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum Move move) { enum Move bestMoves[MAX_MON_MOVES] = {MOVE_NONE}; u32 index = GetMoveIndex(battlerAtk, move); @@ -1654,7 +1654,7 @@ bool32 IsBestDmgMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calc return FALSE; } -bool32 BestDmgMoveHasEffect(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext, enum BattleMoveEffects moveEffect) +bool32 BestDmgMoveHasEffect(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext, enum BattleMoveEffects moveEffect) { enum Move bestMoves[MAX_MON_MOVES] = {MOVE_NONE}; @@ -1672,7 +1672,7 @@ bool32 BestDmgMoveHasEffect(u32 battlerAtk, u32 battlerDef, enum DamageCalcConte return FALSE; } -u32 GetBestDmgFromBattler(u32 battler, u32 battlerTarget, enum DamageCalcContext calcContext) +u32 GetBestDmgFromBattler(enum BattlerId battler, enum BattlerId battlerTarget, enum DamageCalcContext calcContext) { struct AiLogicData *aiData = gAiLogicData; u32 bestDmg = 0; @@ -1694,7 +1694,7 @@ u32 GetBestDmgFromBattler(u32 battler, u32 battlerTarget, enum DamageCalcContext // Check if AI mon has the means to faint the target with any of its moves. // If numHits > 1, check if the target will be KO'ed by that number of hits (ignoring healing effects) -bool32 CanAIFaintTarget(u32 battlerAtk, u32 battlerDef, u32 numHits) +bool32 CanAIFaintTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 numHits) { struct AiLogicData *aiData = gAiLogicData; s32 dmg; @@ -1725,7 +1725,7 @@ bool32 CanAIFaintTarget(u32 battlerAtk, u32 battlerDef, u32 numHits) } // Can battler KO the target ignoring any Endure effects (Sturdy, Focus Sash, etc.) -bool32 CanBattlerKOTargetIgnoringSturdy(u32 battlerAtk, u32 battlerDef) +bool32 CanBattlerKOTargetIgnoringSturdy(enum BattlerId battlerAtk, enum BattlerId battlerDef) { struct AiLogicData *aiData = gAiLogicData; s32 dmg; @@ -1744,7 +1744,7 @@ bool32 CanBattlerKOTargetIgnoringSturdy(u32 battlerAtk, u32 battlerDef) return FALSE; } -bool32 CanTargetMoveFaintAi(enum Move move, u32 battlerDef, u32 battlerAtk, u32 nHits) +bool32 CanTargetMoveFaintAi(enum Move move, enum BattlerId battlerDef, enum BattlerId battlerAtk, u32 nHits) { u32 indexSlot = GetMoveSlot(GetMovesArray(battlerDef), move); if (indexSlot < MAX_MON_MOVES) @@ -1757,7 +1757,7 @@ bool32 CanTargetMoveFaintAi(enum Move move, u32 battlerDef, u32 battlerAtk, u32 } // Check if target has means to faint ai mon after modding hp/dmg -bool32 CanTargetFaintAiWithMod(u32 battlerDef, u32 battlerAtk, s32 hpMod, s32 dmgMod) +bool32 CanTargetFaintAiWithMod(enum BattlerId battlerDef, enum BattlerId battlerAtk, s32 hpMod, s32 dmgMod) { struct AiLogicData *aiData = gAiLogicData; s32 dmg; @@ -1792,7 +1792,7 @@ bool32 CanTargetFaintAiWithMod(u32 battlerDef, u32 battlerAtk, s32 hpMod, s32 dm return FALSE; } -bool32 AI_IsAbilityOnSide(u32 battlerId, enum Ability ability) +bool32 AI_IsAbilityOnSide(enum BattlerId battlerId, enum Ability ability) { if (IsBattlerAlive(battlerId) && gAiLogicData->abilities[battlerId] == ability) return TRUE; @@ -1803,7 +1803,7 @@ bool32 AI_IsAbilityOnSide(u32 battlerId, enum Ability ability) } // does NOT include ability suppression checks -enum Ability AI_DecideKnownAbilityForTurn(u32 battlerId) +enum Ability AI_DecideKnownAbilityForTurn(enum BattlerId battlerId) { enum Ability validAbilities[NUM_ABILITY_SLOTS]; u8 numValidAbilities = 0; @@ -1849,7 +1849,7 @@ enum Ability AI_DecideKnownAbilityForTurn(u32 battlerId) return ABILITY_NONE; // Unknown. } -enum HoldEffect AI_DecideHoldEffectForTurn(u32 battlerId) +enum HoldEffect AI_DecideHoldEffectForTurn(enum BattlerId battlerId) { enum HoldEffect holdEffect = HOLD_EFFECT_NONE; @@ -1874,7 +1874,7 @@ enum HoldEffect AI_DecideHoldEffectForTurn(u32 battlerId) return holdEffect; } -bool32 DoesBattlerIgnoreAbilityChecks(u32 battlerAtk, enum Ability atkAbility, enum Move move) +bool32 DoesBattlerIgnoreAbilityChecks(enum BattlerId battlerAtk, enum Ability atkAbility, enum Move move) { if (gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_NEGATE_UNAWARE) return FALSE; // AI handicap flag: doesn't understand ability suppression concept @@ -1906,7 +1906,7 @@ u32 AI_GetWeather(void) return gBattleWeather; } -u32 AI_GetSwitchinWeather(u32 battler) +u32 AI_GetSwitchinWeather(enum BattlerId battler) { enum Ability ability = gBattleMons[battler].ability; // Forced weather behaviour @@ -1948,7 +1948,7 @@ u32 SwitchinChangeBattleTerrain(u32 newTerrain, u32 fieldStatus) return fieldStatus; } -u32 AI_GetSwitchinFieldStatus(u32 battler) +u32 AI_GetSwitchinFieldStatus(enum BattlerId battler) { enum Ability ability = gBattleMons[battler].ability; u32 startingFieldStatus = gFieldStatuses; @@ -2089,7 +2089,7 @@ bool32 IsHazardClearingMove(enum Move move) return FALSE; } -bool32 IsAllyProtectingFromMove(u32 battlerAtk, enum Move attackerMove, enum Move allyMove) +bool32 IsAllyProtectingFromMove(enum BattlerId battlerAtk, enum Move attackerMove, enum Move allyMove) { enum BattleMoveEffects effect = GetMoveEffect(allyMove); @@ -2139,7 +2139,7 @@ bool32 IsAllyProtectingFromMove(u32 battlerAtk, enum Move attackerMove, enum Mov } } -bool32 IsMoveRedirectionPrevented(u32 battlerAtk, enum Move move, enum Ability atkAbility) +bool32 IsMoveRedirectionPrevented(enum BattlerId battlerAtk, enum Move move, enum Ability atkAbility) { if (gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_NEGATE_UNAWARE) return FALSE; @@ -2153,7 +2153,7 @@ bool32 IsMoveRedirectionPrevented(u32 battlerAtk, enum Move move, enum Ability a return FALSE; } -bool32 ShouldTryOHKO(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move) +bool32 ShouldTryOHKO(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move) { enum HoldEffect holdEffect = gAiLogicData->holdEffects[battlerDef]; u32 accuracy = gAiLogicData->moveAccuracy[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex]; @@ -2185,7 +2185,7 @@ bool32 ShouldTryOHKO(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility, en return FALSE; } -bool32 ShouldRaiseAnyStat(u32 battlerAtk, u32 battlerDef) +bool32 ShouldRaiseAnyStat(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (AreBattlersStatsMaxed(battlerAtk)) return FALSE; @@ -2222,7 +2222,7 @@ bool32 ShouldRaiseAnyStat(u32 battlerAtk, u32 battlerDef) return TRUE; } -bool32 ShouldSetWeather(u32 battler, u32 weather) +bool32 ShouldSetWeather(enum BattlerId battler, u32 weather) { if (AI_GetWeather() & weather) return FALSE; @@ -2230,12 +2230,12 @@ bool32 ShouldSetWeather(u32 battler, u32 weather) return WeatherChecker(battler, weather, FIELD_EFFECT_POSITIVE); } -bool32 ShouldClearWeather(u32 battler, u32 weather) +bool32 ShouldClearWeather(enum BattlerId battler, u32 weather) { return WeatherChecker(battler, weather, FIELD_EFFECT_NEGATIVE); } -bool32 ShouldSetFieldStatus(u32 battler, u32 fieldStatus) +bool32 ShouldSetFieldStatus(enum BattlerId battler, u32 fieldStatus) { if (gFieldStatuses & fieldStatus) { @@ -2249,12 +2249,12 @@ bool32 ShouldSetFieldStatus(u32 battler, u32 fieldStatus) return FieldStatusChecker(battler, fieldStatus, FIELD_EFFECT_POSITIVE); } -bool32 ShouldClearFieldStatus(u32 battler, u32 fieldStatus) +bool32 ShouldClearFieldStatus(enum BattlerId battler, u32 fieldStatus) { return FieldStatusChecker(battler, fieldStatus, FIELD_EFFECT_NEGATIVE); } -bool32 IsBattlerDamagedByStatus(u32 battler) +bool32 IsBattlerDamagedByStatus(enum BattlerId battler) { return gBattleMons[battler].status1 & STATUS1_DAMAGING || gBattleMons[battler].volatiles.wrapped @@ -2266,7 +2266,7 @@ bool32 IsBattlerDamagedByStatus(u32 battler) || gSideStatuses[GetBattlerSide(battler)] & (SIDE_STATUS_SEA_OF_FIRE | SIDE_STATUS_DAMAGE_NON_TYPES); } -s32 ProtectChecks(u32 battlerAtk, u32 battlerDef, enum Move move, enum Move predictedMove) +s32 ProtectChecks(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Move predictedMove) { s32 score = 0; @@ -2320,7 +2320,7 @@ s32 ProtectChecks(u32 battlerAtk, u32 battlerDef, enum Move move, enum Move pred } // stat stages -bool32 CanLowerStat(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData, enum Stat stat) +bool32 CanLowerStat(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData, enum Stat stat) { if (gBattleMons[battlerDef].statStages[stat] == MIN_STAT_STAGE) return FALSE; @@ -2383,7 +2383,7 @@ bool32 CanLowerStat(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData, return TRUE; } -enum AIScore IncreaseStatDownScore(u32 battlerAtk, u32 battlerDef, enum Stat stat) +enum AIScore IncreaseStatDownScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Stat stat) { enum AIScore tempScore = NO_INCREASE; @@ -2456,7 +2456,7 @@ enum AIScore IncreaseStatDownScore(u32 battlerAtk, u32 battlerDef, enum Stat sta return (tempScore > BEST_EFFECT) ? BEST_EFFECT : tempScore; // don't inflate score so only max +4 } -bool32 BattlerStatCanRise(u32 battler, enum Ability battlerAbility, enum Stat stat) +bool32 BattlerStatCanRise(enum BattlerId battler, enum Ability battlerAbility, enum Stat stat) { if ((gBattleMons[battler].statStages[stat] < MAX_STAT_STAGE && battlerAbility != ABILITY_CONTRARY) || (battlerAbility == ABILITY_CONTRARY && gBattleMons[battler].statStages[stat] > MIN_STAT_STAGE)) @@ -2464,7 +2464,7 @@ bool32 BattlerStatCanRise(u32 battler, enum Ability battlerAbility, enum Stat st return FALSE; } -bool32 AreBattlersStatsMaxed(u32 battlerId) +bool32 AreBattlersStatsMaxed(enum BattlerId battlerId) { for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) { @@ -2474,7 +2474,7 @@ bool32 AreBattlersStatsMaxed(u32 battlerId) return TRUE; } -bool32 AnyStatIsRaised(u32 battlerId) +bool32 AnyStatIsRaised(enum BattlerId battlerId) { for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) { @@ -2484,7 +2484,7 @@ bool32 AnyStatIsRaised(u32 battlerId) return FALSE; } -u32 CountPositiveStatStages(u32 battlerId) +u32 CountPositiveStatStages(enum BattlerId battlerId) { u32 count = 0; for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) @@ -2495,7 +2495,7 @@ u32 CountPositiveStatStages(u32 battlerId) return count; } -u32 CountNegativeStatStages(u32 battlerId) +u32 CountNegativeStatStages(enum BattlerId battlerId) { u32 count = 0; for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) @@ -2506,7 +2506,7 @@ u32 CountNegativeStatStages(u32 battlerId) return count; } -bool32 CanIndexMoveFaintTarget(u32 battlerAtk, u32 battlerDef, u32 moveIndex, enum DamageCalcContext calcContext) +bool32 CanIndexMoveFaintTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 moveIndex, enum DamageCalcContext calcContext) { s32 dmg; enum Move *moves = gBattleMons[battlerAtk].moves; @@ -2521,7 +2521,7 @@ bool32 CanIndexMoveFaintTarget(u32 battlerAtk, u32 battlerDef, u32 moveIndex, en return FALSE; } -enum Move *GetMovesArray(u32 battler) +enum Move *GetMovesArray(enum BattlerId battler) { if (IsAiBattlerAware(battler) || IsAiBattlerAware(BATTLE_PARTNER(battler))) return gBattleMons[battler].moves; @@ -2529,7 +2529,7 @@ enum Move *GetMovesArray(u32 battler) return gBattleHistory->usedMoves[battler]; } -u32 GetBattlerMoveIndexWithEffect(u32 battler, enum BattleMoveEffects effect) +u32 GetBattlerMoveIndexWithEffect(enum BattlerId battler, enum BattleMoveEffects effect) { enum Move *moves = GetMovesArray(battler); for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -2540,7 +2540,7 @@ u32 GetBattlerMoveIndexWithEffect(u32 battler, enum BattleMoveEffects effect) return MAX_MON_MOVES; } -bool32 HasPhysicalBestMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContext calcContext) +bool32 HasPhysicalBestMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum DamageCalcContext calcContext) { enum Move atkBestMoves[MAX_MON_MOVES] = {MOVE_NONE}; GetBestDmgMovesFromBattler(battlerAtk, battlerDef, calcContext, atkBestMoves); @@ -2563,7 +2563,7 @@ bool32 HasPhysicalBestMove(u32 battlerAtk, u32 battlerDef, enum DamageCalcContex return bestMoveIsPhysical; } -bool32 HasOnlyMovesWithCategory(u32 battlerId, enum DamageCategory category, bool32 onlyOffensive) +bool32 HasOnlyMovesWithCategory(enum BattlerId battlerId, enum DamageCategory category, bool32 onlyOffensive) { enum Move *moves = GetMovesArray(battlerId); @@ -2578,7 +2578,7 @@ bool32 HasOnlyMovesWithCategory(u32 battlerId, enum DamageCategory category, boo return TRUE; } -bool32 HasMoveWithCategory(u32 battler, enum DamageCategory category) +bool32 HasMoveWithCategory(enum BattlerId battler, enum DamageCategory category) { enum Move *moves = GetMovesArray(battler); @@ -2590,7 +2590,7 @@ bool32 HasMoveWithCategory(u32 battler, enum DamageCategory category) return FALSE; } -bool32 HasMoveWithType(u32 battler, enum Type type) +bool32 HasMoveWithType(enum BattlerId battler, enum Type type) { enum Move *moves = GetMovesArray(battler); @@ -2603,7 +2603,7 @@ bool32 HasMoveWithType(u32 battler, enum Type type) return FALSE; } -bool32 HasMoveWithEffect(u32 battler, enum BattleMoveEffects effect) +bool32 HasMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects effect) { enum Move *moves = GetMovesArray(battler); @@ -2616,7 +2616,7 @@ bool32 HasMoveWithEffect(u32 battler, enum BattleMoveEffects effect) return FALSE; } -bool32 HasMoveWithAIEffect(u32 battler, u32 aiEffect) +bool32 HasMoveWithAIEffect(enum BattlerId battler, u32 aiEffect) { enum Move *moves = GetMovesArray(battler); @@ -2632,7 +2632,7 @@ bool32 HasMoveWithAIEffect(u32 battler, u32 aiEffect) return FALSE; } -bool32 HasBattlerSideMoveWithEffect(u32 battler, enum BattleMoveEffects effect) +bool32 HasBattlerSideMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects effect) { if (HasMoveWithEffect(battler, effect)) return TRUE; @@ -2641,7 +2641,7 @@ bool32 HasBattlerSideMoveWithEffect(u32 battler, enum BattleMoveEffects effect) return FALSE; } -bool32 HasBattlerSideMoveWithAIEffect(u32 battler, u32 aiEffect) +bool32 HasBattlerSideMoveWithAIEffect(enum BattlerId battler, u32 aiEffect) { if (HasMoveWithAIEffect(battler, aiEffect)) return TRUE; @@ -2653,7 +2653,7 @@ bool32 HasBattlerSideMoveWithAIEffect(u32 battler, u32 aiEffect) // HasBattlerSideMoveWithEffect checks if the AI knows a side has a move effect, // while HasBattlerSideUsedMoveWithEffect checks if the side has actively USED the move effect. // It matches both on move effect and on AI move effect; eg, EFFECT_HAZE will also bring up Freezy Frost or Clear Smog, anything with AI_EFFECT_RESET_STATS. -bool32 HasBattlerSideUsedMoveWithEffect(u32 battler, enum BattleMoveEffects effect) +bool32 HasBattlerSideUsedMoveWithEffect(enum BattlerId battler, enum BattleMoveEffects effect) { u32 aiEffect = GetAIEffectGroup(effect); for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -2682,7 +2682,7 @@ bool32 HasBattlerSideUsedMoveWithEffect(u32 battler, enum BattleMoveEffects effe return FALSE; } -bool32 HasNonVolatileMoveEffect(u32 battlerId, enum MoveEffect effect) +bool32 HasNonVolatileMoveEffect(enum BattlerId battlerId, enum MoveEffect effect) { enum Move *moves = GetMovesArray(battlerId); @@ -2695,7 +2695,7 @@ bool32 HasNonVolatileMoveEffect(u32 battlerId, enum MoveEffect effect) return FALSE; } -bool32 IsPowerBasedOnStatus(u32 battlerId, enum BattleMoveEffects effect, u32 argument) +bool32 IsPowerBasedOnStatus(enum BattlerId battlerId, enum BattleMoveEffects effect, u32 argument) { enum Move *moves = GetMovesArray(battlerId); @@ -2710,7 +2710,7 @@ bool32 IsPowerBasedOnStatus(u32 battlerId, enum BattleMoveEffects effect, u32 ar return FALSE; } -bool32 HasMoveWithAdditionalEffect(u32 battlerId, enum MoveEffect moveEffect) +bool32 HasMoveWithAdditionalEffect(enum BattlerId battlerId, enum MoveEffect moveEffect) { enum Move *moves = GetMovesArray(battlerId); @@ -2724,7 +2724,7 @@ bool32 HasMoveWithAdditionalEffect(u32 battlerId, enum MoveEffect moveEffect) return FALSE; } -bool32 HasBattlerSideMoveWithAdditionalEffect(u32 battler, enum MoveEffect moveEffect) +bool32 HasBattlerSideMoveWithAdditionalEffect(enum BattlerId battler, enum MoveEffect moveEffect) { if (HasMoveWithAdditionalEffect(battler, moveEffect)) return TRUE; @@ -2733,7 +2733,7 @@ bool32 HasBattlerSideMoveWithAdditionalEffect(u32 battler, enum MoveEffect moveE return FALSE; } -bool32 HasMoveWithCriticalHitChance(u32 battlerId) +bool32 HasMoveWithCriticalHitChance(enum BattlerId battlerId) { enum Move *moves = GetMovesArray(battlerId); @@ -2747,7 +2747,7 @@ bool32 HasMoveWithCriticalHitChance(u32 battlerId) return FALSE; } -bool32 HasMoveWithMoveEffectExcept(u32 battlerId, enum MoveEffect moveEffect, enum BattleMoveEffects exception) +bool32 HasMoveWithMoveEffectExcept(enum BattlerId battlerId, enum MoveEffect moveEffect, enum BattleMoveEffects exception) { enum Move *moves = GetMovesArray(battlerId); @@ -2762,7 +2762,7 @@ bool32 HasMoveWithMoveEffectExcept(u32 battlerId, enum MoveEffect moveEffect, en return FALSE; } -bool32 HasMove(u32 battlerId, enum Move move) +bool32 HasMove(enum BattlerId battlerId, enum Move move) { enum Move *moves = GetMovesArray(battlerId); @@ -2775,7 +2775,7 @@ bool32 HasMove(u32 battlerId, enum Move move) return FALSE; } -bool32 HasAnyKnownMove(u32 battlerId) +bool32 HasAnyKnownMove(enum BattlerId battlerId) { enum Move *moves = GetMovesArray(battlerId); @@ -2788,7 +2788,7 @@ bool32 HasAnyKnownMove(u32 battlerId) return FALSE; } -bool32 HasMoveThatLowersOwnStats(u32 battlerId) +bool32 HasMoveThatLowersOwnStats(enum BattlerId battlerId) { enum Move aiMove; enum Move *moves = GetMovesArray(battlerId); @@ -2810,7 +2810,7 @@ bool32 HasMoveThatLowersOwnStats(u32 battlerId) return FALSE; } -bool32 HasMoveThatRaisesOwnStats(u32 battlerId) +bool32 HasMoveThatRaisesOwnStats(enum BattlerId battlerId) { enum Move aiMove; enum Move *moves = GetMovesArray(battlerId); @@ -2832,7 +2832,7 @@ bool32 HasMoveThatRaisesOwnStats(u32 battlerId) return FALSE; } -bool32 HasMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef, u32 accCheck, bool32 ignoreStatus) +bool32 HasMoveWithLowAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 accCheck, bool32 ignoreStatus) { enum Move *moves = GetMovesArray(battlerAtk); u32 moveLimitations = gAiLogicData->moveLimitations[battlerAtk]; @@ -2859,7 +2859,7 @@ bool32 HasMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef, u32 accCheck, bool return FALSE; } -bool32 HasSleepMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef) +bool32 HasSleepMoveWithLowAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef) { enum Move *moves = GetMovesArray(battlerAtk); u32 moveLimitations = gAiLogicData->moveLimitations[battlerAtk]; @@ -2876,7 +2876,7 @@ bool32 HasSleepMoveWithLowAccuracy(u32 battlerAtk, u32 battlerDef) return FALSE; } -bool32 HasHealingEffect(u32 battlerId) +bool32 HasHealingEffect(enum BattlerId battlerId) { enum Move *moves = GetMovesArray(battlerId); @@ -2903,7 +2903,7 @@ bool32 IsTrappingMove(enum Move move) } } -bool32 HasTrappingMoveEffect(u32 battler) +bool32 HasTrappingMoveEffect(enum BattlerId battler) { enum Move *moves = GetMovesArray(battler); @@ -2916,7 +2916,7 @@ bool32 HasTrappingMoveEffect(u32 battler) return FALSE; } -bool32 HasThawingMove(u32 battler) +bool32 HasThawingMove(enum BattlerId battler) { enum Move *moves = GetMovesArray(battler); for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -2927,7 +2927,7 @@ bool32 HasThawingMove(u32 battler) return FALSE; } -bool32 HasUsableWhileAsleepMove(u32 battler) +bool32 HasUsableWhileAsleepMove(enum BattlerId battler) { enum Move *moves = GetMovesArray(battler); for (u32 moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -3199,7 +3199,7 @@ static inline bool32 IsMoveSleepClauseTrigger(enum Move move) return FALSE; } -bool32 HasDamagingMove(u32 battler) +bool32 HasDamagingMove(enum BattlerId battler) { enum Move *moves = GetMovesArray(battler); @@ -3212,7 +3212,7 @@ bool32 HasDamagingMove(u32 battler) return FALSE; } -bool32 HasDamagingMoveOfType(u32 battler, enum Type type) +bool32 HasDamagingMoveOfType(enum BattlerId battler, enum Type type) { enum Move *moves = GetMovesArray(battler); @@ -3226,7 +3226,7 @@ bool32 HasDamagingMoveOfType(u32 battler, enum Type type) return TRUE; if (GetMoveType(moves[moveIndex]) == type) return TRUE; - if (GetMoveEffect(moves[moveIndex]) == EFFECT_NATURE_POWER && GetMoveType(GetNaturePowerMove(moves[moveIndex])) == type) + if (GetMoveEffect(moves[moveIndex]) == EFFECT_NATURE_POWER && GetMoveType(GetNaturePowerMove()) == type) return TRUE; } } @@ -3234,7 +3234,7 @@ bool32 HasDamagingMoveOfType(u32 battler, enum Type type) return FALSE; } -bool32 HasMoveWithFlag(u32 battler, MoveFlag getFlag) +bool32 HasMoveWithFlag(enum BattlerId battler, MoveFlag getFlag) { enum Move *moves = GetMovesArray(battler); u32 moveLimitations = gAiLogicData->moveLimitations[battler]; @@ -3250,7 +3250,7 @@ bool32 HasMoveWithFlag(u32 battler, MoveFlag getFlag) return FALSE; } -bool32 IsTwoTurnNotSemiInvulnerableMove(u32 battlerAtk, enum Move move) +bool32 IsTwoTurnNotSemiInvulnerableMove(enum BattlerId battlerAtk, enum Move move) { switch (GetMoveEffect(move)) { @@ -3263,7 +3263,7 @@ bool32 IsTwoTurnNotSemiInvulnerableMove(u32 battlerAtk, enum Move move) } } -static u32 GetLeechSeedDamage(u32 battler) +static u32 GetLeechSeedDamage(enum BattlerId battler) { u32 damage = 0; u32 leechSeeder = gBattleMons[battler].volatiles.leechSeed; @@ -3276,7 +3276,7 @@ static u32 GetLeechSeedDamage(u32 battler) return damage; } -static u32 GetNightmareDamage(u32 battlerId) +static u32 GetNightmareDamage(enum BattlerId battlerId) { u32 damage = 0; if (gBattleMons[battlerId].volatiles.nightmare @@ -3290,7 +3290,7 @@ static u32 GetNightmareDamage(u32 battlerId) return damage; } -static u32 GetCurseDamage(u32 battlerId) +static u32 GetCurseDamage(enum BattlerId battlerId) { u32 damage = 0; if (gBattleMons[battlerId].volatiles.cursed) @@ -3302,7 +3302,7 @@ static u32 GetCurseDamage(u32 battlerId) return damage; } -static u32 GetTrapDamage(u32 battler) +static u32 GetTrapDamage(enum BattlerId battler) { // ai has no knowledge about turns remaining u32 damage = 0; @@ -3319,7 +3319,7 @@ static u32 GetTrapDamage(u32 battler) return damage; } -static u32 GetPoisonDamage(u32 battlerId) +static u32 GetPoisonDamage(enum BattlerId battlerId) { u32 damage = 0; @@ -3345,7 +3345,7 @@ static u32 GetPoisonDamage(u32 battlerId) return damage; } -static bool32 BattlerAffectedBySandstorm(u32 battlerId, enum Ability ability) +static bool32 BattlerAffectedBySandstorm(enum BattlerId battlerId, enum Ability ability) { if (!IS_BATTLER_ANY_TYPE(battlerId, TYPE_ROCK, TYPE_GROUND, TYPE_STEEL) && ability != ABILITY_SAND_VEIL @@ -3356,7 +3356,7 @@ static bool32 BattlerAffectedBySandstorm(u32 battlerId, enum Ability ability) return FALSE; } -static bool32 BattlerAffectedByHail(u32 battlerId, enum Ability ability) +static bool32 BattlerAffectedByHail(enum BattlerId battlerId, enum Ability ability) { if (!IS_BATTLER_OF_TYPE(battlerId, TYPE_ICE) && ability != ABILITY_SNOW_CLOAK @@ -3366,7 +3366,7 @@ static bool32 BattlerAffectedByHail(u32 battlerId, enum Ability ability) return FALSE; } -static u32 GetWeatherDamage(u32 battlerId) +static u32 GetWeatherDamage(enum BattlerId battlerId) { enum Ability ability = gAiLogicData->abilities[battlerId]; enum HoldEffect holdEffect = gAiLogicData->holdEffects[battlerId]; @@ -3402,7 +3402,7 @@ static u32 GetWeatherDamage(u32 battlerId) return damage; } -u32 GetBattlerSecondaryDamage(u32 battlerId) +u32 GetBattlerSecondaryDamage(enum BattlerId battlerId) { u32 secondaryDamage; @@ -3419,7 +3419,7 @@ u32 GetBattlerSecondaryDamage(u32 battlerId) return secondaryDamage; } -bool32 BattlerWillFaintFromWeather(u32 battler, enum Ability ability) +bool32 BattlerWillFaintFromWeather(enum BattlerId battler, enum Ability ability) { if ((BattlerAffectedBySandstorm(battler, ability) || BattlerAffectedByHail(battler, ability)) && gBattleMons[battler].hp <= max(1, gBattleMons[battler].maxHP / 16)) @@ -3428,7 +3428,7 @@ bool32 BattlerWillFaintFromWeather(u32 battler, enum Ability ability) return FALSE; } -bool32 BattlerWillFaintFromSecondaryDamage(u32 battler, enum Ability ability) +bool32 BattlerWillFaintFromSecondaryDamage(enum BattlerId battler, enum Ability ability) { if (GetBattlerSecondaryDamage(battler) != 0 && gBattleMons[battler].hp <= max(1, gBattleMons[battler].maxHP / 16)) @@ -3436,7 +3436,7 @@ bool32 BattlerWillFaintFromSecondaryDamage(u32 battler, enum Ability ability) return FALSE; } -bool32 AnyUsefulStatIsRaised(u32 battler) +bool32 AnyUsefulStatIsRaised(enum BattlerId battler) { for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) { @@ -3463,7 +3463,7 @@ bool32 AnyUsefulStatIsRaised(u32 battler) return FALSE; } -bool32 BattlerHasMaxHPProtection(u32 battler) +bool32 BattlerHasMaxHPProtection(enum BattlerId battler) { enum Ability ability = gAiLogicData->abilities[battler]; if (!AI_BattlerAtMaxHp(battler)) @@ -3477,7 +3477,7 @@ bool32 BattlerHasMaxHPProtection(u32 battler) return FALSE; } -enum AIPivot ShouldPivot(u32 battlerAtk, u32 battlerDef, enum Move move) +enum AIPivot ShouldPivot(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { enum Move predictedMoveSpeedCheck = GetIncomingMoveSpeedCheck(battlerAtk, battlerDef, gAiLogicData); bool32 aiIsFaster = AI_IsFaster(battlerAtk, battlerDef, move, predictedMoveSpeedCheck, CONSIDER_PRIORITY); @@ -3512,7 +3512,7 @@ enum AIPivot ShouldPivot(u32 battlerAtk, u32 battlerDef, enum Move move) #define BATTLE_TYPE_CANT_KNOCK_OFF (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_FRONTIER | BATTLE_TYPE_LINK \ | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_SECRET_BASE \ | (B_TRAINERS_KNOCK_OFF_ITEMS == TRUE ? BATTLE_TYPE_TRAINER : 0)) -bool32 CanKnockOffItem(u32 fromBattler, u32 battler, enum Item item) +bool32 CanKnockOffItem(enum BattlerId fromBattler, enum BattlerId battler, enum Item item) { if (item == ITEM_NONE) return FALSE; @@ -3531,7 +3531,7 @@ bool32 CanKnockOffItem(u32 fromBattler, u32 battler, enum Item item) #undef BATTLE_TYPE_CANT_KNOCK_OFF // status checks -bool32 IsBattlerIncapacitated(u32 battler, enum Ability ability) +bool32 IsBattlerIncapacitated(enum BattlerId battler, enum Ability ability) { if ((gBattleMons[battler].status1 & STATUS1_FREEZE) && !HasThawingMove(battler)) return TRUE; // if battler has thawing move we assume they will definitely use it, and thus being frozen should be neglected @@ -3545,7 +3545,7 @@ bool32 IsBattlerIncapacitated(u32 battler, enum Ability ability) return FALSE; } -bool32 AI_CanPutToSleep(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) +bool32 AI_CanPutToSleep(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) { if (!CanBeSlept(battlerAtk, battlerDef, defAbility, BLOCKED_BY_SLEEP_CLAUSE) || DoesSubstituteBlockMove(battlerAtk, battlerDef, move) @@ -3554,7 +3554,7 @@ bool32 AI_CanPutToSleep(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, return TRUE; } -static inline bool32 DoesBattlerBenefitFromAllVolatileStatus(u32 battler, enum Ability ability) +static inline bool32 DoesBattlerBenefitFromAllVolatileStatus(enum BattlerId battler, enum Ability ability) { if (ability == ABILITY_MARVEL_SCALE || ability == ABILITY_QUICK_FEET @@ -3566,7 +3566,7 @@ static inline bool32 DoesBattlerBenefitFromAllVolatileStatus(u32 battler, enum A return FALSE; } -bool32 ShouldPoison(u32 battlerAtk, u32 battlerDef) +bool32 ShouldPoison(enum BattlerId battlerAtk, enum BattlerId battlerDef) { enum Ability abilityDef = gAiLogicData->abilities[battlerDef]; // Battler can be poisoned and has move/ability that synergizes with being poisoned @@ -3586,7 +3586,7 @@ bool32 ShouldPoison(u32 battlerAtk, u32 battlerDef) return TRUE; } -bool32 ShouldBurn(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 ShouldBurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { // Battler can be burned and has move/ability that synergizes with being burned if (CanBeBurned(battlerAtk, battlerDef, abilityDef) && ( @@ -3606,7 +3606,7 @@ bool32 ShouldBurn(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return TRUE; } -bool32 ShouldFreezeOrFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 ShouldFreezeOrFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (!B_USE_FROSTBITE) { @@ -3638,7 +3638,7 @@ bool32 ShouldFreezeOrFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abil } } -bool32 ShouldParalyze(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 ShouldParalyze(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { // Battler can be paralyzed and has move/ability that synergizes with being paralyzed if (CanBeParalyzed(battlerAtk, battlerDef, abilityDef) && ( @@ -3655,7 +3655,7 @@ bool32 ShouldParalyze(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return TRUE; } -bool32 AI_CanPoison(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) +bool32 AI_CanPoison(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) { if (!CanBePoisoned(battlerAtk, battlerDef, gAiLogicData->abilities[battlerAtk], defAbility) || gAiLogicData->effectiveness[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex] == UQ_4_12(0.0) @@ -3666,7 +3666,7 @@ bool32 AI_CanPoison(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enu return TRUE; } -bool32 AI_CanParalyze(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) +bool32 AI_CanParalyze(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum Move move, enum Move partnerMove) { if (!CanBeParalyzed(battlerAtk, battlerDef, defAbility) || gAiLogicData->effectiveness[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex] == UQ_4_12(0.0) @@ -3676,7 +3676,7 @@ bool32 AI_CanParalyze(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, e return TRUE; } -bool32 AI_CanBeConfused(u32 battlerAtk, u32 battlerDef, enum Move move, enum Ability abilityDef) +bool32 AI_CanBeConfused(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Ability abilityDef) { if (gBattleMons[battlerDef].volatiles.confusionTurns > 0 || (abilityDef == ABILITY_OWN_TEMPO && !DoesBattlerIgnoreAbilityChecks(battlerAtk, gAiLogicData->abilities[battlerAtk], move)) @@ -3687,7 +3687,7 @@ bool32 AI_CanBeConfused(u32 battlerAtk, u32 battlerDef, enum Move move, enum Abi return TRUE; } -bool32 AI_CanConfuse(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove) +bool32 AI_CanConfuse(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove) { if (AI_GetBattlerMoveTargetType(battlerAtk, move) == TARGET_FOES_AND_ALLY && AI_CanBeConfused(battlerAtk, battlerDef, move, defAbility) @@ -3701,7 +3701,7 @@ bool32 AI_CanConfuse(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u3 return TRUE; } -bool32 AI_CanBurn(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove) +bool32 AI_CanBurn(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove) { if (!CanBeBurned(battlerAtk, battlerDef, defAbility) || gAiLogicData->effectiveness[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex] == UQ_4_12(0.0) @@ -3713,7 +3713,7 @@ bool32 AI_CanBurn(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 b return TRUE; } -bool32 AI_CanGiveFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability defAbility, u32 battlerAtkPartner, enum Move move, enum Move partnerMove) +bool32 AI_CanGiveFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove) { if (!CanBeFrozen(battlerAtk, battlerDef, defAbility) || gAiLogicData->effectiveness[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex] == UQ_4_12(0.0) @@ -3725,7 +3725,7 @@ bool32 AI_CanGiveFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability defAbili return TRUE; } -bool32 AI_CanBeInfatuated(u32 battlerAtk, u32 battlerDef, enum Ability defAbility) +bool32 AI_CanBeInfatuated(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability defAbility) { if (gBattleMons[battlerDef].volatiles.infatuation || gAiLogicData->effectiveness[battlerAtk][battlerDef][gAiThinkingStruct->movesetIndex] == UQ_4_12(0.0) @@ -3736,7 +3736,7 @@ bool32 AI_CanBeInfatuated(u32 battlerAtk, u32 battlerDef, enum Ability defAbilit return TRUE; } -bool32 ShouldTryToFlinch(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move) +bool32 ShouldTryToFlinch(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability atkAbility, enum Ability defAbility, enum Move move) { enum Move predictedMoveSpeedCheck = GetIncomingMoveSpeedCheck(battlerAtk, battlerDef, gAiLogicData); if (((!IsMoldBreakerTypeAbility(battlerAtk, gAiLogicData->abilities[battlerAtk]) && (defAbility == ABILITY_SHIELD_DUST || defAbility == ABILITY_INNER_FOCUS)) @@ -3758,7 +3758,7 @@ bool32 ShouldTryToFlinch(u32 battlerAtk, u32 battlerDef, enum Ability atkAbility return FALSE; // don't try to flinch } -bool32 ShouldTrap(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 ShouldTrap(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (AI_CanBattlerEscape(battlerDef)) return FALSE; @@ -3778,7 +3778,7 @@ bool32 ShouldTrap(u32 battlerAtk, u32 battlerDef, enum Move move) return FALSE; } -bool32 IsFlinchGuaranteed(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 IsFlinchGuaranteed(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (!MoveHasAdditionalEffect(move, MOVE_EFFECT_FLINCH)) return FALSE; @@ -3810,7 +3810,7 @@ bool32 IsFlinchGuaranteed(u32 battlerAtk, u32 battlerDef, enum Move move) return FALSE; } -bool32 HasChoiceEffect(u32 battler) +bool32 HasChoiceEffect(enum BattlerId battler) { enum Ability ability = gAiLogicData->abilities[battler]; if (ability == ABILITY_GORILLA_TACTICS) @@ -3831,7 +3831,7 @@ bool32 HasChoiceEffect(u32 battler) } } -static u32 FindMoveUsedXTurnsAgo(u32 battlerId, u32 x) +static u32 FindMoveUsedXTurnsAgo(enum BattlerId battlerId, u32 x) { s32 index = gBattleHistory->moveHistoryIndex[battlerId]; for (u32 turnsAgo = 0; turnsAgo < x; turnsAgo++) @@ -3842,7 +3842,7 @@ static u32 FindMoveUsedXTurnsAgo(u32 battlerId, u32 x) return gBattleHistory->moveHistory[battlerId][index]; } -bool32 IsWakeupTurn(u32 battler) +bool32 IsWakeupTurn(enum BattlerId battler) { // Check if rest was used 2 turns ago if ((gBattleMons[battler].status1 & STATUS1_SLEEP) == 1 && GetMoveEffect(FindMoveUsedXTurnsAgo(battler, 2)) == EFFECT_REST) @@ -3851,7 +3851,7 @@ bool32 IsWakeupTurn(u32 battler) return FALSE; } -bool32 AnyPartyMemberStatused(u32 battlerId, bool32 checkSoundproof) +bool32 AnyPartyMemberStatused(enum BattlerId battlerId, bool32 checkSoundproof) { struct Pokemon *party; u32 battlerOnField1, battlerOnField2; @@ -3901,7 +3901,7 @@ bool32 AnyPartyMemberStatused(u32 battlerId, bool32 checkSoundproof) return hasStatusToCure; } -bool32 ShouldUseRecoilMove(u32 battlerAtk, u32 battlerDef, u32 recoilDmg, u32 moveIndex) +bool32 ShouldUseRecoilMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 recoilDmg, u32 moveIndex) { if (recoilDmg >= gBattleMons[battlerAtk].hp //Recoil kills attacker && CountUsablePartyMons(battlerDef) != 0) //Foe has more than 1 target left @@ -3915,7 +3915,7 @@ bool32 ShouldUseRecoilMove(u32 battlerAtk, u32 battlerDef, u32 recoilDmg, u32 mo return TRUE; } -static inline bool32 RecoveryEnablesWinning1v1(u32 battlerAtk, u32 battlerDef, enum Move move, bool32 aiIsFaster, u32 healAmount) +static inline bool32 RecoveryEnablesWinning1v1(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, bool32 aiIsFaster, u32 healAmount) { if (aiIsFaster) { @@ -3937,7 +3937,7 @@ static inline bool32 RecoveryEnablesWinning1v1(u32 battlerAtk, u32 battlerDef, e return FALSE; } -static inline bool32 ShouldDrainHPToWithstandHit(u32 battlerAtk, u32 battlerDef, u32 currHP, u32 healAmount) +static inline bool32 ShouldDrainHPToWithstandHit(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 currHP, u32 healAmount) { s32 bestDamageFromPlayer = GetBestDmgFromBattler(battlerDef, battlerAtk, AI_DEFENDING); @@ -3950,7 +3950,7 @@ static inline bool32 ShouldDrainHPToWithstandHit(u32 battlerAtk, u32 battlerDef, return FALSE; } -bool32 ShouldAbsorb(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 ShouldAbsorb(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { u32 maxHP = gBattleMons[battlerAtk].maxHP; u32 currHP = gBattleMons[battlerAtk].hp; @@ -3977,7 +3977,7 @@ bool32 ShouldAbsorb(u32 battlerAtk, u32 battlerDef, enum Move move) return FALSE; } -bool32 ShouldRecover(u32 battlerAtk, u32 battlerDef, enum Move move, u32 healPercent) +bool32 ShouldRecover(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, u32 healPercent) { u32 maxHP = gBattleMons[battlerAtk].maxHP; u32 currHP = gBattleMons[battlerAtk].hp; @@ -3996,7 +3996,7 @@ bool32 ShouldRecover(u32 battlerAtk, u32 battlerDef, enum Move move, u32 healPer return FALSE; } -bool32 ShouldSetScreen(u32 battlerAtk, u32 battlerDef, enum BattleMoveEffects moveEffect) +bool32 ShouldSetScreen(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum BattleMoveEffects moveEffect) { enum BattleSide atkSide = GetBattlerSide(battlerAtk); @@ -4031,7 +4031,7 @@ bool32 ShouldSetScreen(u32 battlerAtk, u32 battlerDef, enum BattleMoveEffects mo return FALSE; } -static bool32 ShouldCureStatusInternal(u32 battlerAtk, u32 battlerDef, bool32 usingItem, struct AiLogicData *aiData) +static bool32 ShouldCureStatusInternal(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 usingItem, struct AiLogicData *aiData) { bool32 targetingSelf = (battlerAtk == battlerDef); bool32 targetingAlly = IsTargetingPartner(battlerAtk, battlerDef); @@ -4117,12 +4117,12 @@ static bool32 ShouldCureStatusInternal(u32 battlerAtk, u32 battlerDef, bool32 us } } -bool32 ShouldCureStatus(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData) +bool32 ShouldCureStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData) { return ShouldCureStatusInternal(battlerAtk, battlerDef, FALSE, aiData); } -bool32 ShouldCureStatusWithItem(u32 battlerAtk, u32 battlerDef, struct AiLogicData *aiData) +bool32 ShouldCureStatusWithItem(enum BattlerId battlerAtk, enum BattlerId battlerDef, struct AiLogicData *aiData) { return ShouldCureStatusInternal(battlerAtk, battlerDef, TRUE, aiData); } @@ -4131,13 +4131,13 @@ bool32 ShouldCureStatusWithItem(u32 battlerAtk, u32 battlerDef, struct AiLogicDa bool32 IsBattle1v1(void) { if (IsDoubleBattle() - && ((IsBattlerAlive(B_POSITION_PLAYER_LEFT) && IsBattlerAlive(B_POSITION_PLAYER_RIGHT)) - || (IsBattlerAlive(B_POSITION_OPPONENT_LEFT) && IsBattlerAlive(B_POSITION_OPPONENT_RIGHT)))) + && ((IsBattlerAlive(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)) && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT))) + || (IsBattlerAlive(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT))))) return FALSE; return TRUE; } -bool32 HasTwoOpponents(u32 battler) +bool32 HasTwoOpponents(enum BattlerId battler) { if (IsDoubleBattle() && IsBattlerAlive(LEFT_FOE(battler)) && IsBattlerAlive(RIGHT_FOE(battler))) @@ -4145,7 +4145,7 @@ bool32 HasTwoOpponents(u32 battler) return FALSE; } -bool32 HasPartner(u32 battler) +bool32 HasPartner(enum BattlerId battler) { if (IsDoubleBattle() && IsBattlerAlive(BATTLE_PARTNER(battler))) { @@ -4157,7 +4157,7 @@ bool32 HasPartner(u32 battler) return FALSE; } -bool32 HasPartnerIgnoreFlags(u32 battler) +bool32 HasPartnerIgnoreFlags(enum BattlerId battler) { if (IsDoubleBattle() && IsBattlerAlive(BATTLE_PARTNER(battler))) { @@ -4166,31 +4166,31 @@ bool32 HasPartnerIgnoreFlags(u32 battler) return FALSE; } -bool32 IsTargetingPartner(u32 battlerAtk, u32 battlerDef) +bool32 IsTargetingPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_ATTACKS_PARTNER) return FALSE; return ((battlerAtk) == (battlerDef ^ BIT_FLANK)); } -enum Move GetAllyChosenMove(u32 battlerId) +enum Move GetAllyChosenMove(enum BattlerId battlerId) { - u32 partnerBattler = BATTLE_PARTNER(battlerId); + enum BattlerId partnerBattler = BATTLE_PARTNER(battlerId); if (!IsBattlerAlive(partnerBattler) || !IsAiBattlerAware(partnerBattler)) return MOVE_NONE; else if (partnerBattler > battlerId) // Battler with the lower id chooses the move first. return gAiLogicData->lastUsedMove[partnerBattler]; else - return GetChosenMoveFromPosition(partnerBattler); + return GetBattlerChosenMove(partnerBattler); } -bool32 AreMovesEquivalent(u32 battlerAtk, u32 battlerAtkPartner, enum Move move, enum Move partnerMove) +bool32 AreMovesEquivalent(enum BattlerId battlerAtk, enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove) { if (!IsBattlerAlive(battlerAtkPartner) || partnerMove == MOVE_NONE) return FALSE; - u32 battlerDef = gBattleStruct->moveTarget[battlerAtk]; + enum BattlerId battlerDef = gBattleStruct->moveTarget[battlerAtk]; // We don't care the effect is basically the same; we would use this move anyway. if (IsBestDmgMove(battlerAtk, battlerDef, AI_ATTACKING, move)) @@ -4279,7 +4279,7 @@ static u32 GetAIEffectGroup(enum BattleMoveEffects effect) return aiEffect; } -static u32 GetAIEffectGroupFromMove(u32 battler, enum Move move) +static u32 GetAIEffectGroupFromMove(enum BattlerId battler, enum Move move) { u32 aiEffect = GetAIEffectGroup(GetMoveEffect(move)); @@ -4334,7 +4334,7 @@ static u32 GetAIEffectGroupFromMove(u32 battler, enum Move move) } // It matches both on move effect and on AI move effect; eg, EFFECT_HAZE will also bring up Freezy Frost or Clear Smog, anything with AI_EFFECT_RESET_STATS. -bool32 DoesPartnerHaveSameMoveEffect(u32 battlerAtkPartner, u32 battlerDef, enum Move move, enum Move partnerMove) +bool32 DoesPartnerHaveSameMoveEffect(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move move, enum Move partnerMove) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4352,7 +4352,7 @@ bool32 DoesPartnerHaveSameMoveEffect(u32 battlerAtkPartner, u32 battlerDef, enum } //PARTNER_MOVE_EFFECT_IS_STATUS_SAME_TARGET -bool32 PartnerMoveEffectIsStatusSameTarget(u32 battlerAtkPartner, u32 battlerDef, enum Move partnerMove) +bool32 PartnerMoveEffectIsStatusSameTarget(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move partnerMove) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4372,7 +4372,7 @@ bool32 PartnerMoveEffectIsStatusSameTarget(u32 battlerAtkPartner, u32 battlerDef } //PARTNER_MOVE_EFFECT_IS -bool32 PartnerMoveEffectIs(u32 battlerAtkPartner, enum Move partnerMove, enum BattleMoveEffects effectCheck) +bool32 PartnerMoveEffectIs(enum BattlerId battlerAtkPartner, enum Move partnerMove, enum BattleMoveEffects effectCheck) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4384,7 +4384,7 @@ bool32 PartnerMoveEffectIs(u32 battlerAtkPartner, enum Move partnerMove, enum Ba } //PARTNER_MOVE_IS_TAILWIND_TRICKROOM -bool32 PartnerMoveIs(u32 battlerAtkPartner, enum Move partnerMove, enum Move moveCheck) +bool32 PartnerMoveIs(enum BattlerId battlerAtkPartner, enum Move partnerMove, enum Move moveCheck) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4395,7 +4395,7 @@ bool32 PartnerMoveIs(u32 battlerAtkPartner, enum Move partnerMove, enum Move mov } //PARTNER_MOVE_IS_SAME -bool32 PartnerMoveIsSameAsAttacker(u32 battlerAtkPartner, u32 battlerDef, enum Move move, enum Move partnerMove) +bool32 PartnerMoveIsSameAsAttacker(enum BattlerId battlerAtkPartner, enum BattlerId battlerDef, enum Move move, enum Move partnerMove) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4406,7 +4406,7 @@ bool32 PartnerMoveIsSameAsAttacker(u32 battlerAtkPartner, u32 battlerDef, enum M } //PARTNER_MOVE_IS_SAME_NO_TARGET -bool32 PartnerMoveIsSameNoTarget(u32 battlerAtkPartner, enum Move move, enum Move partnerMove) +bool32 PartnerMoveIsSameNoTarget(enum BattlerId battlerAtkPartner, enum Move move, enum Move partnerMove) { if (!HasPartner(battlerAtkPartner)) return FALSE; @@ -4422,7 +4422,7 @@ bool32 PartnerMoveActivatesSleepClause(enum Move partnerMove) return IsMoveSleepClauseTrigger(partnerMove); } -bool32 ShouldUseWishAromatherapy(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 ShouldUseWishAromatherapy(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { s32 firstId, lastId; struct Pokemon *party; @@ -4516,7 +4516,7 @@ void FreeRestoreAiLogicData(struct AiLogicData *savedAiLogicData) } // Set potential field effect from ability for switch in -void SetBattlerFieldStatusForSwitchin(u32 battler) +void SetBattlerFieldStatusForSwitchin(enum BattlerId battler) { switch (gAiLogicData->abilities[battler]) { @@ -4538,7 +4538,7 @@ void SetBattlerFieldStatusForSwitchin(u32 battler) } // party logic -s32 CountUsablePartyMons(u32 battlerId) +s32 CountUsablePartyMons(enum BattlerId battlerId) { s32 battlerOnField1, battlerOnField2, ret; struct Pokemon *party; @@ -4572,7 +4572,7 @@ s32 CountUsablePartyMons(u32 battlerId) return ret; } -bool32 IsPartyFullyHealedExceptBattler(u32 battlerId) +bool32 IsPartyFullyHealedExceptBattler(enum BattlerId battlerId) { struct Pokemon *party = GetBattlerParty(battlerId); @@ -4588,7 +4588,7 @@ bool32 IsPartyFullyHealedExceptBattler(u32 battlerId) return TRUE; } -bool32 PartyHasMoveCategory(u32 battlerId, enum DamageCategory category) +bool32 PartyHasMoveCategory(enum BattlerId battlerId, enum DamageCategory category) { struct Pokemon *party = GetBattlerParty(battlerId); @@ -4614,7 +4614,7 @@ bool32 PartyHasMoveCategory(u32 battlerId, enum DamageCategory category) return FALSE; } -bool32 SideHasMoveCategory(u32 battlerId, enum DamageCategory category) +bool32 SideHasMoveCategory(enum BattlerId battlerId, enum DamageCategory category) { if (HasPartnerIgnoreFlags(battlerId)) { @@ -4682,7 +4682,7 @@ bool32 IsStatBoostingBerry(enum Item item) } } -bool32 ShouldRestoreHpBerry(u32 battlerAtk, enum Item item) +bool32 ShouldRestoreHpBerry(enum BattlerId battlerAtk, enum Item item) { switch (item) { @@ -4712,7 +4712,7 @@ bool32 IsRecycleEncouragedItem(enum Item item) return FALSE; } -static bool32 HasMoveThatChangesKOThreshold(u32 battlerId, u32 noOfHitsToFaint, bool32 aiIsFaster) +static bool32 HasMoveThatChangesKOThreshold(enum BattlerId battlerId, u32 noOfHitsToFaint, bool32 aiIsFaster) { enum Move *moves = GetMovesArray(battlerId); @@ -4810,7 +4810,7 @@ static u32 GetStagesOfStatChange(enum StatChange statChange) return 0; // STAT_HP, should never be getting changed } -static enum AIScore IncreaseStatUpScoreInternal(u32 battlerAtk, u32 battlerDef, enum StatChange statChange, bool32 considerContrary) +static enum AIScore IncreaseStatUpScoreInternal(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum StatChange statChange, bool32 considerContrary) { enum AIScore tempScore = NO_INCREASE; u32 noOfHitsToFaint = NoOfHitsForTargetToFaintBattler(battlerDef, battlerAtk, DONT_CONSIDER_ENDURE); @@ -4934,7 +4934,7 @@ static enum AIScore IncreaseStatUpScoreInternal(u32 battlerAtk, u32 battlerDef, return tempScore; } -bool32 HasHPForDamagingSetup(u32 battlerAtk, u32 battlerDef, u32 hpThreshold) +bool32 HasHPForDamagingSetup(enum BattlerId battlerAtk, enum BattlerId battlerDef, u32 hpThreshold) { bool32 bestMoveIsPhysical = HasPhysicalBestMove(battlerDef, battlerAtk, AI_DEFENDING); @@ -4955,17 +4955,17 @@ bool32 HasHPForDamagingSetup(u32 battlerAtk, u32 battlerDef, u32 hpThreshold) return FALSE; } -enum AIScore IncreaseStatUpScore(u32 battlerAtk, u32 battlerDef, enum StatChange statChange) +enum AIScore IncreaseStatUpScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum StatChange statChange) { return IncreaseStatUpScoreInternal(battlerAtk, battlerDef, statChange, TRUE); } -enum AIScore IncreaseStatUpScoreContrary(u32 battlerAtk, u32 battlerDef, enum StatChange statChange) +enum AIScore IncreaseStatUpScoreContrary(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum StatChange statChange) { return IncreaseStatUpScoreInternal(battlerAtk, battlerDef, statChange, FALSE); } -void IncreasePoisonScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreasePoisonScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (((gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_TRY_TO_FAINT) && CanAIFaintTarget(battlerAtk, battlerDef, 0)) || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_PSN || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_STATUS) @@ -4988,7 +4988,7 @@ void IncreasePoisonScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *sc } } -void IncreaseBurnScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseBurnScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (((gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_TRY_TO_FAINT) && CanAIFaintTarget(battlerAtk, battlerDef, 0)) || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_BRN || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_STATUS) @@ -5029,7 +5029,7 @@ void IncreaseBurnScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *scor } } -void IncreaseParalyzeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseParalyzeScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (((gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_TRY_TO_FAINT) && CanAIFaintTarget(battlerAtk, battlerDef, 0)) || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_PAR || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_STATUS) @@ -5051,7 +5051,7 @@ void IncreaseParalyzeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 * } } -void IncreaseSleepScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseSleepScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_SLP || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_STATUS) return; @@ -5083,7 +5083,7 @@ void IncreaseSleepScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *sco ADJUST_SCORE_PTR(WEAK_EFFECT); } -void IncreaseConfusionScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseConfusionScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (((gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_TRY_TO_FAINT) && CanAIFaintTarget(battlerAtk, battlerDef, 0)) || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_CONFUSION || gAiLogicData->holdEffects[battlerDef] == HOLD_EFFECT_CURE_STATUS) @@ -5102,7 +5102,7 @@ void IncreaseConfusionScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 } } -void IncreaseFrostbiteScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseFrostbiteScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if ((gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_TRY_TO_FAINT) && CanAIFaintTarget(battlerAtk, battlerDef, 0)) return; @@ -5142,7 +5142,7 @@ void IncreaseFrostbiteScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 } } -bool32 AI_MoveMakesContact(u32 battlerAtk, u32 battlerDef, enum Ability ability, enum HoldEffect holdEffect, enum Move move) +bool32 AI_MoveMakesContact(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability ability, enum HoldEffect holdEffect, enum Move move) { if (GetMoveEffect(move) == EFFECT_SHELL_SIDE_ARM) { @@ -5163,7 +5163,7 @@ bool32 AI_MoveMakesContact(u32 battlerAtk, u32 battlerDef, enum Ability ability, return TRUE; } -bool32 IsUnseenFistContactMove(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 IsUnseenFistContactMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (move == MOVE_NONE || move == MOVE_UNAVAILABLE) return FALSE; @@ -5186,7 +5186,7 @@ bool32 IsUnseenFistContactMove(u32 battlerAtk, u32 battlerDef, enum Move move) } -bool32 IsConsideringZMove(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 IsConsideringZMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (GetMovePower(move) == 0 && GetMoveZEffect(move) == Z_EFFECT_NONE) return FALSE; @@ -5195,7 +5195,7 @@ bool32 IsConsideringZMove(u32 battlerAtk, u32 battlerDef, enum Move move) } //TODO - this could use some more sophisticated logic -bool32 ShouldUseZMove(u32 battlerAtk, u32 battlerDef, enum Move chosenMove) +bool32 ShouldUseZMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move chosenMove) { // simple logic. just upgrades chosen move to z move if possible, unless regular move would kill opponent enum MoveTarget target = AI_GetBattlerMoveTargetType(battlerAtk, chosenMove); @@ -5365,7 +5365,7 @@ bool32 ShouldUseZMove(u32 battlerAtk, u32 battlerDef, enum Move chosenMove) return FALSE; } -void SetAIUsingGimmick(u32 battler, enum AIConsiderGimmick use) +void SetAIUsingGimmick(enum BattlerId battler, enum AIConsiderGimmick use) { if (use == USE_GIMMICK) gAiBattleData->aiUsingGimmick |= (1<aiUsingGimmick &= ~(1<aiUsingGimmick & (1<gimmick.usableGimmick[battler] != GIMMICK_TERA) return; @@ -5401,7 +5401,7 @@ void DecideTerastal(u32 battler) // TODO: A lot of these checks are most effective for an omnicient ai. // If we don't have enough information about the opponent's moves, consider simpler checks based on type effectivness. - u32 opposingBattler = GetOppositeBattler(battler); + enum BattlerId opposingBattler = GetOppositeBattler(battler); // Default calculations automatically assume gimmicks for the attacker, but not the defender. // Consider calcs for the other possibilities. @@ -5466,7 +5466,7 @@ void DecideTerastal(u32 battler) #define takenWithTera altCalcs->takenWithTera #define takenWithoutTera gAiLogicData->simulatedDmg[opposingBattler][battler] -enum AIConsiderGimmick ShouldTeraFromCalcs(u32 battler, u32 opposingBattler, struct AltTeraCalcs *altCalcs) +enum AIConsiderGimmick ShouldTeraFromCalcs(enum BattlerId battler, enum BattlerId opposingBattler, struct AltTeraCalcs *altCalcs) { struct Pokemon *party = GetBattlerParty(battler); @@ -5628,12 +5628,12 @@ enum AIConsiderGimmick ShouldTeraFromCalcs(u32 battler, u32 opposingBattler, str #undef takenWithTera #undef takenWithoutTera -bool32 AI_IsBattlerAsleepOrComatose(u32 battlerId) +bool32 AI_IsBattlerAsleepOrComatose(enum BattlerId battlerId) { return (gBattleMons[battlerId].status1 & STATUS1_SLEEP) || gAiLogicData->abilities[battlerId] == ABILITY_COMATOSE; } -s32 AI_TryToClearStats(u32 battlerAtk, u32 battlerDef, bool32 isDoubleBattle) +s32 AI_TryToClearStats(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 isDoubleBattle) { if (isDoubleBattle) return min(CountPositiveStatStages(battlerDef) + CountPositiveStatStages(BATTLE_PARTNER(battlerDef)), 7); @@ -5641,7 +5641,7 @@ s32 AI_TryToClearStats(u32 battlerAtk, u32 battlerDef, bool32 isDoubleBattle) return min(CountPositiveStatStages(battlerDef), 4); } -bool32 AI_ShouldCopyStatChanges(u32 battlerAtk, u32 battlerDef) +bool32 AI_ShouldCopyStatChanges(enum BattlerId battlerAtk, enum BattlerId battlerDef) { // Want to copy positive stat changes for (enum Stat statId = STAT_ATK; statId < NUM_BATTLE_STATS; statId++) @@ -5672,7 +5672,7 @@ bool32 AI_ShouldCopyStatChanges(u32 battlerAtk, u32 battlerDef) } //TODO - track entire opponent party data to determine hazard effectiveness -bool32 AI_ShouldSetUpHazards(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +bool32 AI_ShouldSetUpHazards(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { if (CountUsablePartyMons(battlerDef) == 0 || HasBattlerSideMoveWithAIEffect(battlerDef, AI_EFFECT_CLEAR_HAZARDS)) @@ -5697,7 +5697,7 @@ bool32 AI_ShouldSetUpHazards(u32 battlerAtk, u32 battlerDef, enum Move move, str return TRUE; } -void IncreaseTidyUpScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score) +void IncreaseTidyUpScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score) { if (AreAnyHazardsOnSide(GetBattlerSide(battlerAtk)) && CountUsablePartyMons(battlerAtk) != 0) ADJUST_SCORE_PTR(GOOD_EFFECT); @@ -5715,12 +5715,12 @@ void IncreaseTidyUpScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *sc ADJUST_SCORE_PTR(-2); } -bool32 AI_ShouldSpicyExtract(u32 battlerAtk, u32 battlerAtkPartner, enum Move move, struct AiLogicData *aiData) +bool32 AI_ShouldSpicyExtract(enum BattlerId battlerAtk, enum BattlerId battlerAtkPartner, enum Move move, struct AiLogicData *aiData) { bool32 preventsStatLoss; enum Ability partnerAbility = aiData->abilities[battlerAtkPartner]; enum BattlerPosition opposingPosition = BATTLE_OPPOSITE(GetBattlerPosition(battlerAtk)); - u32 opposingBattler = GetBattlerAtPosition(opposingPosition); + enum BattlerId opposingBattler = GetBattlerAtPosition(opposingPosition); if (gBattleMons[battlerAtkPartner].statStages[STAT_ATK] == MAX_STAT_STAGE || partnerAbility == ABILITY_CONTRARY @@ -5748,7 +5748,7 @@ bool32 AI_ShouldSpicyExtract(u32 battlerAtk, u32 battlerAtkPartner, enum Move mo && HasMoveWithCategory(battlerAtkPartner, DAMAGE_CATEGORY_PHYSICAL)); } -u32 IncreaseSubstituteMoveScore(u32 battlerAtk, u32 battlerDef, enum Move move) +u32 IncreaseSubstituteMoveScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { enum BattleMoveEffects effect = GetMoveEffect(move); u32 scoreIncrease = 0; @@ -5788,7 +5788,7 @@ u32 IncreaseSubstituteMoveScore(u32 battlerAtk, u32 battlerDef, enum Move move) return scoreIncrease; } -bool32 IsBattlerItemEnabled(u32 battler) +bool32 IsBattlerItemEnabled(enum BattlerId battler) { if (gAiThinkingStruct->aiFlags[battler] & AI_FLAG_NEGATE_UNAWARE) return TRUE; @@ -5801,7 +5801,7 @@ bool32 IsBattlerItemEnabled(u32 battler) return TRUE; } -u32 GetFriendlyFireKOThreshold(u32 battler) +u32 GetFriendlyFireKOThreshold(enum BattlerId battler) { if (gAiThinkingStruct->aiFlags[battler] & AI_FLAG_RISKY) return FRIENDLY_FIRE_RISKY_THRESHOLD; @@ -5858,7 +5858,7 @@ bool32 DoesIntimidateRaiseStats(enum Ability ability) } // TODO: work out when to attack into the player's contextually 'beneficial' ability -bool32 ShouldTriggerAbility(u32 battlerAtk, u32 battlerDef, enum Ability ability) +bool32 ShouldTriggerAbility(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability ability) { if (IsTargetingPartner(battlerAtk, battlerDef)) { @@ -5913,7 +5913,7 @@ bool32 ShouldTriggerAbility(u32 battlerAtk, u32 battlerDef, enum Ability ability // Used by CheckBadMove; this is determining purely if the effect CAN change an ability, not if it SHOULD. // At the moment, the parts about Mummy and Wandering Spirit are not actually used. -bool32 CanEffectChangeAbility(u32 battlerAtk, u32 battlerDef, enum Move move, struct AiLogicData *aiData) +bool32 CanEffectChangeAbility(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, struct AiLogicData *aiData) { enum BattleMoveEffects effect = GetMoveEffect(move); @@ -6046,7 +6046,7 @@ bool32 DoesEffectReplaceTargetAbility(u32 effect) } } -void AbilityChangeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *score, struct AiLogicData *aiData) +void AbilityChangeScore(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, s32 *score, struct AiLogicData *aiData) { enum BattleMoveEffects effect = GetMoveEffect(move); bool32 isTargetingPartner = IsTargetingPartner(battlerAtk, battlerDef); @@ -6119,7 +6119,7 @@ void AbilityChangeScore(u32 battlerAtk, u32 battlerDef, enum Move move, s32 *sco } } -enum AIScore BattlerBenefitsFromAbilityScore(u32 battler, enum Ability ability, struct AiLogicData *aiData) +enum AIScore BattlerBenefitsFromAbilityScore(enum BattlerId battler, enum Ability ability, struct AiLogicData *aiData) { if (gAbilitiesInfo[ability].aiRating < 0) return WORST_EFFECT; @@ -6272,7 +6272,7 @@ u32 GetAIExplosionChanceFromHP(u32 hpPercent) return (EXPLOSION_HIGHER_HP_THRESHOLD - hpPercent); } -bool32 ShouldFinalGambit(u32 battlerAtk, u32 battlerDef, bool32 aiIsFaster) +bool32 ShouldFinalGambit(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 aiIsFaster) { if (!gAiLogicData->shouldConsiderFinalGambit) return FALSE; @@ -6291,7 +6291,7 @@ bool32 ShouldFinalGambit(u32 battlerAtk, u32 battlerDef, bool32 aiIsFaster) return FALSE; } -bool32 ShouldConsiderSelfSacrificeDamageEffect(u32 battlerAtk, u32 battlerDef, enum Move move, bool32 aiIsFaster) +bool32 ShouldConsiderSelfSacrificeDamageEffect(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, bool32 aiIsFaster) { if (gAiThinkingStruct->aiFlags[battlerAtk] & AI_FLAG_WILL_SUICIDE) return TRUE; @@ -6302,7 +6302,7 @@ bool32 ShouldConsiderSelfSacrificeDamageEffect(u32 battlerAtk, u32 battlerDef, e return FALSE; } -bool32 AiExpectsToFaintPlayer(u32 battler) +bool32 AiExpectsToFaintPlayer(enum BattlerId battler) { u8 target = gAiBattleData->chosenTarget[battler]; @@ -6320,10 +6320,10 @@ bool32 AiExpectsToFaintPlayer(u32 battler) return FALSE; } -bool32 AI_OpponentCanFaintAiWithMod(u32 battler, u32 healAmount) +bool32 AI_OpponentCanFaintAiWithMod(enum BattlerId battler, u32 healAmount) { // Check special cases to NOT heal - for (u32 battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) + for (enum BattlerId battlerIndex = 0; battlerIndex < gBattlersCount; battlerIndex++) { if (IsOnPlayerSide(battlerIndex) && CanTargetFaintAiWithMod(battlerIndex, battler, healAmount, 0)) { @@ -6334,7 +6334,7 @@ bool32 AI_OpponentCanFaintAiWithMod(u32 battler, u32 healAmount) return FALSE; } -void GetAIPartyIndexes(u32 battler, s32 *firstId, s32 *lastId) +void GetAIPartyIndexes(enum BattlerId battler, s32 *firstId, s32 *lastId) { if (BATTLE_TWO_VS_ONE_OPPONENT && (battler & BIT_SIDE) == B_SIDE_OPPONENT) { @@ -6353,7 +6353,7 @@ void GetAIPartyIndexes(u32 battler, s32 *firstId, s32 *lastId) } } -bool32 ShouldInstructPartner(u32 partner, enum Move move) +bool32 ShouldInstructPartner(enum BattlerId partner, enum Move move) { if (GetMoveEffect(move) == EFFECT_MAX_HP_50_RECOIL && gAiLogicData->abilities[partner] != ABILITY_MAGIC_GUARD) return FALSE; @@ -6377,7 +6377,7 @@ bool32 ShouldInstructPartner(u32 partner, enum Move move) return FALSE; } -bool32 CanMoveBeBouncedBack(u32 battler, enum Move move) +bool32 CanMoveBeBouncedBack(enum BattlerId battler, enum Move move) { if (!MoveCanBeBouncedBack(move) || !IsBattleMoveStatus(move)) return FALSE; @@ -6397,9 +6397,9 @@ bool32 CanMoveBeBouncedBack(u32 battler, enum Move move) return FALSE; } -u32 GetActiveBattlerIds(u32 battler, u32 *battlerIn1, u32 *battlerIn2) +u32 GetActiveBattlerIds(enum BattlerId battler, enum BattlerId *battlerIn1, enum BattlerId *battlerIn2) { - u32 opposingBattler = 0; + enum BattlerId opposingBattler = 0; enum BattlerPosition battlerPosition = GetBattlerPosition(battler); if (IsDoubleBattle()) { @@ -6423,7 +6423,7 @@ u32 GetActiveBattlerIds(u32 battler, u32 *battlerIn1, u32 *battlerIn2) return opposingBattler; } -bool32 IsPartyMonOnFieldOrChosenToSwitch(u32 partyIndex, u32 battlerIn1, u32 battlerIn2) +bool32 IsPartyMonOnFieldOrChosenToSwitch(u32 partyIndex, enum BattlerId battlerIn1, enum BattlerId battlerIn2) { if (partyIndex == gBattlerPartyIndexes[battlerIn1] || partyIndex == gBattlerPartyIndexes[battlerIn2]) diff --git a/src/battle_anim.c b/src/battle_anim.c index 49bcd5b7b0..68c180d9fe 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -116,8 +116,8 @@ EWRAM_DATA static u8 sMonAnimTaskIdArray[2] = {0}; EWRAM_DATA u8 gAnimMoveTurn = 0; EWRAM_DATA static u8 sAnimBackgroundFadeState = 0; EWRAM_DATA u16 gAnimMoveIndex = 0; -EWRAM_DATA u8 gBattleAnimAttacker = 0; -EWRAM_DATA u8 gBattleAnimTarget = 0; +EWRAM_DATA enum BattlerId gBattleAnimAttacker = 0; +EWRAM_DATA enum BattlerId gBattleAnimTarget = 0; EWRAM_DATA u16 gAnimBattlerSpecies[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gAnimCustomPanning = 0; EWRAM_DATA static bool8 sAnimHideHpBoxes = FALSE; @@ -557,13 +557,13 @@ static void Cmd_unloadspritegfx(void) ClearSpriteIndex(GET_TRUE_SPRITE_INDEX(index)); } -static u8 GetBattleAnimMoveTargets(u8 battlerArgIndex, u8 *targets) +static u8 GetBattleAnimMoveTargets(u8 battlerArgIndex, enum BattlerId *targets) { u8 numTargets = 0; - u32 battlerAnimId = gBattleAnimArgs[battlerArgIndex]; // ANIM_xx input - u32 i; - u32 ignoredTgt = gBattlerAttacker; - u32 target = GetBattlerMoveTargetType(gBattleAnimAttacker, gAnimMoveIndex); + enum AnimBattler battlerAnimId = gBattleAnimArgs[battlerArgIndex]; // ANIM_xx input + enum BattlerId i; + enum BattlerId ignoredTgt; + enum MoveTarget target = GetBattlerMoveTargetType(gBattleAnimAttacker, gAnimMoveIndex); switch (battlerAnimId) { @@ -573,6 +573,7 @@ static u8 GetBattleAnimMoveTargets(u8 battlerArgIndex, u8 *targets) break; case ANIM_TARGET: case ANIM_DEF_PARTNER: + default: ignoredTgt = gBattlerAttacker; break; } @@ -675,8 +676,9 @@ static void Cmd_createsprite(void) static void CreateSpriteOnTargets(const struct SpriteTemplate *template, u8 argVar, u8 battlerArgIndex, u8 argsCount, bool32 overwriteAnimTgt) { - u32 i, battler; - u8 targets[MAX_BATTLERS_COUNT]; + u32 i; + enum BattlerId battler; + enum BattlerId targets[MAX_BATTLERS_COUNT]; int ntargets; s16 subpriority; @@ -694,7 +696,7 @@ static void CreateSpriteOnTargets(const struct SpriteTemplate *template, u8 argV for (i = 0; i < ntargets; i++) { - battler = GetAnimBattlerId(targets[i]); + battler = targets[i]; if (overwriteAnimTgt) gBattleAnimArgs[battlerArgIndex] = targets[i]; @@ -794,7 +796,7 @@ static void Cmd_createvisualtaskontargets(void) u8 numArgs; u8 battlerArgIndex; // index in gBattleAnimArgs that has the battlerId s32 i; - u8 targets[MAX_BATTLERS_COUNT] = {0}; + enum BattlerId targets[MAX_BATTLERS_COUNT] = {0}; sBattleAnimScriptPtr++; @@ -985,8 +987,8 @@ static void Cmd_monbg(void) { bool8 toBG_2; u8 taskId; - u8 battler; - u8 animBattler; + enum BattlerId battler; + enum AnimBattler animBattler; sBattleAnimScriptPtr++; @@ -1039,7 +1041,7 @@ static void Cmd_monbg(void) gAnimScriptCallback = WaitAnimFrameCount; } -u8 GetAnimBattlerId(u8 wantedBattler) +enum BattlerId GetAnimBattlerId(enum AnimBattler wantedBattler) { switch (wantedBattler) { @@ -1057,7 +1059,7 @@ u8 GetAnimBattlerId(u8 wantedBattler) } } -bool8 IsBattlerSpriteVisible(u8 battler) +bool8 IsBattlerSpriteVisible(enum BattlerId battler) { if (IsContest()) { @@ -1076,7 +1078,7 @@ bool8 IsBattlerSpriteVisible(u8 battler) return FALSE; } -void MoveBattlerSpriteToBG(u8 battler, bool8 toBG_2, bool8 setSpriteInvisible) +void MoveBattlerSpriteToBG(enum BattlerId battler, bool8 toBG_2, bool8 setSpriteInvisible) { struct BattleAnimBgData animBg; u8 battlerSpriteId; @@ -1262,8 +1264,8 @@ static void Task_UpdateMonBg(u8 taskId) static void Cmd_clearmonbg(void) { - u8 animBattlerId; - u8 battler; + enum AnimBattler animBattlerId; + enum BattlerId battler; u8 taskId; sBattleAnimScriptPtr++; @@ -1325,8 +1327,8 @@ static void Task_ClearMonBg(u8 taskId) static void Cmd_monbg_static(void) { bool8 toBG_2; - u8 battler; - u8 animBattlerId; + enum BattlerId battler; + enum AnimBattler animBattlerId; sBattleAnimScriptPtr++; @@ -1370,8 +1372,8 @@ static void Cmd_monbg_static(void) static void Cmd_clearmonbg_static(void) { - u8 animBattlerId; - u8 battler; + enum AnimBattler animBattlerId; + enum BattlerId battler; u8 taskId; sBattleAnimScriptPtr++; @@ -1407,7 +1409,7 @@ static void Task_ClearMonBgStatic(u8 taskId) if (gTasks[taskId].data[1] != 1) { bool8 toBG_2; - u8 battler = gTasks[taskId].data[2]; + enum BattlerId battler = gTasks[taskId].data[2]; enum BattlerPosition position = GetBattlerPosition(battler); if (position == B_POSITION_OPPONENT_LEFT || position == B_POSITION_PLAYER_RIGHT || IsContest()) toBG_2 = FALSE; @@ -2094,8 +2096,8 @@ static void Cmd_jumpifcontest(void) static void Cmd_splitbgprio(void) { - u8 wantedBattler; - u8 battler; + enum AnimBattler wantedBattler; + enum BattlerId battler; enum BattlerPosition battlerPosition; wantedBattler = sBattleAnimScriptPtr[1]; @@ -2127,9 +2129,9 @@ static void Cmd_splitbgprio_all(void) static void Cmd_splitbgprio_foes(void) { - u8 wantedBattler; + enum AnimBattler wantedBattler; enum BattlerPosition battlerPosition; - u8 battler; + enum BattlerId battler; wantedBattler = sBattleAnimScriptPtr[1]; sBattleAnimScriptPtr += 2; @@ -2154,9 +2156,8 @@ static void Cmd_splitbgprio_foes(void) static void Cmd_invisible(void) { - u8 spriteId; - - spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + enum AnimBattler animBattler = sBattleAnimScriptPtr[1]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId != SPRITE_NONE) gSprites[spriteId].invisible = TRUE; @@ -2165,9 +2166,8 @@ static void Cmd_invisible(void) static void Cmd_visible(void) { - u8 spriteId; - - spriteId = GetAnimBattlerSpriteId(sBattleAnimScriptPtr[1]); + enum AnimBattler animBattler = sBattleAnimScriptPtr[1]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId != SPRITE_NONE) gSprites[spriteId].invisible = FALSE; diff --git a/src/battle_anim_dark.c b/src/battle_anim_dark.c index b96f9f43bb..a15d024e2d 100644 --- a/src/battle_anim_dark.c +++ b/src/battle_anim_dark.c @@ -273,7 +273,7 @@ static void AnimPunishment(struct Sprite *sprite) void AnimTask_AttackerFadeToInvisible(u8 taskId) { - int battler; + enum BattlerId battler; gTasks[taskId].data[0] = gBattleAnimArgs[0]; battler = gBattleAnimAttacker; gTasks[taskId].data[1] = 16; @@ -430,7 +430,7 @@ static void AnimBite_Step2(struct Sprite *sprite) // Launches a tear drop away from the battler. Used by Fake Tears void AnimTearDrop(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; s8 xOffset; if (gBattleAnimArgs[0] == ANIM_ATTACKER) @@ -1008,17 +1008,18 @@ static void AnimTask_MetallicShine_Step(u8 taskId) void AnimTask_SetGrayscaleOrOriginalPal(u8 taskId) { u8 spriteId; - u8 battler; + enum BattlerId battler; bool8 calcSpriteId = FALSE; u8 position = B_POSITION_PLAYER_LEFT; + enum AnimBattler animBattler = gBattleAnimArgs[0]; - switch (gBattleAnimArgs[0]) + switch (animBattler) { case ANIM_ATTACKER: case ANIM_TARGET: case ANIM_ATK_PARTNER: case ANIM_DEF_PARTNER: - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + spriteId = GetAnimBattlerSpriteId(animBattler); break; case ANIM_PLAYER_LEFT: position = B_POSITION_PLAYER_LEFT; diff --git a/src/battle_anim_effects_1.c b/src/battle_anim_effects_1.c index adc75f2656..20c1552cf3 100644 --- a/src/battle_anim_effects_1.c +++ b/src/battle_anim_effects_1.c @@ -3873,7 +3873,7 @@ void AnimTeraStarstormStars(struct Sprite *sprite) sprite->data[3] = sprite->y; if (gBattleAnimArgs[5] == 1) { - u32 targetPartner; + enum BattlerId targetPartner; if (IsOnPlayerSide(gBattleAnimTarget)) { if (gBattleAnimTarget == 0) @@ -4844,7 +4844,7 @@ static void AnimTask_LeafBlade_Step2_Callback(struct Sprite *sprite) static void AnimFlyingParticle(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (!gBattleAnimArgs[6]) battler = gBattleAnimAttacker; else @@ -5417,7 +5417,8 @@ static void AnimMilkBottle_Step2(struct Sprite *sprite, int unk1, int unk2) void AnimGrantingStars(struct Sprite *sprite) { - if (!InitSpritePosToAnimBattler(gBattleAnimArgs[2], sprite, FALSE)) + enum AnimBattler animBattler = gBattleAnimArgs[2]; + if (!InitSpritePosToAnimBattler(animBattler, sprite, FALSE)) return; SetAnimSpriteInitialXOffset(sprite, gBattleAnimArgs[0]); @@ -5431,7 +5432,7 @@ void AnimGrantingStars(struct Sprite *sprite) static void AnimSparklingStars(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (!gBattleAnimArgs[2]) battler = gBattleAnimAttacker; else @@ -6208,8 +6209,7 @@ void AnimTask_Conversion2AlphaBlend(u8 taskId) static void UNUSED AnimTask_HideBattlersHealthbox(u8 taskId) { - u8 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleAnimArgs[0] == TRUE && IsOnPlayerSide(i)) SetHealthboxSpriteInvisible(gHealthboxSpriteIds[i]); @@ -6223,8 +6223,7 @@ static void UNUSED AnimTask_HideBattlersHealthbox(u8 taskId) static void UNUSED AnimTask_ShowBattlersHealthbox(u8 taskId) { - u8 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) SetHealthboxSpriteVisible(gHealthboxSpriteIds[i]); DestroyAnimVisualTask(taskId); @@ -6468,7 +6467,7 @@ static void AnimHornHit_Step(struct Sprite *sprite) #define sSinIndexMod data[5] #define sBattlerFlank data[6] -void PrepareDoubleTeamAnim(u32 taskId, u32 animBattler, bool32 forAllySwitch) +void PrepareDoubleTeamAnim(u32 taskId, enum AnimBattler animBattler, bool32 forAllySwitch) { s32 i, spriteId; u16 palOffsetBattler, palOffsetSpoon; @@ -6527,7 +6526,7 @@ static inline void SwapStructData(void *s1, void *s2, void *data, u32 size) memcpy(s2, data, size); } -static void ReloadBattlerSprites(u32 battler, struct Pokemon *party) +static void ReloadBattlerSprites(enum BattlerId battler, struct Pokemon *party) { struct Pokemon *mon = &party[gBattlerPartyIndexes[battler]]; BattleLoadMonSpriteGfx(mon, battler); @@ -6563,14 +6562,14 @@ static void ReloadBattlerSprites(u32 battler, struct Pokemon *party) } } -static void TrySwapSkyDropTargets(u32 battlerAtk, u32 battlerPartner) +static void TrySwapSkyDropTargets(enum BattlerId battlerAtk, enum BattlerId battlerPartner) { - u32 i, temp; + u32 temp; // battlerAtk is using Ally Switch // check if our partner is the target of sky drop // If so, change that index to battlerAtk - for (i = 0; i < gBattlersCount; i++) { + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleStruct->skyDropTargets[i] == battlerPartner) { gBattleStruct->skyDropTargets[i] = battlerAtk; break; @@ -6587,7 +6586,7 @@ static void TrySwapSkyDropTargets(u32 battlerAtk, u32 battlerPartner) else if (gSideTimers[side].field == battlerPartner) \ gSideTimers[side].field = battlerAtk; -static void TrySwapStickyWebBattlerId(u32 battlerAtk, u32 battlerPartner) +static void TrySwapStickyWebBattlerId(enum BattlerId battlerAtk, enum BattlerId battlerPartner) { u32 oppSide = GetBattlerSide(BATTLE_OPPOSITE(battlerAtk)); @@ -6596,15 +6595,15 @@ static void TrySwapStickyWebBattlerId(u32 battlerAtk, u32 battlerPartner) } #undef TRY_SIDE_TIMER_BATTLER_ID_SWAP -static void TrySwapWishBattlerIds(u32 battlerAtk, u32 battlerPartner) +static void TrySwapWishBattlerIds(enum BattlerId battlerAtk, enum BattlerId battlerPartner) { - u32 i, temp; + u32 temp; // if used future sight on opposing side, properly track who used it if (gBattleStruct->futureSight[LEFT_FOE(battlerAtk)].counter > 0 || gBattleStruct->futureSight[RIGHT_FOE(battlerAtk)].counter > 0) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsBattlerAlly(i, battlerAtk)) continue; // only on opposing side @@ -6631,14 +6630,14 @@ static void TrySwapWishBattlerIds(u32 battlerAtk, u32 battlerPartner) SWAP(gBattleStruct->wish[battlerAtk].partyId, gBattleStruct->wish[battlerPartner].partyId, temp); } -static void TrySwapAttractBattlerIds(u32 battlerAtk, u32 battlerPartner) +static void TrySwapAttractBattlerIds(enum BattlerId battlerAtk, enum BattlerId battlerPartner) { u32 attractedTo; // our own infatuation handled with gBattleMons struct data swapping // if another battler is infatuated with one of us, change to other battler - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (i == battlerAtk || i == battlerPartner || !gBattleMons[i].volatiles.infatuation) continue; @@ -6657,7 +6656,7 @@ static void TrySwapAttractBattlerIds(u32 battlerAtk, u32 battlerPartner) } } -static void SwapBattlerMoveData(u32 battler1, u32 battler2) +static void SwapBattlerMoveData(enum BattlerId battler1, enum BattlerId battler2) { u32 temp; SWAP(gBattleStruct->chosenMovePositions[battler1], gBattleStruct->chosenMovePositions[battler2], temp); @@ -6678,11 +6677,11 @@ static void SwapBattlerMoveData(u32 battler1, u32 battler2) static void AnimTask_AllySwitchDataSwap(u8 taskId) { - s32 i, j; + enum BattlerId i, j; struct Pokemon *party; u32 temp; - u32 battlerAtk = gBattlerAttacker; - u32 battlerPartner = BATTLE_PARTNER(battlerAtk); + enum BattlerId battlerAtk = gBattlerAttacker; + enum BattlerId battlerPartner = BATTLE_PARTNER(battlerAtk); void *data = Alloc(0x200); if (data == NULL) @@ -7072,7 +7071,7 @@ static void AnimSlowFlyingMusicNotes_Step(struct Sprite *sprite) } } -void SetSpriteNextToMonHead(u8 battler, struct Sprite *sprite) +void SetSpriteNextToMonHead(enum BattlerId battler, struct Sprite *sprite) { if (IsOnPlayerSide(battler)) sprite->x = GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_RIGHT) + 8; @@ -7085,7 +7084,7 @@ void SetSpriteNextToMonHead(u8 battler, struct Sprite *sprite) void AnimThoughtBubble(struct Sprite *sprite) { u8 animNum; - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -7112,7 +7111,7 @@ static void AnimThoughtBubble_Step(struct Sprite *sprite) void AnimMetronomeFinger(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -7136,7 +7135,7 @@ static void AnimMetronomeFinger_Step(struct Sprite *sprite) void AnimFollowMeFinger(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -7194,7 +7193,7 @@ static void AnimFollowMeFinger_Step2(struct Sprite *sprite) static void AnimTauntFinger(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c index de9356d2ec..ed2831ee00 100755 --- a/src/battle_anim_effects_2.c +++ b/src/battle_anim_effects_2.c @@ -1218,7 +1218,7 @@ static void AnimCirclingFinger(struct Sprite *sprite) static void AnimBouncingMusicNote(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; else @@ -2097,7 +2097,8 @@ void AnimTask_Splash(u8 taskId) } else { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); task->data[0] = spriteId; task->data[1] = 0; task->data[2] = gBattleAnimArgs[1]; @@ -2222,7 +2223,7 @@ static void AnimBreathPuff(struct Sprite *sprite) // arg 2: y pixel offset void AnimAngerMark(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (!gBattleAnimArgs[0]) battler = gBattleAnimAttacker; else @@ -2492,12 +2493,12 @@ static void AnimPencil_Step(struct Sprite *sprite) static void AnimBlendThinRing(struct Sprite *sprite) { - u8 battler = 0; + enum BattlerId battler = 0; s16 x = 0; s16 y = 0; u8 r4; - if (gBattleAnimArgs[2] == 0) + if (gBattleAnimArgs[2] == ANIM_ATTACKER) battler = gBattleAnimAttacker; else battler = gBattleAnimTarget; @@ -2537,8 +2538,8 @@ void AnimHyperVoiceRing(struct Sprite *sprite) s16 x = 0; s16 y = 0; u8 yCoordType; - u8 battler1; - u8 battler2; + enum BattlerId battler1; + enum BattlerId battler2; u8 xCoordType; if (gBattleAnimArgs[5] == 0) @@ -3608,7 +3609,8 @@ static void AnimMovementWaves_Step(struct Sprite *sprite) void AnimTask_UproarDistortion(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); PrepareAffineAnimInTaskData(&gTasks[taskId], spriteId, sAffineAnims_UproarDistortion); gTasks[taskId].func = AnimTask_UproarDistortion_Step; @@ -3622,7 +3624,7 @@ static void AnimTask_UproarDistortion_Step(u8 taskId) static void AnimJaggedMusicNote(struct Sprite *sprite) { - u8 battler = !gBattleAnimArgs[0] ? gBattleAnimAttacker : gBattleAnimTarget; + enum BattlerId battler = !gBattleAnimArgs[0] ? gBattleAnimAttacker : gBattleAnimTarget; if (!IsOnPlayerSide(battler)) gBattleAnimArgs[1] *= -1; diff --git a/src/battle_anim_effects_3.c b/src/battle_anim_effects_3.c index 7fd9e38128..f3bf526866 100644 --- a/src/battle_anim_effects_3.c +++ b/src/battle_anim_effects_3.c @@ -2396,12 +2396,12 @@ void AnimTask_HideSwapSprite(u8 taskId) void AnimTask_HideOpponentShadows(u8 taskId) { - u32 battlerLeft = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battlerLeft = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerLeft].shadowSpriteIdPrimary].callback = SpriteCB_SetInvisible; gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerLeft].shadowSpriteIdSecondary].callback = SpriteCB_SetInvisible; if (IsDoubleBattle()) { - u32 battlerRight = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + enum BattlerId battlerRight = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerRight].shadowSpriteIdPrimary].callback = SpriteCB_SetInvisible; gSprites[gBattleSpritesDataPtr->healthBoxesData[battlerRight].shadowSpriteIdSecondary].callback = SpriteCB_SetInvisible; } @@ -2410,11 +2410,11 @@ void AnimTask_HideOpponentShadows(u8 taskId) void AnimTask_SetOpponentShadowCallbacks(u8 taskId) { - u32 battlerLeft = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battlerLeft = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); SetBattlerShadowSpriteCallback(battlerLeft, gBattleMons[battlerLeft].species); if (IsDoubleBattle()) { - u32 battlerRight = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + enum BattlerId battlerRight = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); SetBattlerShadowSpriteCallback(battlerRight, gBattleMons[battlerRight].species); } DestroyAnimVisualTask(taskId); @@ -2870,6 +2870,7 @@ void AnimTask_RockMonBackAndForth(u8 taskId) { u8 side; struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (!gBattleAnimArgs[1]) { @@ -2889,9 +2890,9 @@ void AnimTask_RockMonBackAndForth(u8 taskId) task->data[4] = 0x100 + (gBattleAnimArgs[2] * 128); task->data[5] = gBattleAnimArgs[2] + 2; task->data[6] = gBattleAnimArgs[1] - 1; - task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[15] = GetAnimBattlerSpriteId(animBattler); - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) side = GetBattlerSide(gBattleAnimAttacker); else side = GetBattlerSide(gBattleAnimTarget); @@ -3012,6 +3013,7 @@ static void AnimSweetScentPetal_Step(struct Sprite *sprite) void AnimTask_FlailMovement(u8 taskId) { struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; task->data[0] = 0; task->data[1] = 0; @@ -3020,7 +3022,7 @@ void AnimTask_FlailMovement(u8 taskId) task->data[12] = 0x20; task->data[13] = 0x40; task->data[14] = 0x800; - task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[15] = GetAnimBattlerSpriteId(animBattler); PrepareBattlerSpriteForRotScale(task->data[15], ST_OAM_OBJ_NORMAL); task->func = AnimTask_FlailMovement_Step; @@ -3144,12 +3146,13 @@ void AnimTask_PainSplitMovement(u8 taskId) if (gTasks[taskId].data[0] == 0) { - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + enum AnimBattler animBattler = gBattleAnimArgs[0]; + if (animBattler == ANIM_ATTACKER) gTasks[taskId].data[11] = gBattleAnimAttacker; else gTasks[taskId].data[11] = gBattleAnimTarget; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + spriteId = GetAnimBattlerSpriteId(animBattler); gTasks[taskId].data[10] = spriteId; PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); @@ -3434,13 +3437,14 @@ static void AnimTask_RolePlaySilhouette_Step2(u8 taskId) // arg 0: which battler void AnimTask_AcidArmor(u8 taskId) { - u8 battler; + enum BattlerId battler; u16 bgX, bgY; s16 y, i; struct ScanlineEffectParams scanlineParams; struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) battler = gBattleAnimAttacker; else battler = gBattleAnimTarget; @@ -3463,7 +3467,7 @@ void AnimTask_AcidArmor(u8 taskId) task->data[13] = 0; task->data[14] = task->data[13] + 66; - task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[15] = GetAnimBattlerSpriteId(animBattler); if (GetBattlerSpriteBGPriorityRank(battler) == 1) { scanlineParams.dmaDest = ®_BG1HOFS; @@ -3613,8 +3617,9 @@ static void AnimTask_AcidArmor_Step(u8 taskId) void AnimTask_DeepInhale(u8 taskId) { struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; task->data[0] = 0; - task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[15] = GetAnimBattlerSpriteId(animBattler); PrepareAffineAnimInTaskData(&gTasks[taskId], task->data[15], gDeepInhaleAffineAnimCmds); task->func = AnimTask_DeepInhale_Step; } @@ -3880,8 +3885,9 @@ void AnimTask_SlideMonForFocusBand(u8 taskId) // arg 1: num squishes void AnimTask_SquishAndSweatDroplets(u8 taskId) { - u8 battler; + enum BattlerId battler; struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (!gBattleAnimArgs[1]) DestroyAnimVisualTask(taskId); @@ -3890,7 +3896,7 @@ void AnimTask_SquishAndSweatDroplets(u8 taskId) task->tTimer = 0; task->tActiveSprites = 0; task->tNumSquishes = gBattleAnimArgs[1]; - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) battler = gBattleAnimAttacker; else battler = gBattleAnimTarget; @@ -3898,7 +3904,7 @@ void AnimTask_SquishAndSweatDroplets(u8 taskId) task->tBaseX = GetBattlerSpriteCoord(battler, BATTLER_COORD_X); task->tBaseY = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y); task->tSubpriority = GetBattlerSpriteSubpriority(battler); - task->tBattlerSpriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->tBattlerSpriteId = GetAnimBattlerSpriteId(animBattler); PrepareAffineAnimInTaskData(task, task->tBattlerSpriteId, gFacadeSquishAffineAnimCmds); task->func = AnimTask_SquishAndSweatDroplets_Step; } @@ -4014,10 +4020,11 @@ static void AnimFacadeSweatDrop(struct Sprite *sprite) void AnimTask_FacadeColorBlend(u8 taskId) { u8 spriteId; + enum AnimBattler animBattler = gBattleAnimArgs[0]; gTasks[taskId].data[0] = 0; gTasks[taskId].data[1] = gBattleAnimArgs[1]; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + spriteId = GetAnimBattlerSpriteId(animBattler); gTasks[taskId].data[2] = OBJ_PLTT_ID(gSprites[spriteId].oam.paletteNum); gTasks[taskId].func = AnimTask_FacadeColorBlend_Step; } @@ -4370,7 +4377,7 @@ static void AnimTask_BarrageBall_Step(u8 taskId) // arg 2: num squishes static void AnimSmellingSaltsHand(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == ANIM_ATTACKER) battler = gBattleAnimAttacker; @@ -4445,14 +4452,15 @@ static void AnimSmellingSaltsHand_Step(struct Sprite *sprite) // arg 1: number of squishes void AnimTask_SmellingSaltsSquish(u8 taskId) { - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + enum AnimBattler animBattler = gBattleAnimArgs[0]; + if (animBattler == ANIM_ATTACKER) { DestroyAnimVisualTask(taskId); } else { gTasks[taskId].data[0] = gBattleAnimArgs[1]; - gTasks[taskId].data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[15] = GetAnimBattlerSpriteId(animBattler); PrepareAffineAnimInTaskData(&gTasks[taskId], gTasks[taskId].data[15], gSmellingSaltsSquishAffineAnimCmds); gTasks[taskId].func = AnimTask_SmellingSaltsSquish_Step; } @@ -4750,20 +4758,22 @@ static void AnimTask_HelpingHandAttackerMovement_Step(u8 taskId) // arg 0: magnifying glass target mon static void AnimForesightMagnifyingGlass(struct Sprite *sprite) { + enum BattlerId battler; if (gBattleAnimArgs[0] == ANIM_ATTACKER) { InitSpritePosToAnimAttacker(sprite, TRUE); - sprite->data[7] = gBattleAnimAttacker; + battler = gBattleAnimAttacker; } else { - sprite->data[7] = gBattleAnimTarget; + battler = gBattleAnimTarget; } + sprite->data[7] = battler; - if (!IsOnPlayerSide(sprite->data[7])) + if (!IsOnPlayerSide(battler)) sprite->oam.matrixNum = ST_OAM_HFLIP; - sprite->oam.priority = GetBattlerSpriteBGPriority(sprite->data[7]); + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); sprite->oam.objMode = ST_OAM_OBJ_BLEND; sprite->callback = AnimForesightMagnifyingGlass_Step; } @@ -5652,8 +5662,9 @@ void AnimTask_GetWeather(u8 taskId) void AnimTask_SlackOffSquish(u8 taskId) { struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; task->data[0] = 0; - task->data[15] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[15] = GetAnimBattlerSpriteId(animBattler); PrepareAffineAnimInTaskData(task, task->data[15], gSlackOffSquishAffineAnimCmds); task->func = AnimTask_SlackOffSquish_Step; } diff --git a/src/battle_anim_electric.c b/src/battle_anim_electric.c index 503d400cbf..40ff9c1e77 100644 --- a/src/battle_anim_electric.c +++ b/src/battle_anim_electric.c @@ -645,11 +645,12 @@ static void AnimCirclingElectricShock(struct Sprite *sprite) // arg 6: increase battler sprite priority by 1 void AnimSparkElectricity(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; u32 matrixNum; s16 sineVal; + enum AnimBattler animBattler = gBattleAnimArgs[4]; - switch (gBattleAnimArgs[4]) + switch (animBattler) { case ANIM_ATTACKER: battler = gBattleAnimAttacker; @@ -759,7 +760,7 @@ static void AnimThunderboltOrb(struct Sprite *sprite) void AnimSparkElectricityFlashing(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; sprite->data[0] = gBattleAnimArgs[3]; if (gBattleAnimArgs[7] & 0x8000) @@ -799,7 +800,8 @@ static void AnimSparkElectricityFlashing_Step(struct Sprite *sprite) // Electricity arcs around the target. Used for Paralysis and various electric move hits void AnimElectricity(struct Sprite *sprite) { - if (!InitSpritePosToAnimBattler(gBattleAnimArgs[4], sprite, FALSE)) + enum AnimBattler animBattler = gBattleAnimArgs[4]; + if (!InitSpritePosToAnimBattler(animBattler, sprite, FALSE)) return; sprite->oam.tileNum += gBattleAnimArgs[3] * 4; @@ -1309,7 +1311,8 @@ void AnimGrowingShockWaveOrb(struct Sprite *sprite) void AnimTask_ShockWaveProgressingBolt(u8 taskId) { struct Task *task = &gTasks[taskId]; - u8 target = GetAnimBattlerId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + enum BattlerId target = GetAnimBattlerId(animBattler); switch (task->data[0]) { @@ -1435,7 +1438,8 @@ static void AnimShockWaveProgressingBolt(struct Sprite *sprite) void AnimTask_ShockWaveLightning(u8 taskId) { struct Task *task = &gTasks[taskId]; - u8 target = GetAnimBattlerId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + enum BattlerId target = GetAnimBattlerId(animBattler); switch (task->data[0]) { diff --git a/src/battle_anim_fight.c b/src/battle_anim_fight.c index cb1a967f4d..c28511ecc5 100644 --- a/src/battle_anim_fight.c +++ b/src/battle_anim_fight.c @@ -487,7 +487,7 @@ void AnimBasicFistOrFoot(struct Sprite *sprite) static void AnimFistOrFootRandomPos(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; s16 xMod, yMod; s16 x, y; @@ -917,7 +917,7 @@ static void AnimSuperpowerRock_Step2(struct Sprite *sprite) void AnimSuperpowerFireball(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == ANIM_ATTACKER) { diff --git a/src/battle_anim_flying.c b/src/battle_anim_flying.c index b63dbf8e25..e24d37786e 100644 --- a/src/battle_anim_flying.c +++ b/src/battle_anim_flying.c @@ -560,7 +560,8 @@ struct FeatherDanceData static void AnimFallingFeather(struct Sprite *sprite) { - u8 battler, matrixNum, sinIndex; + enum BattlerId battler; + u8 matrixNum, sinIndex; s16 spriteCoord; struct FeatherDanceData *data = (struct FeatherDanceData *)sprite->data; diff --git a/src/battle_anim_ghost.c b/src/battle_anim_ghost.c index a028065025..33d1807349 100644 --- a/src/battle_anim_ghost.c +++ b/src/battle_anim_ghost.c @@ -824,7 +824,7 @@ static void AnimDestinyBondWhiteShadow_Step(struct Sprite *sprite) void AnimTask_DestinyBondWhiteShadow(u8 taskId) { struct Task *task; - s16 battler; + enum BattlerId battler; u8 spriteId; s16 baseX, baseY; s16 x, y; diff --git a/src/battle_anim_ground.c b/src/battle_anim_ground.c index be64beafb7..0cac205b91 100644 --- a/src/battle_anim_ground.c +++ b/src/battle_anim_ground.c @@ -497,7 +497,7 @@ static void SetDigScanlineEffect(u8 useBG1, s16 y, s16 endY) // arg 5: duration void AnimDirtPlumeParticle(struct Sprite *sprite) { - s8 battler; + enum BattlerId battler; s16 xOffset; if (gBattleAnimArgs[0] == ANIM_ATTACKER) @@ -536,7 +536,7 @@ static void AnimDirtPlumeParticle_Step(struct Sprite *sprite) // arg 2: duration static void AnimDigDirtMound(struct Sprite *sprite) { - s8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) battler = gBattleAnimAttacker; @@ -569,6 +569,7 @@ void AnimTask_HorizontalShake(u8 taskId) { u16 i; struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (gBattleAnimArgs[1] != 0) task->tHorizOffset = task->tInitHorizOffset = gBattleAnimArgs[1] + 3; @@ -576,13 +577,13 @@ void AnimTask_HorizontalShake(u8 taskId) task->tHorizOffset = task->tInitHorizOffset = (gAnimMovePower / 10) + 3; task->tMaxTime = gBattleAnimArgs[2]; - switch (gBattleAnimArgs[0]) + switch (animBattler) { - case MAX_BATTLERS_COUNT + 1: // Shake platforms + case ANIM_OPPONENT_LEFT: // Shake platforms task->tInitialX = gBattle_BG3_X; task->func = AnimTask_ShakePlatforms; break; - case MAX_BATTLERS_COUNT: // Shake all battlers + case ANIM_PLAYER_LEFT: // Shake all battlers task->tNumBattlers = 0; for (i = 0; i < MAX_BATTLERS_COUNT; i++) { @@ -595,7 +596,7 @@ void AnimTask_HorizontalShake(u8 taskId) task->func = AnimTask_ShakeBattlers; break; default: // Shake specific battler - task->tbattlerSpriteIds(0) = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->tbattlerSpriteIds(0) = GetAnimBattlerSpriteId(animBattler); if (task->tbattlerSpriteIds(0) == SPRITE_NONE) { DestroyAnimVisualTask(taskId); @@ -733,7 +734,7 @@ void AnimTask_IsPowerOver99(u8 taskId) void AnimTask_PositionFissureBgOnBattler(u8 taskId) { struct Task *newTask; - u8 battler = (gBattleAnimArgs[0] & ANIM_TARGET) ? gBattleAnimTarget : gBattleAnimAttacker; + enum BattlerId battler = (gBattleAnimArgs[0] & ANIM_TARGET) ? gBattleAnimTarget : gBattleAnimAttacker; if (gBattleAnimArgs[0] > ANIM_TARGET) battler = BATTLE_PARTNER(battler); diff --git a/src/battle_anim_ice.c b/src/battle_anim_ice.c index 00486e1a69..3d88bd8b17 100644 --- a/src/battle_anim_ice.c +++ b/src/battle_anim_ice.c @@ -959,7 +959,7 @@ static void AnimWaveFromCenterOfTarget(struct Sprite *sprite) static void InitSwirlingFogAnim(struct Sprite *sprite) { s16 tempVar; - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[4] == 0) { @@ -1031,10 +1031,11 @@ static void AnimSwirlingFogAnim(struct Sprite *sprite) sprite->x2 += Sin(sprite->data[5], sprite->data[6]); sprite->y2 += Cos(sprite->data[5], -6); + enum BattlerId battler = sprite->data[7]; if ((u16)(sprite->data[5] - 64) <= 0x7F) - sprite->oam.priority = GetBattlerSpriteBGPriority(sprite->data[7]); + sprite->oam.priority = GetBattlerSpriteBGPriority(battler); else - sprite->oam.priority = GetBattlerSpriteBGPriority(sprite->data[7]) + 1; + sprite->oam.priority = GetBattlerSpriteBGPriority(battler) + 1; sprite->data[5] = (sprite->data[5] + 3) & 0xFF; } @@ -1493,21 +1494,21 @@ static bool8 GenerateHailParticle(u8 hailStructId, u8 affineAnimNum, u8 taskId, if (type != HAILSTRUCTTYPE_FIXED_POSITION) { - id = GetBattlerAtPosition(sHailCoordData[hailStructId].bPosition); - if (IsBattlerSpriteVisible(id)) + enum BattlerId battler = GetBattlerAtPosition(sHailCoordData[hailStructId].bPosition); + if (IsBattlerSpriteVisible(battler)) { shouldSpawnImpactEffect = TRUE; - battlerX = GetBattlerSpriteCoord(id, BATTLER_COORD_X_2); - battlerY = GetBattlerSpriteCoord(id, BATTLER_COORD_Y_PIC_OFFSET); + battlerX = GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2); + battlerY = GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET); switch (type) { case HAILSTRUCTTYPE_NEGATIVE_POS_MOD: - battlerX -= GetBattlerSpriteCoordAttr(id, BATTLER_COORD_ATTR_WIDTH) / 6; - battlerY -= GetBattlerSpriteCoordAttr(id, BATTLER_COORD_ATTR_HEIGHT) / 6; + battlerX -= GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_WIDTH) / 6; + battlerY -= GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 6; break; case HAILSTRUCTTYPE_POSITIVE_POS_MOD: - battlerX += GetBattlerSpriteCoordAttr(id, BATTLER_COORD_ATTR_WIDTH) / 6; - battlerY += GetBattlerSpriteCoordAttr(id, BATTLER_COORD_ATTR_HEIGHT) / 6; + battlerX += GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_WIDTH) / 6; + battlerY += GetBattlerSpriteCoordAttr(battler, BATTLER_COORD_ATTR_HEIGHT) / 6; break; } } diff --git a/src/battle_anim_mon_movement.c b/src/battle_anim_mon_movement.c index 71dea82659..990242265c 100644 --- a/src/battle_anim_mon_movement.c +++ b/src/battle_anim_mon_movement.c @@ -97,8 +97,8 @@ const struct SpriteTemplate gSlideMonToOffsetAndBackSpriteTemplate = // arg 4: frame delay void AnimTask_ShakeMon(u8 taskId) { - u8 spriteId; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == SPRITE_NONE) { DestroyAnimVisualTask(taskId); @@ -162,17 +162,18 @@ void AnimTask_ShakeMon2(u8 taskId) { u8 spriteId; bool8 abort = FALSE; - u8 battler; + enum BattlerId battler; + enum AnimBattler animBattler = gBattleAnimArgs[0]; - if (gBattleAnimArgs[0] < MAX_BATTLERS_COUNT) + if (animBattler < ANIM_PLAYER_LEFT) { - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == SPRITE_NONE) abort = TRUE; } - else if (gBattleAnimArgs[0] != ANIM_ATTACKER_FORCE) + else if (animBattler != ANIM_ATTACKER_FORCE) { - switch (gBattleAnimArgs[0]) + switch (animBattler) { case ANIM_PLAYER_LEFT: battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); @@ -256,7 +257,8 @@ static void AnimTask_ShakeMon2_Step(u8 taskId) // arg 4: delay void AnimTask_ShakeMonInPlace(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == SPRITE_NONE) { DestroyAnimVisualTask(taskId); @@ -321,7 +323,8 @@ static void AnimTask_ShakeMonInPlace_Step(u8 taskId) // arg 4: duration void AnimTask_ShakeAndSinkMon(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == SPRITE_NONE) { @@ -373,7 +376,8 @@ void AnimTask_TranslateMonElliptical(u8 taskId) { u8 i; u8 wavePeriod = 1; - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (gBattleAnimArgs[4] > 5) gBattleAnimArgs[4] = 5; @@ -465,7 +469,8 @@ static void DoVerticalDip(struct Sprite *sprite) { u8 spriteId; sprite->invisible = TRUE; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + enum AnimBattler animBattler = gBattleAnimArgs[2]; + spriteId = GetAnimBattlerSpriteId(animBattler); sprite->data[0] = gBattleAnimArgs[0]; sprite->data[1] = 0; sprite->data[2] = gBattleAnimArgs[1]; @@ -587,7 +592,7 @@ static void SlideMonToOriginalPos_Step(struct Sprite *sprite) // arg 4: duration static void SlideMonToOffset(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; u8 monSpriteId; if (!gBattleAnimArgs[0]) battler = gBattleAnimAttacker; @@ -620,7 +625,7 @@ static void SlideMonToOffset(struct Sprite *sprite) static void SlideMonToOffsetPartner(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; u8 monSpriteId; if (!gBattleAnimArgs[0]) battler = BATTLE_PARTNER(gBattleAnimAttacker); @@ -654,7 +659,7 @@ static void SlideMonToOffsetPartner(struct Sprite *sprite) static void SlideMonToOffsetAndBack(struct Sprite *sprite) { u8 spriteId; - u8 battler; + enum BattlerId battler; sprite->invisible = TRUE; if (gBattleAnimArgs[0] == ANIM_ATTACKER) @@ -713,12 +718,13 @@ static void SlideMonToOffsetAndBack_End(struct Sprite *sprite) void AnimTask_WindUpLunge(u8 taskId) { s16 wavePeriod = 0x8000 / gBattleAnimArgs[3]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (!IsOnPlayerSide(gBattleAnimAttacker)) { gBattleAnimArgs[1] = -gBattleAnimArgs[1]; gBattleAnimArgs[5] = -gBattleAnimArgs[5]; } - gTasks[taskId].data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[0] = GetAnimBattlerSpriteId(animBattler); gTasks[taskId].data[1] = (gBattleAnimArgs[1] << 8) / gBattleAnimArgs[3]; gTasks[taskId].data[2] = gBattleAnimArgs[2]; gTasks[taskId].data[3] = gBattleAnimArgs[3]; @@ -777,11 +783,12 @@ static void AnimTask_WindUpLunge_Step2(u8 taskId) void AnimTask_DuckDownHop(u8 taskId) { s16 wavePeriod = 0x8000 / gBattleAnimArgs[3]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (!IsOnPlayerSide(gBattleAnimAttacker)) { gBattleAnimArgs[1] = -gBattleAnimArgs[1]; } - gTasks[taskId].data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[0] = GetAnimBattlerSpriteId(animBattler); gTasks[taskId].data[1] = (gBattleAnimArgs[1] << 8) / gBattleAnimArgs[3]; gTasks[taskId].data[2] = gBattleAnimArgs[2]; gTasks[taskId].data[3] = gBattleAnimArgs[3]; @@ -831,11 +838,12 @@ static void AnimTask_DuckDownHop_Step2(u8 taskId) void AnimTask_SlideOffScreen(u8 taskId) { u8 spriteId; - switch (gBattleAnimArgs[0]) + enum AnimBattler animBattler = gBattleAnimArgs[0]; + switch (animBattler) { case ANIM_ATTACKER: case ANIM_TARGET: - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + spriteId = GetAnimBattlerSpriteId(animBattler); break; case ANIM_ATK_PARTNER: if (!IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) @@ -891,10 +899,11 @@ static void AnimTask_SlideOffScreen_Step(u8 taskId) void AnimTask_SwayMon(u8 taskId) { u8 spriteId; + enum AnimBattler animBattler = gBattleAnimArgs[4]; if (!IsOnPlayerSide(gBattleAnimAttacker)) gBattleAnimArgs[1] = -gBattleAnimArgs[1]; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[4]); + spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == 0xff) { DestroyAnimVisualTask(taskId); @@ -906,7 +915,7 @@ void AnimTask_SwayMon(u8 taskId) gTasks[taskId].data[3] = gBattleAnimArgs[3]; gTasks[taskId].data[4] = spriteId; - if (gBattleAnimArgs[4] == 0) + if (animBattler == ANIM_ATTACKER) gTasks[taskId].data[5] = gBattleAnimAttacker; else gTasks[taskId].data[5] = gBattleAnimTarget; @@ -967,7 +976,8 @@ static void AnimTask_SwayMonStep(u8 taskId) // arg 4: sprite object mode void AnimTask_ScaleMonAndRestore(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[3]); + enum AnimBattler animBattler = gBattleAnimArgs[3]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); PrepareBattlerSpriteForRotScale(spriteId, gBattleAnimArgs[4]); gTasks[taskId].data[0] = gBattleAnimArgs[0]; gTasks[taskId].data[1] = gBattleAnimArgs[1]; @@ -1006,8 +1016,8 @@ static void AnimTask_ScaleMonAndRestore_Step(u8 taskId) void AnimTask_RotateMonSpriteToSide(u8 taskId) { - u8 spriteId; - spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + enum AnimBattler animBattler = gBattleAnimArgs[2]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[1] = 0; gTasks[taskId].data[2] = gBattleAnimArgs[0]; @@ -1028,14 +1038,10 @@ void AnimTask_RotateMonSpriteToSide(u8 taskId) } else { - if (gBattleAnimArgs[2] == ANIM_ATTACKER) - { + if (animBattler == ANIM_ATTACKER) gTasks[taskId].data[7] = IsOnPlayerSide(gBattleAnimAttacker); - } else - { gTasks[taskId].data[7] = IsOnPlayerSide(gBattleAnimTarget); - } } if (gTasks[taskId].data[7]) { @@ -1051,23 +1057,20 @@ void AnimTask_RotateMonSpriteToSide(u8 taskId) // Rotates mon to side and back to original position. For Peck and when a held item activates void AnimTask_RotateMonToSideAndRestore(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + enum AnimBattler animBattler = gBattleAnimArgs[2]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].data[1] = 0; gTasks[taskId].data[2] = gBattleAnimArgs[0]; - if (gBattleAnimArgs[2] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) { if (!IsOnPlayerSide(gBattleAnimAttacker)) - { gBattleAnimArgs[1] = -gBattleAnimArgs[1]; - } } else { if (!IsOnPlayerSide(gBattleAnimTarget)) - { gBattleAnimArgs[1] = -gBattleAnimArgs[1]; - } } if (gBattleAnimArgs[3] != 1) { @@ -1218,12 +1221,13 @@ static void AnimTask_ShakeTargetBasedOnMovePowerOrDmg_Step(u8 taskId) void AnimTask_RotateVertically(u8 taskId) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); PrepareBattlerSpriteForRotScale(spriteId, ST_OAM_OBJ_NORMAL); gTasks[taskId].tSpriteId = spriteId; gTasks[taskId].tRotCurr = 0; - gTasks[taskId].tPlayerSide = IsOnPlayerSide(GetAnimBattlerId(gBattleAnimArgs[0])); + gTasks[taskId].tPlayerSide = IsOnPlayerSide(GetAnimBattlerId(animBattler)); gTasks[taskId].tRotMax = gTasks[taskId].tPlayerSide ? 0x1FFF : 0x7FFE; gTasks[taskId].tRotSpeed = gBattleAnimArgs[1]; gTasks[taskId].func = AnimTask_RotateVerticallyStep; diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index 3f62b94f32..a10e32376b 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -76,7 +76,7 @@ static const struct SpriteSheet sSpriteSheets_MoveEffectMons[] = { gMiscBlank_Gfx, MON_PIC_SIZE, TAG_MOVE_EFFECT_MON_2, }, }; -u8 GetBattlerSpriteCoord(u8 battler, u8 coordType) +u8 GetBattlerSpriteCoord(enum BattlerId battler, u8 coordType) { u8 retVal; u16 species; @@ -130,7 +130,7 @@ u8 GetBattlerSpriteCoord(u8 battler, u8 coordType) return retVal; } -u8 GetBattlerYDelta(u8 battler, u16 species) +u8 GetBattlerYDelta(enum BattlerId battler, u16 species) { u32 personality; struct BattleSpriteInfo *spriteInfo; @@ -168,7 +168,7 @@ u8 GetBattlerYDelta(u8 battler, u16 species) return ret; } -u8 GetBattlerElevation(u8 battler, u16 species) +u8 GetBattlerElevation(enum BattlerId battler, u16 species) { u8 ret = 0; if (!IsOnPlayerSide(battler)) @@ -182,7 +182,7 @@ u8 GetBattlerElevation(u8 battler, u16 species) return ret; } -u8 GetBattlerSpriteFinal_Y(u8 battler, u16 species, bool8 a3) +u8 GetBattlerSpriteFinal_Y(enum BattlerId battler, u16 species, bool8 a3) { u16 offset; u8 y; @@ -207,7 +207,7 @@ u8 GetBattlerSpriteFinal_Y(u8 battler, u16 species, bool8 a3) return y; } -u8 GetBattlerSpriteCoord2(u8 battler, u8 coordType) +u8 GetBattlerSpriteCoord2(enum BattlerId battler, u8 coordType) { u16 species; struct BattleSpriteInfo *spriteInfo; @@ -240,12 +240,12 @@ u8 GetBattlerSpriteCoord2(u8 battler, u8 coordType) } } -u8 GetBattlerSpriteDefault_Y(u8 battler) +u8 GetBattlerSpriteDefault_Y(enum BattlerId battler) { return GetBattlerSpriteCoord(battler, BATTLER_COORD_Y_PIC_OFFSET_DEFAULT); } -u8 GetSubstituteSpriteDefault_Y(u8 battler) +u8 GetSubstituteSpriteDefault_Y(enum BattlerId battler) { u16 y; if (!IsOnPlayerSide(battler)) @@ -255,7 +255,7 @@ u8 GetSubstituteSpriteDefault_Y(u8 battler) return y; } -u8 GetBattlerYCoordWithElevation(u8 battler) +u8 GetBattlerYCoordWithElevation(enum BattlerId battler) { u16 species; u8 y; @@ -277,7 +277,7 @@ u8 GetBattlerYCoordWithElevation(u8 battler) return y; } -u8 GetAnimBattlerSpriteId(u8 animBattler) +u8 GetAnimBattlerSpriteId(enum AnimBattler animBattler) { u32 partner; @@ -316,7 +316,7 @@ u8 GetAnimBattlerSpriteId(u8 animBattler) return SPRITE_NONE; break; case ANIM_PLAYER_LEFT ... ANIM_OPPONENT_RIGHT: - partner = animBattler - MAX_BATTLERS_COUNT; + partner = animBattler - ANIM_PLAYER_LEFT; if (IsBattlerSpriteVisible(partner)) return gBattlerSpriteIds[partner]; else @@ -787,9 +787,9 @@ void InitSpritePosToAnimBothTargets(struct Sprite *sprite, bool8 respectMonPicOf sprite->y += gBattleAnimArgs[1]; } -bool32 InitSpritePosToAnimBattler(u32 animBattlerId, struct Sprite *sprite, bool8 respectMonPicOffsets) +bool32 InitSpritePosToAnimBattler(enum AnimBattler animBattlerId, struct Sprite *sprite, bool8 respectMonPicOffsets) { - u32 battler = GetAnimBattlerId(animBattlerId); + enum BattlerId battler = GetAnimBattlerId(animBattlerId); if (GetAnimBattlerSpriteId(animBattlerId) == 0xFF || !IsBattlerSpriteVisible(battler)) { DestroyAnimSprite(sprite); @@ -811,7 +811,7 @@ bool32 InitSpritePosToAnimBattler(u32 animBattlerId, struct Sprite *sprite, bool return TRUE; } -bool8 IsBattlerSpritePresent(u8 battler) +bool8 IsBattlerSpritePresent(enum BattlerId battler) { if (IsContest()) { @@ -832,7 +832,7 @@ bool8 IsBattlerSpritePresent(u8 battler) if (gAbsentBattlerFlags & 1u << battler) return FALSE; - + return TRUE; } } @@ -889,7 +889,7 @@ void GetBattleAnimBgData(struct BattleAnimBgData *out, u32 bgId) } } -void GetBgDataForTransform(struct BattleAnimBgData *out, u8 battler) +void GetBgDataForTransform(struct BattleAnimBgData *out, enum BattlerId battler) { out->bgTiles = gBattleAnimBgTileBuffer; out->bgTilemap = (u16 *)gBattleAnimBgTilemapBuffer; @@ -1227,7 +1227,7 @@ static bool8 ShouldRotScaleSpeciesBeFlipped(void) void PrepareBattlerSpriteForRotScale(u8 spriteId, u8 objMode) { - u8 battler = gSprites[spriteId].data[0]; + enum BattlerId battler = gSprites[spriteId].data[0]; if (IsContest() || IsBattlerSpriteVisible(battler)) gSprites[spriteId].invisible = FALSE; @@ -1435,7 +1435,7 @@ u32 GetBattleMonSpritePalettesMask(u8 playerLeft, u8 playerRight, u8 opponentLef return selectedPalettes; } -u8 GetSpritePalIdxByBattler(u8 battler) +u8 GetSpritePalIdxByBattler(enum BattlerId battler) { return battler; } @@ -1549,7 +1549,8 @@ static void AnimThrowProjectile_Step(struct Sprite *sprite) void AnimTravelDiagonally(struct Sprite *sprite) { bool8 respectOffsets; - u8 battler, coordType; + enum BattlerId battler; + u8 coordType; if (!gBattleAnimArgs[6]) { @@ -1581,7 +1582,7 @@ void AnimTravelDiagonally(struct Sprite *sprite) StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); } -s16 CloneBattlerSpriteWithBlend(u8 animBattler) +s16 CloneBattlerSpriteWithBlend(enum AnimBattler animBattler) { u16 i; u8 spriteId = GetAnimBattlerSpriteId(animBattler); @@ -1671,7 +1672,8 @@ static void AnimTask_AlphaFadeIn_Step(u8 taskId) // arg 4: number of times to blend in and out void AnimTask_BlendMonInAndOut(u8 task) { - u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + u8 spriteId = GetAnimBattlerSpriteId(animBattler); if (spriteId == SPRITE_NONE) { DestroyAnimVisualTask(task); @@ -1860,7 +1862,7 @@ void SetBattlerSpriteYOffsetFromOtherYScale(u8 spriteId, u8 otherSpriteId) static u16 GetBattlerYDeltaFromSpriteId(u8 spriteId) { struct BattleSpriteInfo *spriteInfo; - u8 battler = gSprites[spriteId].data[0]; + enum BattlerId battler = gSprites[spriteId].data[0]; u16 species; u16 i; @@ -1967,9 +1969,7 @@ static void UNUSED SetPriorityForVisibleBattlers(u8 priority) void InitPrioritiesForVisibleBattlers(void) { - int i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsBattlerSpriteVisible(i)) { @@ -1979,14 +1979,14 @@ void InitPrioritiesForVisibleBattlers(void) } } -u8 GetBattlerSpriteSubpriority(u8 battler) +u8 GetBattlerSpriteSubpriority(enum BattlerId battler) { enum BattlerPosition position; u8 subpriority; if (IsContest()) { - if (battler == 2) + if (battler == B_BATTLER_2) return 30; else return 40; @@ -2007,7 +2007,7 @@ u8 GetBattlerSpriteSubpriority(u8 battler) return subpriority; } -u8 GetBattlerSpriteBGPriority(u8 battler) +u8 GetBattlerSpriteBGPriority(enum BattlerId battler) { enum BattlerPosition position = GetBattlerPosition(battler); @@ -2019,7 +2019,7 @@ u8 GetBattlerSpriteBGPriority(u8 battler) return GetAnimBgAttribute(1, BG_ANIM_PRIORITY); } -u8 GetBattlerSpriteBGPriorityRank(u8 battler) +u8 GetBattlerSpriteBGPriorityRank(enum BattlerId battler) { if (!IsContest()) { @@ -2033,7 +2033,7 @@ u8 GetBattlerSpriteBGPriorityRank(u8 battler) } // Create Pokémon sprite to be used for a move animation effect (e.g. Role Play / Snatch) -u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, bool8 isShiny, u32 battler) +u8 CreateAdditionalMonSpriteForMoveAnim(u16 species, bool8 isBackpic, u8 id, s16 x, s16 y, u8 subpriority, u32 personality, bool8 isShiny, enum BattlerId battler) { u8 spriteId; u16 sheet = LoadSpriteSheet(&sSpriteSheets_MoveEffectMons[id]); @@ -2079,7 +2079,7 @@ void DestroySpriteAndFreeResources_(struct Sprite *sprite) DestroySpriteAndFreeResources(sprite); } -s16 GetBattlerSpriteCoordAttr(u8 battler, u8 attr) +s16 GetBattlerSpriteCoordAttr(enum BattlerId battler, u8 attr) { u16 species; u32 personality; @@ -2172,7 +2172,7 @@ s16 GetBattlerSpriteCoordAttr(u8 battler, u8 attr) } } -void SetAverageBattlerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y) +void SetAverageBattlerPositions(enum BattlerId battler, bool8 respectMonPicOffsets, s16 *x, s16 *y) { u8 xCoordType, yCoordType; s16 battlerX, battlerY; @@ -2206,7 +2206,7 @@ void SetAverageBattlerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, *y = (battlerY + partnerY) / 2; } -void SetToPartnerPositions(u8 battler, bool8 respectMonPicOffsets, s16 *x, s16 *y) +void SetToPartnerPositions(enum BattlerId battler, bool8 respectMonPicOffsets, s16 *x, s16 *y) { u8 xCoordType, yCoordType; s16 returnX, returnY; @@ -2388,7 +2388,7 @@ static void AnimTask_AttackerPunchWithTrace_Step(u8 taskId) static void CreateBattlerTrace(struct Task *task, u8 taskId) { - s16 spriteId = CloneBattlerSpriteWithBlend(0); + s16 spriteId = CloneBattlerSpriteWithBlend(ANIM_ATTACKER); if (spriteId >= 0) { gSprites[spriteId].oam.priority = task->tPriority; diff --git a/src/battle_anim_new.c b/src/battle_anim_new.c index bb3abb464c..26a05deb64 100644 --- a/src/battle_anim_new.c +++ b/src/battle_anim_new.c @@ -6327,31 +6327,32 @@ void AnimTask_IsTargetPartner(u8 taskId) DestroyAnimVisualTask(taskId); } -static u8 LoadBattleAnimTarget(u8 arg) +static enum BattlerId LoadBattleAnimTarget(u8 arg) { - u8 battler; + enum BattlerId battler; + enum AnimBattler animBattler = gBattleAnimArgs[arg]; if (IsDoubleBattle()) { - switch (gBattleAnimArgs[arg]) + switch (animBattler) { - case 0: + case ANIM_ATTACKER: battler = gBattleAnimAttacker; break; default: battler = gBattleAnimTarget; break; - case 2: + case ANIM_ATK_PARTNER: battler = BATTLE_PARTNER(gBattleAnimAttacker); break; - case 3: + case ANIM_DEF_PARTNER: battler = BATTLE_PARTNER(gBattleAnimTarget); break; } } else { - if (gBattleAnimArgs[arg] == 0) + if (animBattler == ANIM_ATTACKER) battler = gBattleAnimAttacker; else battler = gBattleAnimTarget; @@ -6360,7 +6361,7 @@ static u8 LoadBattleAnimTarget(u8 arg) return battler; } -static u8 GetProperCentredCoord(u8 battler, u8 coordType) +static u8 GetProperCentredCoord(enum BattlerId battler, u8 coordType) { if (IsDoubleBattle()) return (GetBattlerSpriteCoord2(battler, coordType) + GetBattlerSpriteCoord2(BATTLE_PARTNER(battler), coordType)) / 2; @@ -6368,7 +6369,7 @@ static u8 GetProperCentredCoord(u8 battler, u8 coordType) return GetBattlerSpriteCoord(battler, coordType); } -static void InitSpritePosToGivenTarget(struct Sprite *sprite, u8 target) +static void InitSpritePosToGivenTarget(struct Sprite *sprite, enum BattlerId target) { sprite->x = GetBattlerSpriteCoord2(target, BATTLER_COORD_X); sprite->y = GetBattlerSpriteCoord2(target, BATTLER_COORD_Y); @@ -6575,7 +6576,7 @@ static void SpriteCB_SpriteToCentreOfSide(struct Sprite *sprite) static void SpriteCB_SpriteOnMonForDuration(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(0); + enum BattlerId target = LoadBattleAnimTarget(0); if (!IsBattlerSpriteVisible(target)) { @@ -6612,7 +6613,7 @@ static void SpriteCB_ToxicThreadWrap(struct Sprite *sprite) static void SpriteCB_GrowingSuperpower(struct Sprite *sprite) { - u8 battler; + enum BattlerId battler; if (gBattleAnimArgs[0] == 0) { @@ -6702,7 +6703,7 @@ static void SpriteCB_CoreEnforcerBeam(struct Sprite *sprite) static void SpriteCB_TranslateAnimSpriteToTargetMonLocationDoubles(struct Sprite *sprite) { bool8 respectMonPicOffsets; - u8 target; + enum BattlerId target; u8 coordType; if (!(gBattleAnimArgs[5] & 0xff00)) @@ -6740,7 +6741,7 @@ static void SpriteCB_TranslateAnimSpriteToTargetMonLocationDoubles(struct Sprite //arg 3: anim battler static void SpriteCB_FallingObject(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(3); + enum BattlerId target = LoadBattleAnimTarget(3); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -7156,7 +7157,7 @@ static void SpriteCB_AcidDripSingleTarget(struct Sprite *sprite) //arg 2: anim battler static void SpriteCB_WaterDroplet(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(2); + enum BattlerId target = LoadBattleAnimTarget(2); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -7197,7 +7198,7 @@ static void SpriteCB_AnimSpriteOnSelectedMonPos(struct Sprite *sprite) { if (!sprite->data[0]) { - u8 target = LoadBattleAnimTarget(2); + enum BattlerId target = LoadBattleAnimTarget(2); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -7235,7 +7236,7 @@ static void SpriteCB_SurroundingRing(struct Sprite *sprite) //arg 5: affine anim start delay static void SpriteCB_PhotonGeyserBeam(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(2); + enum BattlerId target = LoadBattleAnimTarget(2); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -7288,7 +7289,7 @@ static void AnimSkyDropBallUp(struct Sprite *sprite) static void SpriteCB_SearingShotRock(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(4); + enum BattlerId target = LoadBattleAnimTarget(4); if (!IsBattlerSpriteVisible(target)) { @@ -7420,8 +7421,8 @@ static void AnimTask_DynamaxGrowthStep(u8 taskId) // from CFRU void AnimTask_AllBattlersInvisible(u8 taskId) { - u32 i, spriteId; - for (i = 0; i < gBattlersCount; i++) + u32 spriteId; + for (enum BattlerId i = 0; i < gBattlersCount; i++) { spriteId = gBattlerSpriteIds[i]; if (spriteId != 0xFF) @@ -7432,8 +7433,8 @@ void AnimTask_AllBattlersInvisible(u8 taskId) void AnimTask_AllBattlersVisible(u8 taskId) { - u32 i, spriteId; - for (i = 0; i < gBattlersCount; ++i) + u32 spriteId; + for (enum BattlerId i = 0; i < gBattlersCount; ++i) { spriteId = gBattlerSpriteIds[i]; if (IsBattlerSpriteVisible(i) && spriteId != 0xFF) @@ -7445,8 +7446,7 @@ void AnimTask_AllBattlersVisible(u8 taskId) void AnimTask_AllBattlersInvisibleExceptAttackerAndTarget(u8 taskId) { - u32 i; - for (i = 0; i < gBattlersCount; ++i) + for (enum BattlerId i = 0; i < gBattlersCount; ++i) { u8 spriteId = gBattlerSpriteIds[i]; if (spriteId == GetAnimBattlerSpriteId(ANIM_ATTACKER) || spriteId == GetAnimBattlerSpriteId(ANIM_TARGET)) @@ -7895,7 +7895,7 @@ static void SpriteCB_ShellSmashShell_DestroyDuringFadeOut(struct Sprite* sprite) static void SpriteCB_AnimSpriteOnTargetSideCentre(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(2); + enum BattlerId target = LoadBattleAnimTarget(2); if (!sprite->data[0]) { @@ -7924,7 +7924,7 @@ static void SpriteCB_AnimSpriteOnTargetSideCentre(struct Sprite *sprite) static void SpriteCB_SpriteOnMonUntilAffineAnimEnds(struct Sprite* sprite) { - u8 target = LoadBattleAnimTarget(0); + enum BattlerId target = LoadBattleAnimTarget(0); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -7939,7 +7939,7 @@ static void SpriteCB_SpriteOnMonUntilAffineAnimEnds(struct Sprite* sprite) static void SpriteCB_SpriteOnMonForDurationUseY(struct Sprite *sprite) { - u8 target = LoadBattleAnimTarget(0); + enum BattlerId target = LoadBattleAnimTarget(0); if (!IsBattlerSpriteVisible(target)) DestroyAnimSprite(sprite); @@ -8072,8 +8072,8 @@ static void SpriteCB_FlippableSlash(struct Sprite* sprite) static void SpriteCB_DragonEnergyShot(struct Sprite* sprite) { s16 startingX, finishingX, y; - u8 def1 = gBattleAnimTarget; - u8 def2 = BATTLE_PARTNER(def1); + enum BattlerId def1 = gBattleAnimTarget; + enum BattlerId def2 = BATTLE_PARTNER(def1); if (!IsDoubleBattle() || IsBattlerAlly(gBattleAnimAttacker, gBattleAnimTarget)) y = GetBattlerSpriteCoord(def1, BATTLER_COORD_Y_PIC_OFFSET); @@ -8179,8 +8179,8 @@ static void SpriteCB_MaxFlutterbyStep2(struct Sprite* sprite) //arg 6: duration to target static void SpriteCB_GlacialLance(struct Sprite* sprite) { - u8 def1 = gBattleAnimTarget; - u8 def2 = BATTLE_PARTNER(def1); + enum BattlerId def1 = gBattleAnimTarget; + enum BattlerId def2 = BATTLE_PARTNER(def1); InitSpritePosToAnimAttacker(sprite, TRUE); sprite->data[5] = gBattleAnimArgs[4]; diff --git a/src/battle_anim_normal.c b/src/battle_anim_normal.c index 9734f07dcc..0b8350b6d0 100644 --- a/src/battle_anim_normal.c +++ b/src/battle_anim_normal.c @@ -381,7 +381,7 @@ u32 UnpackSelectedBattlePalettes(s16 selector) bool8 targetPartner = (selector >> 4) & 1; bool8 anim1 = (selector >> 5) & 1; bool8 anim2 = (selector >> 6) & 1; - u32 moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gAnimMoveIndex); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gAnimMoveIndex); switch (moveTarget) { @@ -398,6 +398,8 @@ u32 UnpackSelectedBattlePalettes(s16 selector) attackerPartner |= 1; } break; + default: + break; } return GetBattlePalettesMask(battleBackground, attacker, target, attackerPartner, targetPartner, anim1, anim2); @@ -561,7 +563,6 @@ static void AnimTask_BlendColorCycleLoop(u8 taskId) // See AnimTask_BlendColorCycle. Same, but excludes Attacker and Target void AnimTask_BlendColorCycleExclude(u8 taskId) { - int battler; u32 selectedPalettes = 0; gTasks[taskId].data[0] = gBattleAnimArgs[0]; @@ -572,7 +573,7 @@ void AnimTask_BlendColorCycleExclude(u8 taskId) gTasks[taskId].tBlendColor = gBattleAnimArgs[5]; gTasks[taskId].tRestoreBlend = 0; - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (battler != gBattleAnimAttacker && battler != gBattleAnimTarget) selectedPalettes |= 1 << (battler + 16); @@ -816,8 +817,8 @@ void AnimTask_InvertScreenColor(u8 taskId) #define tColorB data[7] void AnimTask_TintPalettes(u8 taskId) { - u8 attackerBattler; - u8 targetBattler; + enum BattlerId attackerBattler; + enum BattlerId targetBattler; u8 paletteIndex; u32 selectedPalettes = 0; @@ -904,7 +905,6 @@ static void AnimShakeMonOrBattlePlatforms(struct Sprite *sprite) static void AnimShakeMonOrBattlePlatforms_Step(struct Sprite *sprite) { - u8 i; u16 var0; if (sprite->data[3] > 0) @@ -927,7 +927,7 @@ static void AnimShakeMonOrBattlePlatforms_Step(struct Sprite *sprite) var0 = sprite->data[5] - 2; if (var0 < 2) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gSprites[gBattlerSpriteIds[i]].coordOffsetEnabled = FALSE; } @@ -1055,10 +1055,11 @@ static void AnimHitSplatHandleInvert(struct Sprite *sprite) void AnimHitSplatRandom(struct Sprite *sprite) { + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (gBattleAnimArgs[1] == -1) gBattleAnimArgs[1] = Random2() & 3; - if (!InitSpritePosToAnimBattler(gBattleAnimArgs[0], sprite, FALSE)) + if (!InitSpritePosToAnimBattler(animBattler, sprite, FALSE)) return; StartSpriteAffineAnim(sprite, gBattleAnimArgs[1]); @@ -1071,7 +1072,8 @@ void AnimHitSplatRandom(struct Sprite *sprite) void AnimHitSplatOnMonEdge(struct Sprite *sprite) { - sprite->data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + enum AnimBattler animBattler = gBattleAnimArgs[0]; + sprite->data[0] = GetAnimBattlerSpriteId(animBattler); sprite->x = gSprites[sprite->data[0]].x + gSprites[sprite->data[0]].x2; sprite->y = gSprites[sprite->data[0]].y + gSprites[sprite->data[0]].y2; sprite->x2 = gBattleAnimArgs[1]; diff --git a/src/battle_anim_poison.c b/src/battle_anim_poison.c index 742b59c743..40fb84e68d 100644 --- a/src/battle_anim_poison.c +++ b/src/battle_anim_poison.c @@ -494,20 +494,20 @@ static void AnimSludgeProjectile(struct Sprite *sprite) StartSpriteAnim(sprite, 2); if (gBattleAnimArgs[4] && IsDoubleBattle()) { - u32 targetPartner; + enum BattlerId targetPartner; if (IsOnPlayerSide(gBattleAnimTarget)) { - if (gBattleAnimTarget == 0) - targetPartner = 2; + if (gBattleAnimTarget == B_BATTLER_0) + targetPartner = B_BATTLER_2; else - targetPartner = 0; + targetPartner = B_BATTLER_0; } else { - if (gBattleAnimTarget == 1) - targetPartner = 3; + if (gBattleAnimTarget == B_BATTLER_1) + targetPartner = B_BATTLER_3; else - targetPartner = 1; + targetPartner = B_BATTLER_1; } if (IsBattlerAlive(gBattleAnimTarget) && !IsBattlerAlive(targetPartner)) diff --git a/src/battle_anim_psychic.c b/src/battle_anim_psychic.c index bd832cda59..12fcf0f133 100644 --- a/src/battle_anim_psychic.c +++ b/src/battle_anim_psychic.c @@ -512,8 +512,8 @@ static void AnimDefensiveWall(struct Sprite *sprite) if (!isContest) { - u8 battlerCopy; - u8 battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battlerCopy; + enum BattlerId battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); u8 rank = GetBattlerSpriteBGPriorityRank(battler); int var0 = 1; u8 toBG_2 = (rank ^ var0) != 0; @@ -564,7 +564,7 @@ static void AnimDefensiveWall(struct Sprite *sprite) static void AnimDefensiveWall_Step1(struct Sprite *sprite) { - u8 battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); if (!sprite->data[7]) { sprite->data[7] = 1; @@ -621,8 +621,8 @@ static void AnimDefensiveWall_Step4(struct Sprite *sprite) { if (!IsContest()) { - u8 battlerCopy; - u8 battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battlerCopy; + enum BattlerId battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); if (IsBattlerSpriteVisible(battler)) gSprites[gBattlerSpriteIds[battler]].invisible = FALSE; @@ -641,8 +641,8 @@ static void AnimDefensiveWall_Step5(struct Sprite *sprite) { if (!IsContest()) { - u8 battlerCopy; - u8 battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battlerCopy; + enum BattlerId battler = battlerCopy = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); u8 rank = GetBattlerSpriteBGPriorityRank(battler); int var0 = 1; bool8 toBG2 = (rank ^ var0) != 0; @@ -1219,6 +1219,7 @@ void AnimTask_TransparentCloneGrowAndShrink(u8 taskId) s16 spriteId; s16 matrixNum; struct Task *task = &gTasks[taskId]; + enum AnimBattler animBattler = gBattleAnimArgs[0]; matrixNum = AllocOamMatrix(); if (matrixNum == 0xFF) @@ -1227,7 +1228,7 @@ void AnimTask_TransparentCloneGrowAndShrink(u8 taskId) return; } - spriteId = CloneBattlerSpriteWithBlend(gBattleAnimArgs[0]); + spriteId = CloneBattlerSpriteWithBlend(animBattler); if (spriteId < 0) { FreeOamMatrix(matrixNum); @@ -1242,7 +1243,7 @@ void AnimTask_TransparentCloneGrowAndShrink(u8 taskId) gSprites[spriteId].subpriority++; SetSpriteRotScale(spriteId, 256, 256, 0); CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); - task->data[13] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + task->data[13] = GetAnimBattlerSpriteId(animBattler); task->data[14] = matrixNum; task->data[15] = spriteId; task->func = AnimTask_TransparentCloneGrowAndShrink_Step; diff --git a/src/battle_anim_rock.c b/src/battle_anim_rock.c index a49b661158..a3eb4a4cc9 100644 --- a/src/battle_anim_rock.c +++ b/src/battle_anim_rock.c @@ -443,10 +443,11 @@ void AnimRockFragment(struct Sprite *sprite) // args[6] - attacker or target void AnimParticleInVortex(struct Sprite *sprite) { + enum AnimBattler animBattler = gBattleAnimArgs[6]; if (IsDoubleBattle() && GetMoveTarget(gAnimMoveIndex) == TARGET_BOTH) InitSpritePosToAnimTargetsCentre(sprite, FALSE); else - InitSpritePosToAnimBattler(gBattleAnimArgs[6], sprite, FALSE); + InitSpritePosToAnimBattler(animBattler, sprite, FALSE); sprite->data[0] = gBattleAnimArgs[3]; sprite->data[1] = gBattleAnimArgs[2]; diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c index 6645e6273b..1232bb3ac5 100644 --- a/src/battle_anim_sound_tasks.c +++ b/src/battle_anim_sound_tasks.c @@ -135,9 +135,10 @@ void SoundTask_PlayCryHighPitch(u8 taskId) { u16 species = 0; s8 pan = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER); + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (IsContest()) { - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) species = gContestResources->moveAnim->species; // Destroying the task twice (here and at end of function) // results in an incorrect value for gAnimVisualTaskCount @@ -148,20 +149,27 @@ void SoundTask_PlayCryHighPitch(u8 taskId) } else { - u8 battler; + enum BattlerId battler; // Get wanted battler. - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + switch (animBattler) + { + case ANIM_ATTACKER: battler = gBattleAnimAttacker; - else if (gBattleAnimArgs[0] == ANIM_TARGET) + break; + case ANIM_TARGET: battler = gBattleAnimTarget; - else if (gBattleAnimArgs[0] == ANIM_ATK_PARTNER) + break; + case ANIM_ATK_PARTNER: battler = BATTLE_PARTNER(gBattleAnimAttacker); - else + break; + default: battler = BATTLE_PARTNER(gBattleAnimTarget); + break; + } // Check if battler is visible. - if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler)) + if ((animBattler == ANIM_TARGET || animBattler == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler)) { DestroyAnimVisualTask(taskId); return; @@ -180,9 +188,10 @@ void SoundTask_PlayDoubleCry(u8 taskId) { u16 species = 0; s8 pan = BattleAnimAdjustPanning(SOUND_PAN_ATTACKER); + enum AnimBattler animBattler = gBattleAnimArgs[0]; if (IsContest()) { - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + if (animBattler == ANIM_ATTACKER) species = gContestResources->moveAnim->species; // Destroying the task twice (here and at end of function) // results in an incorrect value for gAnimVisualTaskCount @@ -193,20 +202,27 @@ void SoundTask_PlayDoubleCry(u8 taskId) } else { - u8 battler; + enum BattlerId battler; // Get wanted battler. - if (gBattleAnimArgs[0] == ANIM_ATTACKER) + switch (animBattler) + { + case ANIM_ATTACKER: battler = gBattleAnimAttacker; - else if (gBattleAnimArgs[0] == ANIM_TARGET) + break; + case ANIM_TARGET: battler = gBattleAnimTarget; - else if (gBattleAnimArgs[0] == ANIM_ATK_PARTNER) + break; + case ANIM_ATK_PARTNER: battler = BATTLE_PARTNER(gBattleAnimAttacker); - else + break; + default: battler = BATTLE_PARTNER(gBattleAnimTarget); + break; + } // Check if battler is visible. - if ((gBattleAnimArgs[0] == ANIM_TARGET || gBattleAnimArgs[0] == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler)) + if ((animBattler == ANIM_TARGET || animBattler == ANIM_DEF_PARTNER) && !IsBattlerSpriteVisible(battler)) { DestroyAnimVisualTask(taskId); return; diff --git a/src/battle_anim_status_effects.c b/src/battle_anim_status_effects.c index b9653934a3..aaded8887a 100644 --- a/src/battle_anim_status_effects.c +++ b/src/battle_anim_status_effects.c @@ -245,7 +245,7 @@ static const struct SpriteTemplate sFlashingCircleImpactSpriteTemplate = .callback = AnimFlashingCircleImpact, }; -static u8 UNUSED Task_FlashingCircleImpacts(u8 battler, bool8 red) +static u8 UNUSED Task_FlashingCircleImpacts(enum BattlerId battler, bool8 red) { u8 battlerSpriteId = gBattlerSpriteIds[battler]; u8 taskId = CreateTask(Task_UpdateFlashingCircleImpacts, 10); @@ -376,8 +376,8 @@ void AnimTask_CentredFrozenIceCube(u8 taskId) // same as AnimTask_FrozenIceCube but center position on target(s) s16 x, y; u8 spriteId; - u8 battler1 = gBattleAnimTarget; - u8 battler2 = BATTLE_PARTNER(battler1); + enum BattlerId battler1 = gBattleAnimTarget; + enum BattlerId battler2 = BATTLE_PARTNER(battler1); if (!IsDoubleBattle() || IsBattlerAlly(gBattleAnimAttacker, gBattleAnimTarget)) { @@ -564,7 +564,7 @@ void AnimTask_StatsChange(u8 taskId) #undef CASE -void LaunchStatusAnimation(u8 battler, u8 statusAnimId) +void LaunchStatusAnimation(enum BattlerId battler, u8 statusAnimId) { u8 taskId; diff --git a/src/battle_anim_throw.c b/src/battle_anim_throw.c index 9a349e1d1b..2739413c8f 100644 --- a/src/battle_anim_throw.c +++ b/src/battle_anim_throw.c @@ -496,7 +496,7 @@ void AnimTask_UnusedLevelUpHealthBox(u8 taskId) { struct BattleAnimBgData animBgData; u8 healthBoxSpriteId; - u8 battler; + enum BattlerId battler; u8 spriteId1, spriteId2, spriteId3, spriteId4; battler = gBattleAnimAttacker; @@ -543,9 +543,7 @@ void AnimTask_UnusedLevelUpHealthBox(u8 taskId) static void AnimTask_UnusedLevelUpHealthBox_Step(u8 taskId) { u8 spriteId1, spriteId2; - u8 battler; - - battler = gBattleAnimAttacker; + enum BattlerId battler = gBattleAnimAttacker; gTasks[taskId].data[13] += gTasks[taskId].data[1]; gBattle_BG1_Y += (u16)gTasks[taskId].data[13] >> 8; gTasks[taskId].data[13] &= 0xFF; @@ -600,7 +598,7 @@ static void AnimTask_UnusedLevelUpHealthBox_Step(u8 taskId) } } -static void LoadHealthboxPalsForLevelUp(u8 *paletteId1, u8 *paletteId2, u8 battler) +static void LoadHealthboxPalsForLevelUp(u8 *paletteId1, u8 *paletteId2, enum BattlerId battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -629,7 +627,7 @@ void AnimTask_LoadHealthboxPalsForLevelUp(u8 taskId) DestroyAnimVisualTask(taskId); } -static void FreeHealthboxPalsForLevelUp(u8 battler) +static void FreeHealthboxPalsForLevelUp(enum BattlerId battler) { u8 healthBoxSpriteId; u8 spriteId1, spriteId2; @@ -1342,7 +1340,7 @@ static void SpriteCB_Ball_Capture(struct Sprite *sprite) // Fade and unfade ball, create star animations, play sound effects static void SpriteCB_Ball_Capture_Step(struct Sprite *sprite) { - u8 *battler = &gBattleAnimTarget; + enum BattlerId *battler = &gBattleAnimTarget; sprite->sTimer++; if (sprite->sTimer == 40) @@ -2249,7 +2247,7 @@ void AnimTask_SetTargetToEffectBattler(u8 taskId) #define sPhase data[1] // For encircling stars #define sTimer data[1] // For diagnoal stars -void TryShinyAnimation(u8 battler, struct Pokemon *mon) +void TryShinyAnimation(enum BattlerId battler, struct Pokemon *mon) { bool8 isShiny; u8 taskCirc, taskDgnl; @@ -2286,7 +2284,7 @@ void TryShinyAnimation(u8 battler, struct Pokemon *mon) static void Task_ShinyStars(u8 taskId) { - u8 battler; + enum BattlerId battler; u8 x, y; u8 spriteId; u16 timer; @@ -2359,7 +2357,7 @@ static void Task_ShinyStars(u8 taskId) static void Task_ShinyStars_Wait(u8 taskId) { - u8 battler; + enum BattlerId battler; if (gTasks[taskId].tNumStars == 0) { diff --git a/src/battle_anim_utility_funcs.c b/src/battle_anim_utility_funcs.c index 9fd2181b60..207b5f7f9e 100644 --- a/src/battle_anim_utility_funcs.c +++ b/src/battle_anim_utility_funcs.c @@ -15,8 +15,8 @@ struct AnimStatsChangeData { - u8 battler1; - u8 battler2; + enum BattlerId battler1; + enum BattlerId battler2; bool8 hidBattler2; s16 data[8]; u16 species; @@ -53,15 +53,16 @@ void AnimTask_BlendBattleAnimPal(u8 taskId) void AnimTask_BlendBattleAnimPalExclude(u8 taskId) { - u8 battler; + enum BattlerId battler; u32 selectedPalettes; - u8 animBattlers[2]; + enum BattlerId animBattlers[2]; animBattlers[1] = 0xFF; selectedPalettes = UnpackSelectedBattlePalettes(F_PAL_BG); - switch (gBattleAnimArgs[0]) + enum AnimBattler animBattler = gBattleAnimArgs[0]; + switch (animBattler) { - case 2: + case ANIM_ATK_PARTNER: selectedPalettes = 0; // fall through case ANIM_ATTACKER: @@ -70,24 +71,24 @@ void AnimTask_BlendBattleAnimPalExclude(u8 taskId) #endif animBattlers[0] = gBattleAnimAttacker; break; - case 3: + case ANIM_DEF_PARTNER: selectedPalettes = 0; // fall through case ANIM_TARGET: animBattlers[0] = gBattleAnimTarget; break; - case 4: + case ANIM_PLAYER_LEFT: animBattlers[0] = gBattleAnimAttacker; animBattlers[1] = gBattleAnimTarget; break; - case 5: + case ANIM_OPPONENT_LEFT: animBattlers[0] = 0xFF; break; - case 6: + case ANIM_PLAYER_RIGHT: selectedPalettes = 0; animBattlers[0] = BATTLE_PARTNER(gBattleAnimAttacker); break; - case 7: + case ANIM_OPPONENT_RIGHT: selectedPalettes = 0; animBattlers[0] = BATTLE_PARTNER(gBattleAnimTarget); break; @@ -203,10 +204,11 @@ static void AnimTask_TraceMonBlended_Step(u8 taskId) } else { - task->data[6] = CloneBattlerSpriteWithBlend(task->data[0]); + enum AnimBattler animBattler = task->data[0]; + task->data[6] = CloneBattlerSpriteWithBlend(animBattler); if (task->data[6] >= 0) { - gSprites[task->data[6]].oam.priority = task->data[0] ? 1 : 2; + gSprites[task->data[6]].oam.priority = animBattler != ANIM_ATTACKER ? 1 : 2; gSprites[task->data[6]].data[0] = task->data[3]; gSprites[task->data[6]].data[1] = taskId; gSprites[task->data[6]].data[2] = 5; @@ -332,7 +334,7 @@ static void AnimTask_DrawFallingWhiteLinesOnAttacker_Step(u8 taskId) SetGpuReg(REG_OFFSET_DISPCNT, GetGpuReg(REG_OFFSET_DISPCNT) ^ DISPCNT_OBJWIN_ON); SetGpuReg(REG_OFFSET_BLDCNT, 0); SetGpuReg(REG_OFFSET_BLDALPHA, 0); - sprite = &gSprites[GetAnimBattlerSpriteId(0)]; // unused + sprite = &gSprites[GetAnimBattlerSpriteId(ANIM_ATTACKER)]; // unused sprite = &gSprites[gTasks[taskId].data[0]]; DestroySprite(sprite); @@ -673,7 +675,7 @@ static void SetPalettesToColor(u32 selectedPalettes, u16 color) void AnimTask_BlendNonAttackerPalettes(u8 taskId) { - u32 battler; + enum BattlerId battler; int j; u32 selectedPalettes = 0; @@ -751,9 +753,7 @@ void AnimTask_GetTargetIsAttackerPartner(u8 taskId) // For hiding or subsequently revealing all other battlers void AnimTask_SetAllNonAttackersInvisiblity(u8 taskId) { - u16 battler; - - for (battler = 0; battler < MAX_BATTLERS_COUNT; battler++) + for (enum BattlerId battler = 0; battler < MAX_BATTLERS_COUNT; battler++) { if (battler != gBattleAnimAttacker && IsBattlerSpriteVisible(battler)) gSprites[gBattlerSpriteIds[battler]].invisible = gBattleAnimArgs[0]; @@ -762,13 +762,13 @@ void AnimTask_SetAllNonAttackersInvisiblity(u8 taskId) DestroyAnimVisualTask(taskId); } -void StartMonScrollingBgMask(u8 taskId, int UNUSED unused, u16 scrollSpeed, u8 battler, bool8 includePartner, u8 numFadeSteps, u8 fadeStepDelay, u8 duration, const u32 *gfx, const u32 *tilemap, const u16 *palette) +void StartMonScrollingBgMask(u8 taskId, int UNUSED unused, u16 scrollSpeed, enum BattlerId battler, bool8 includePartner, u8 numFadeSteps, u8 fadeStepDelay, u8 duration, const u32 *gfx, const u32 *tilemap, const u16 *palette) { u16 species; u8 spriteId, spriteId2; u32 bg1Cnt; struct BattleAnimBgData animBgData; - u8 battler2; + enum BattlerId battler2; spriteId2 = 0; battler2 = BATTLE_PARTNER(battler); @@ -1069,7 +1069,7 @@ void AnimTask_CanBattlerSwitch(u8 taskId) void AnimTask_SetInvisible(u8 taskId) { - u32 battlerId = GetAnimBattlerId(gBattleAnimArgs[0]); + enum BattlerId battlerId = GetAnimBattlerId(gBattleAnimArgs[0]); u32 spriteId = gBattlerSpriteIds[battlerId]; gSprites[spriteId].invisible = gBattleSpritesDataPtr->battlerData[battlerId].invisible = gBattleAnimArgs[1]; diff --git a/src/battle_arena.c b/src/battle_arena.c index 91b83dac22..7d5252460e 100644 --- a/src/battle_arena.c +++ b/src/battle_arena.c @@ -37,7 +37,7 @@ static void SetArenaPrize(void); static void GiveArenaPrize(void); static void BufferArenaOpponentName(void); static void SpriteCB_JudgmentIcon(struct Sprite *sprite); -static void ShowJudgmentSprite(u8 x, u8 y, u8 category, u8 battler); +static void ShowJudgmentSprite(u8 x, u8 y, u8 category, enum BattlerId battler); #define JUDGMENT_STATE_FINISHED 8 @@ -212,8 +212,8 @@ u8 BattleArena_ShowJudgmentWindow(u8 *state) break; case 4: PlaySE(SE_ARENA_TIMEUP1); - ShowJudgmentSprite(80, 40, ARENA_CATEGORY_MIND, B_POSITION_PLAYER_LEFT); - ShowJudgmentSprite(160, 40, ARENA_CATEGORY_MIND, B_POSITION_OPPONENT_LEFT); + ShowJudgmentSprite(80, 40, ARENA_CATEGORY_MIND, GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)); + ShowJudgmentSprite(160, 40, ARENA_CATEGORY_MIND, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)); BattleStringExpandPlaceholdersToDisplayedString(gText_Judgment); BattlePutTextOnWindow(gDisplayedStringBattle, ARENA_WIN_JUDGMENT_TITLE); (*state)++; @@ -221,8 +221,8 @@ u8 BattleArena_ShowJudgmentWindow(u8 *state) break; case 5: PlaySE(SE_ARENA_TIMEUP1); - ShowJudgmentSprite(80, 56, ARENA_CATEGORY_SKILL, B_POSITION_PLAYER_LEFT); - ShowJudgmentSprite(160, 56, ARENA_CATEGORY_SKILL, B_POSITION_OPPONENT_LEFT); + ShowJudgmentSprite(80, 56, ARENA_CATEGORY_SKILL, GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)); + ShowJudgmentSprite(160, 56, ARENA_CATEGORY_SKILL, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)); BattleStringExpandPlaceholdersToDisplayedString(gText_Judgment); BattlePutTextOnWindow(gDisplayedStringBattle, ARENA_WIN_JUDGMENT_TITLE); (*state)++; @@ -230,8 +230,8 @@ u8 BattleArena_ShowJudgmentWindow(u8 *state) break; case 6: PlaySE(SE_ARENA_TIMEUP1); - ShowJudgmentSprite(80, 72, ARENA_CATEGORY_BODY, B_POSITION_PLAYER_LEFT); - ShowJudgmentSprite(160, 72, ARENA_CATEGORY_BODY, B_POSITION_OPPONENT_LEFT); + ShowJudgmentSprite(80, 72, ARENA_CATEGORY_BODY, GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)); + ShowJudgmentSprite(160, 72, ARENA_CATEGORY_BODY, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)); BattleStringExpandPlaceholdersToDisplayedString(gText_Judgment); BattlePutTextOnWindow(gDisplayedStringBattle, ARENA_WIN_JUDGMENT_TITLE); (*state)++; @@ -281,7 +281,7 @@ u8 BattleArena_ShowJudgmentWindow(u8 *state) return result; } -static void ShowJudgmentSprite(u8 x, u8 y, u8 category, u8 battler) +static void ShowJudgmentSprite(u8 x, u8 y, u8 category, enum BattlerId battler) { int animNum = 0; int pointsPlayer = 0; @@ -310,7 +310,7 @@ static void ShowJudgmentSprite(u8 x, u8 y, u8 category, u8 battler) { animNum = ANIM_ICON_CIRCLE; // +2 to score total for winning - if (battler != 0) + if (battler != B_BATTLER_0) gBattleTextBuff2[0] += 2; else gBattleTextBuff1[0] += 2; @@ -319,7 +319,7 @@ static void ShowJudgmentSprite(u8 x, u8 y, u8 category, u8 battler) { animNum = ANIM_ICON_TRIANGLE; // +1 to score total for a tie - if (battler != 0) + if (battler != B_BATTLER_0) gBattleTextBuff2[0] += 1; else gBattleTextBuff1[0] += 1; @@ -353,7 +353,7 @@ void BattleArena_InitPoints(void) hpAtStart[1] = gBattleMons[1].hp; } -void BattleArena_AddMindPoints(u8 battler) +void BattleArena_AddMindPoints(enum BattlerId battler) { // All moves with power != 0 give 1 point, with the following exceptions: // - Counter, Mirror Coat, and Bide give 0 points @@ -376,7 +376,7 @@ void BattleArena_AddMindPoints(u8 battler) } } -void BattleArena_AddSkillPoints(u8 battler) +void BattleArena_AddSkillPoints(enum BattlerId battler) { s8 *skillPoints = gBattleStruct->arenaSkillPoints; @@ -411,7 +411,7 @@ void BattleArena_AddSkillPoints(u8 battler) } } -void BattleArena_DeductSkillPoints(u8 battler, enum StringID stringId) +void BattleArena_DeductSkillPoints(enum BattlerId battler, enum StringID stringId) { s8 *skillPoints = gBattleStruct->arenaSkillPoints; @@ -439,7 +439,7 @@ void BattleArena_DeductSkillPoints(u8 battler, enum StringID stringId) } } -static void UNUSED UpdateHPAtStart(u8 battler) +static void UNUSED UpdateHPAtStart(enum BattlerId battler) { u16 *hpAtStart = gBattleStruct->arenaStartHp; diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c index 3de85cd2d8..596e7a0c83 100644 --- a/src/battle_controller_link_opponent.c +++ b/src/battle_controller_link_opponent.c @@ -31,17 +31,17 @@ #include "recorded_battle.h" #include "random.h" -static void LinkOpponentHandleDrawTrainerPic(u32 battler); -static void LinkOpponentHandleTrainerSlide(u32 battler); -static void LinkOpponentHandleTrainerSlideBack(u32 battler); -static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler); -static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler); -static void LinkOpponentHandleLinkStandbyMsg(u32 battler); -static void LinkOpponentHandleEndLinkBattle(u32 battler); +static void LinkOpponentHandleDrawTrainerPic(enum BattlerId battler); +static void LinkOpponentHandleTrainerSlide(enum BattlerId battler); +static void LinkOpponentHandleTrainerSlideBack(enum BattlerId battler); +static void LinkOpponentHandleIntroTrainerBallThrow(enum BattlerId battler); +static void LinkOpponentHandleDrawPartyStatusSummary(enum BattlerId battler); +static void LinkOpponentHandleLinkStandbyMsg(enum BattlerId battler); +static void LinkOpponentHandleEndLinkBattle(enum BattlerId battler); -static void LinkOpponentBufferRunCommand(u32 battler); +static void LinkOpponentBufferRunCommand(enum BattlerId battler); -static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -98,14 +98,14 @@ static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 batt [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToLinkOpponent(u32 battler) +void SetControllerToLinkOpponent(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_LINK_OPPONENT; gBattlerControllerEndFuncs[battler] = LinkOpponentBufferExecCompleted; gBattlerControllerFuncs[battler] = LinkOpponentBufferRunCommand; } -static void LinkOpponentBufferRunCommand(u32 battler) +static void LinkOpponentBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -116,7 +116,7 @@ static void LinkOpponentBufferRunCommand(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool32 healthboxAnimDone = FALSE; bool32 twoMons = FALSE; @@ -170,7 +170,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { bool32 bgmRestored = FALSE; @@ -258,7 +258,7 @@ static void Intro_TryShinyAnimShowHealthbox(u32 battler) } } -void LinkOpponentBufferExecCompleted(u32 battler) +void LinkOpponentBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = LinkOpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -274,21 +274,22 @@ void LinkOpponentBufferExecCompleted(u32 battler) } } -static void LinkOpponentHandleDrawTrainerPic(u32 battler) +static void LinkOpponentHandleDrawTrainerPic(enum BattlerId battler) { s16 xPos; enum TrainerPicID trainerPicId; + enum BattlerPosition position = GetBattlerPosition(battler); if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon + if ((position & BIT_FLANK) != 0) // second mon xPos = 152; else // first mon xPos = 200; if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) { - if (battler == B_POSITION_OPPONENT_LEFT) + if (position == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentA); else trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentB); @@ -349,11 +350,11 @@ static void LinkOpponentHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40, -1); } -static void LinkOpponentHandleTrainerSlide(u32 battler) +static void LinkOpponentHandleTrainerSlide(enum BattlerId battler) { enum TrainerPicID trainerPicId; - if (battler == B_POSITION_OPPONENT_LEFT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentA); else trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentB); @@ -362,28 +363,28 @@ static void LinkOpponentHandleTrainerSlide(u32 battler) BtlController_Complete(battler); // Possibly a bug, because execution should be completed after the slide in finishes. See Controller_WaitForTrainerPic. } -static void LinkOpponentHandleTrainerSlideBack(u32 battler) +static void LinkOpponentHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler) +static void LinkOpponentHandleIntroTrainerBallThrow(enum BattlerId battler) { BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler) +static void LinkOpponentHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void LinkOpponentHandleLinkStandbyMsg(u32 battler) +static void LinkOpponentHandleLinkStandbyMsg(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); BtlController_Complete(battler); } -static void LinkOpponentHandleEndLinkBattle(u32 battler) +static void LinkOpponentHandleEndLinkBattle(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c index c4c508ac1c..e387095209 100644 --- a/src/battle_controller_link_partner.c +++ b/src/battle_controller_link_partner.c @@ -31,16 +31,16 @@ #include "recorded_battle.h" #include "random.h" -static void LinkPartnerHandleDrawTrainerPic(u32 battler); -static void LinkPartnerHandleTrainerSlideBack(u32 battler); -static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler); -static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler); -static void LinkPartnerHandleLinkStandbyMsg(u32 battler); -static void LinkPartnerHandleEndLinkBattle(u32 battler); +static void LinkPartnerHandleDrawTrainerPic(enum BattlerId battler); +static void LinkPartnerHandleTrainerSlideBack(enum BattlerId battler); +static void LinkPartnerHandleIntroTrainerBallThrow(enum BattlerId battler); +static void LinkPartnerHandleDrawPartyStatusSummary(enum BattlerId battler); +static void LinkPartnerHandleLinkStandbyMsg(enum BattlerId battler); +static void LinkPartnerHandleEndLinkBattle(enum BattlerId battler); -static void LinkPartnerBufferRunCommand(u32 battler); +static void LinkPartnerBufferRunCommand(enum BattlerId battler); -static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -97,14 +97,14 @@ static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battl [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToLinkPartner(u32 battler) +void SetControllerToLinkPartner(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_LINK_PARTNER; gBattlerControllerEndFuncs[battler] = LinkPartnerBufferExecCompleted; gBattlerControllerFuncs[battler] = LinkPartnerBufferRunCommand; } -static void LinkPartnerBufferRunCommand(u32 battler) +static void LinkPartnerBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -115,7 +115,7 @@ static void LinkPartnerBufferRunCommand(u32 battler) } } -void LinkPartnerBufferExecCompleted(u32 battler) +void LinkPartnerBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = LinkPartnerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -131,7 +131,7 @@ void LinkPartnerBufferExecCompleted(u32 battler) } } -static void LinkPartnerHandleDrawTrainerPic(u32 battler) +static void LinkPartnerHandleDrawTrainerPic(enum BattlerId battler) { s16 xPos; enum TrainerPicID trainerPicId; @@ -154,12 +154,12 @@ static void LinkPartnerHandleDrawTrainerPic(u32 battler) -1); } -static void LinkPartnerHandleTrainerSlideBack(u32 battler) +static void LinkPartnerHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler) +static void LinkPartnerHandleIntroTrainerBallThrow(enum BattlerId battler) { enum TrainerPicID trainerPicId = LinkPlayerGetTrainerPicId(GetBattlerMultiplayerId(battler)); const u16 *trainerPal = gTrainerBacksprites[trainerPicId].palette.data; @@ -167,18 +167,18 @@ static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler) BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); } -static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler) +static void LinkPartnerHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void LinkPartnerHandleLinkStandbyMsg(u32 battler) +static void LinkPartnerHandleLinkStandbyMsg(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); BtlController_Complete(battler); } -static void LinkPartnerHandleEndLinkBattle(u32 battler) +static void LinkPartnerHandleEndLinkBattle(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); gBattleOutcome = gBattleResources->bufferA[battler][1]; diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index 3dda4d9f6c..7d368a3165 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -43,18 +43,18 @@ #include "test/battle.h" #include "test/test_runner_battle.h" -static void OpponentHandleDrawTrainerPic(u32 battler); -static void OpponentHandleTrainerSlideBack(u32 battler); -static void OpponentHandleChooseAction(u32 battler); -static void OpponentHandleChooseMove(u32 battler); -static void OpponentHandleChooseItem(u32 battler); -static void OpponentHandleChoosePokemon(u32 battler); -static void OpponentHandleIntroTrainerBallThrow(u32 battler); -static void OpponentHandleDrawPartyStatusSummary(u32 battler); -static void OpponentHandleEndLinkBattle(u32 battler); -static void OpponentBufferRunCommand(u32 battler); +static void OpponentHandleDrawTrainerPic(enum BattlerId battler); +static void OpponentHandleTrainerSlideBack(enum BattlerId battler); +static void OpponentHandleChooseAction(enum BattlerId battler); +static void OpponentHandleChooseMove(enum BattlerId battler); +static void OpponentHandleChooseItem(enum BattlerId battler); +static void OpponentHandleChoosePokemon(enum BattlerId battler); +static void OpponentHandleIntroTrainerBallThrow(enum BattlerId battler); +static void OpponentHandleDrawPartyStatusSummary(enum BattlerId battler); +static void OpponentHandleEndLinkBattle(enum BattlerId battler); +static void OpponentBufferRunCommand(enum BattlerId battler); -static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -111,14 +111,14 @@ static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToOpponent(u32 battler) +void SetControllerToOpponent(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_OPPONENT; gBattlerControllerEndFuncs[battler] = OpponentBufferExecCompleted; gBattlerControllerFuncs[battler] = OpponentBufferRunCommand; } -static void OpponentBufferRunCommand(u32 battler) +static void OpponentBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -129,7 +129,7 @@ static void OpponentBufferRunCommand(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool8 healthboxAnimDone = FALSE; bool8 twoMons; @@ -194,7 +194,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; @@ -292,7 +292,7 @@ static void Intro_TryShinyAnimShowHealthbox(u32 battler) } } -void OpponentBufferExecCompleted(u32 battler) +void OpponentBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = OpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -308,7 +308,7 @@ void OpponentBufferExecCompleted(u32 battler) } } -static u32 OpponentGetTrainerPicId(u32 battlerId) +static u32 OpponentGetTrainerPicId(enum BattlerId battlerId) { enum TrainerPicID trainerPicId; @@ -367,7 +367,7 @@ static u32 OpponentGetTrainerPicId(u32 battlerId) return trainerPicId; } -static void OpponentHandleDrawTrainerPic(u32 battler) +static void OpponentHandleDrawTrainerPic(enum BattlerId battler) { s16 xPos; enum TrainerPicID trainerPicId; @@ -409,24 +409,24 @@ static void OpponentHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40, -1); } -void OpponentHandleTrainerSlide(u32 battler) +void OpponentHandleTrainerSlide(enum BattlerId battler) { enum TrainerPicID trainerPicId = OpponentGetTrainerPicId(battler); BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void OpponentHandleTrainerSlideBack(u32 battler) +static void OpponentHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void OpponentHandleChooseAction(u32 battler) +static void OpponentHandleChooseAction(enum BattlerId battler) { AI_TrySwitchOrUseItem(battler); BtlController_Complete(battler); } -static void OpponentHandleChooseMove(u32 battler) +static void OpponentHandleChooseMove(enum BattlerId battler) { u32 chosenMoveIndex; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); @@ -496,9 +496,10 @@ static void OpponentHandleChooseMove(u32 battler) } else if (IsDoubleBattle()) { + enum BattlerId targetBattler; do { - target = GetBattlerAtPosition(Random() & 2); - } while (!CanTargetBattler(battler, target, move)); + targetBattler = GetBattlerAtPosition(Random() & 2); + } while (!CanTargetBattler(battler, targetBattler, move)); // Don't bother to check if they're enemies if the move can't attack ally if (B_WILD_NATURAL_ENEMIES == TRUE && GetBattlerMoveTargetType(battler, move) != TARGET_BOTH) @@ -509,7 +510,7 @@ static void OpponentHandleChooseMove(u32 battler) bool32 isPartnerEnemy = IsNaturalEnemy(speciesAttacker, speciesTarget); - if (isPartnerEnemy && CanTargetBattler(battler, target, move)) + if (isPartnerEnemy && CanTargetBattler(battler, targetBattler, move)) BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_EXEC_SCRIPT, (chosenMoveIndex) | (GetBattlerAtPosition(BATTLE_PARTNER(battler)) << 8)); else BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_EXEC_SCRIPT, (chosenMoveIndex) | (target << 8)); @@ -526,13 +527,13 @@ static void OpponentHandleChooseMove(u32 battler) } } -static void OpponentHandleChooseItem(u32 battler) +static void OpponentHandleChooseItem(enum BattlerId battler) { BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, gBattleStruct->chosenItem[battler]); BtlController_Complete(battler); } -static void OpponentHandleChoosePokemon(u32 battler) +static void OpponentHandleChoosePokemon(enum BattlerId battler) { s32 chosenMonId; enum SwitchType switchType = SWITCH_AFTER_KO; @@ -559,7 +560,8 @@ static void OpponentHandleChoosePokemon(u32 battler) chosenMonId = GetMostSuitableMonToSwitchInto(battler, switchType); if (chosenMonId == PARTY_SIZE) // Advanced logic failed so we pick the next available battler { - s32 battler1, battler2, firstId, lastId; + enum BattlerId battler1, battler2; + s32 firstId, lastId; if (!IsDoubleBattle()) { @@ -595,17 +597,17 @@ static void OpponentHandleChoosePokemon(u32 battler) BtlController_Complete(battler); } -static void OpponentHandleIntroTrainerBallThrow(u32 battler) +static void OpponentHandleIntroTrainerBallThrow(enum BattlerId battler) { BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void OpponentHandleDrawPartyStatusSummary(u32 battler) +static void OpponentHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void OpponentHandleEndLinkBattle(u32 battler) +static void OpponentHandleEndLinkBattle(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK && !(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)) { diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 9a41983ef9..58d9930e0c 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -49,41 +49,41 @@ #include "test/battle.h" #include "test/test_runner_battle.h" -static void PlayerHandleLoadMonSprite(u32 battler); -static void PlayerHandleDrawTrainerPic(u32 battler); -static void PlayerHandleTrainerSlide(u32 battler); -static void PlayerHandleTrainerSlideBack(u32 battler); -static void PlayerHandlePaletteFade(u32 battler); -static void PlayerHandlePause(u32 battler); -static void PlayerHandleChooseAction(u32 battler); -static void PlayerHandleYesNoBox(u32 battler); -static void PlayerHandleChooseItem(u32 battler); -static void PlayerHandleChoosePokemon(u32 battler); -static void PlayerHandleCmd23(u32 battler); -static void PlayerHandleStatusXor(u32 battler); -static void PlayerHandleDMA3Transfer(u32 battler); -static void PlayerHandlePlayBGM(u32 battler); -static void PlayerHandleTwoReturnValues(u32 battler); -static void PlayerHandleChosenMonReturnValue(u32 battler); -static void PlayerHandleOneReturnValue(u32 battler); -static void PlayerHandleOneReturnValue_Duplicate(u32 battler); -static void PlayerHandleIntroTrainerBallThrow(u32 battler); -static void PlayerHandleDrawPartyStatusSummary(u32 battler); -static void PlayerHandleEndBounceEffect(u32 battler); -static void PlayerHandleLinkStandbyMsg(u32 battler); -static void PlayerHandleResetActionMoveSelection(u32 battler); -static void PlayerHandleEndLinkBattle(u32 battler); -static void PlayerHandleBattleDebug(u32 battler); +static void PlayerHandleLoadMonSprite(enum BattlerId battler); +static void PlayerHandleDrawTrainerPic(enum BattlerId battler); +static void PlayerHandleTrainerSlide(enum BattlerId battler); +static void PlayerHandleTrainerSlideBack(enum BattlerId battler); +static void PlayerHandlePaletteFade(enum BattlerId battler); +static void PlayerHandlePause(enum BattlerId battler); +static void PlayerHandleChooseAction(enum BattlerId battler); +static void PlayerHandleYesNoBox(enum BattlerId battler); +static void PlayerHandleChooseItem(enum BattlerId battler); +static void PlayerHandleChoosePokemon(enum BattlerId battler); +static void PlayerHandleCmd23(enum BattlerId battler); +static void PlayerHandleStatusXor(enum BattlerId battler); +static void PlayerHandleDMA3Transfer(enum BattlerId battler); +static void PlayerHandlePlayBGM(enum BattlerId battler); +static void PlayerHandleTwoReturnValues(enum BattlerId battler); +static void PlayerHandleChosenMonReturnValue(enum BattlerId battler); +static void PlayerHandleOneReturnValue(enum BattlerId battler); +static void PlayerHandleOneReturnValue_Duplicate(enum BattlerId battler); +static void PlayerHandleIntroTrainerBallThrow(enum BattlerId battler); +static void PlayerHandleDrawPartyStatusSummary(enum BattlerId battler); +static void PlayerHandleEndBounceEffect(enum BattlerId battler); +static void PlayerHandleLinkStandbyMsg(enum BattlerId battler); +static void PlayerHandleResetActionMoveSelection(enum BattlerId battler); +static void PlayerHandleEndLinkBattle(enum BattlerId battler); +static void PlayerHandleBattleDebug(enum BattlerId battler); -static void PlayerBufferRunCommand(u32 battler); -static void MoveSelectionDisplayPpNumber(u32 battler); -static void MoveSelectionDisplayPpString(u32 battler); -static void MoveSelectionDisplayMoveType(u32 battler); -static void MoveSelectionDisplayMoveNames(u32 battler); -static void TryMoveSelectionDisplayMoveDescription(u32 battler); -static void MoveSelectionDisplayMoveDescription(u32 battler); -static void WaitForMonSelection(u32 battler); -static void CompleteWhenChoseItem(u32 battler); +static void PlayerBufferRunCommand(enum BattlerId battler); +static void MoveSelectionDisplayPpNumber(enum BattlerId battler); +static void MoveSelectionDisplayPpString(enum BattlerId battler); +static void MoveSelectionDisplayMoveType(enum BattlerId battler); +static void MoveSelectionDisplayMoveNames(enum BattlerId battler); +static void TryMoveSelectionDisplayMoveDescription(enum BattlerId battler); +static void MoveSelectionDisplayMoveDescription(enum BattlerId battler); +static void WaitForMonSelection(enum BattlerId battler); +static void CompleteWhenChoseItem(enum BattlerId battler); static void Task_LaunchLvlUpAnim(u8); static void Task_PrepareToGiveExpWithExpBar(u8); static void Task_SetControllerToWaitForString(u8); @@ -91,12 +91,12 @@ static void Task_GiveExpWithExpBar(u8); static void Task_UpdateLvlInHealthbox(u8); static void PrintLinkStandbyMsg(void); -static void ReloadMoveNames(u32 battler); -static u32 CheckTypeEffectiveness(u32 battlerAtk, u32 battlerDef); -static u32 CheckTargetTypeEffectiveness(u32 battler); -static void MoveSelectionDisplayMoveEffectiveness(u32 foeEffectiveness, u32 battler); +static void ReloadMoveNames(enum BattlerId battler); +static u32 CheckTypeEffectiveness(enum BattlerId battlerAtk, enum BattlerId battlerDef); +static u32 CheckTargetTypeEffectiveness(enum BattlerId battler); +static void MoveSelectionDisplayMoveEffectiveness(u32 foeEffectiveness, enum BattlerId battler); -static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -153,7 +153,7 @@ static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToPlayer(u32 battler) +void SetControllerToPlayer(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_PLAYER; gBattlerControllerEndFuncs[battler] = PlayerBufferExecCompleted; @@ -162,7 +162,7 @@ void SetControllerToPlayer(u32 battler) gPlayerDpadHoldFrames = 0; } -void PlayerBufferExecCompleted(u32 battler) +void PlayerBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = PlayerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -178,7 +178,7 @@ void PlayerBufferExecCompleted(u32 battler) } } -static void PlayerBufferRunCommand(u32 battler) +static void PlayerBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -189,7 +189,7 @@ static void PlayerBufferRunCommand(u32 battler) } } -static void CompleteOnBattlerSpritePosX_0(u32 battler) +static void CompleteOnBattlerSpritePosX_0(enum BattlerId battler) { if (gSprites[gBattlerSpriteIds[battler]].x2 == 0) BtlController_Complete(battler); @@ -229,7 +229,7 @@ static u32 GetNextBall(u32 ballId) return ballId; } -static void HandleInputChooseAction(u32 battler) +static void HandleInputChooseAction(enum BattlerId battler) { enum Item itemId = gBattleResources->bufferA[battler][2] | (gBattleResources->bufferA[battler][3] << 8); @@ -408,12 +408,18 @@ static void HandleInputChooseAction(u32 battler) } } -void HandleInputChooseTarget(u32 battler) +void HandleInputChooseTarget(enum BattlerId battler) { - s32 i; - static const u8 identities[MAX_BATTLERS_COUNT] = {B_POSITION_PLAYER_LEFT, B_POSITION_PLAYER_RIGHT, B_POSITION_OPPONENT_RIGHT, B_POSITION_OPPONENT_LEFT}; + enum BattlerId i; + static const enum BattlerPosition identities[MAX_BATTLERS_COUNT] = + { + B_POSITION_PLAYER_LEFT, + B_POSITION_PLAYER_RIGHT, + B_POSITION_OPPONENT_RIGHT, + B_POSITION_OPPONENT_LEFT, + }; enum Move move = GetMonData(GetBattlerMon(battler), MON_DATA_MOVE1 + gMoveSelectionCursor[battler]); - u16 moveTarget = GetBattlerMoveTargetType(battler, move); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(battler, move); DoBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX, 15, 1); for (i = 0; i < gBattlersCount; i++) @@ -499,7 +505,7 @@ void HandleInputChooseTarget(u32 battler) break; } if (B_SHOW_EFFECTIVENESS) - MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, GetBattlerPosition(gMultiUsePlayerCursor)), battler); + MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, gMultiUsePlayerCursor), battler); if (gAbsentBattlerFlags & (1u << gMultiUsePlayerCursor) || !CanTargetBattler(battler, gMultiUsePlayerCursor, move) @@ -552,7 +558,7 @@ void HandleInputChooseTarget(u32 battler) break; } if (B_SHOW_EFFECTIVENESS) - MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, GetBattlerPosition(gMultiUsePlayerCursor)), battler); + MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, gMultiUsePlayerCursor), battler); if (gAbsentBattlerFlags & (1u << gMultiUsePlayerCursor) || !CanTargetBattler(battler, gMultiUsePlayerCursor, move) @@ -567,8 +573,7 @@ void HandleInputChooseTarget(u32 battler) static void HideAllTargets(void) { - s32 i; - for (i = 0; i < MAX_BATTLERS_COUNT; i++) + for (enum BattlerId i = 0; i < MAX_BATTLERS_COUNT; i++) { if (IsBattlerAlive(i) && gBattleSpritesDataPtr->healthBoxesData[i].healthboxIsBouncing) { @@ -578,7 +583,7 @@ static void HideAllTargets(void) } } -static void HideShownTargets(u32 battler) +static void HideShownTargets(enum BattlerId battler) { s32 i; for (i = 0; i < MAX_BATTLERS_COUNT; i++) @@ -591,7 +596,7 @@ static void HideShownTargets(u32 battler) } } -void HandleInputShowEntireFieldTargets(u32 battler) +void HandleInputShowEntireFieldTargets(enum BattlerId battler) { if (JOY_HELD(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -619,7 +624,7 @@ void HandleInputShowEntireFieldTargets(u32 battler) } } -void HandleInputShowTargets(u32 battler) +void HandleInputShowTargets(enum BattlerId battler) { if (JOY_HELD(DPAD_ANY) && gSaveBlock2Ptr->optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A) gPlayerDpadHoldFrames++; @@ -648,7 +653,7 @@ void HandleInputShowTargets(u32 battler) } } -static void TryShowAsTarget(u32 battler) +static void TryShowAsTarget(enum BattlerId battler) { if (IsBattlerAlive(battler)) { @@ -678,7 +683,7 @@ static bool32 CanSelectBattler(enum MoveTarget target) return FALSE; } -void HandleInputChooseMove(u32 battler) +void HandleInputChooseMove(enum BattlerId battler) { u32 canSelectTarget = 0; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); @@ -734,8 +739,7 @@ void HandleInputChooseMove(u32 battler) // Show all available targets for multi-target moves if (moveTarget == TARGET_ALL_BATTLERS || moveTarget == TARGET_FIELD) { - u32 i = 0; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) TryShowAsTarget(i); canSelectTarget = 3; @@ -773,7 +777,7 @@ void HandleInputChooseMove(u32 battler) else gMultiUsePlayerCursor = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); if (B_SHOW_EFFECTIVENESS) - MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, GetBattlerPosition(gMultiUsePlayerCursor)), battler); + MoveSelectionDisplayMoveEffectiveness(CheckTypeEffectiveness(battler, gMultiUsePlayerCursor), battler); gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_ShowAsMoveTarget; break; @@ -926,7 +930,7 @@ void HandleInputChooseMove(u32 battler) } } -static void ReloadMoveNames(u32 battler) +static void ReloadMoveNames(enum BattlerId battler) { if (gBattleStruct->zmove.viable && !gBattleStruct->zmove.viewing) { @@ -946,7 +950,7 @@ static void ReloadMoveNames(u32 battler) } } -static u32 UNUSED HandleMoveInputUnused(u32 battler) +static u32 UNUSED HandleMoveInputUnused(enum BattlerId battler) { u32 var = 0; @@ -996,7 +1000,7 @@ static u32 UNUSED HandleMoveInputUnused(u32 battler) return var; } -void HandleMoveSwitching(u32 battler) +void HandleMoveSwitching(enum BattlerId battler) { u8 perMovePPBonuses[MAX_MON_MOVES]; struct ChooseMoveStruct moveStruct; @@ -1188,7 +1192,7 @@ void HandleMoveSwitching(u32 battler) } } -static void SetLinkBattleEndCallbacks(u32 battler) +static void SetLinkBattleEndCallbacks(enum BattlerId battler) { if (gWirelessCommType == 0) { @@ -1219,7 +1223,7 @@ static void SetLinkBattleEndCallbacks(u32 battler) } // Despite handling link battles separately, this is only ever used by link battles -void SetBattleEndCallbacks(u32 battler) +void SetBattleEndCallbacks(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -1245,7 +1249,7 @@ void SetBattleEndCallbacks(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool8 healthboxAnimDone = FALSE; @@ -1283,7 +1287,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; @@ -1384,7 +1388,7 @@ void Task_PlayerController_RestoreBgmAfterCry(u8 taskId) #define tExpTask_gainedExp_2 data[4] // Stored as two half-words containing a word. #define tExpTask_frames data[10] -static void DynamaxModifyHPLevelUp(struct Pokemon *mon, u32 battler, u32 oldMaxHP) +static void DynamaxModifyHPLevelUp(struct Pokemon *mon, enum BattlerId battler, u32 oldMaxHP) { ApplyDynamaxHPMultiplier(mon); gBattleScripting.levelUpHP = GetMonData(mon, MON_DATA_MAX_HP) - oldMaxHP; // overwrite levelUpHP since it overflows @@ -1400,7 +1404,7 @@ static s32 GetTaskExpValue(u8 taskId) static void Task_GiveExpToMon(u8 taskId) { u32 monId = (u8)(gTasks[taskId].tExpTask_monId); - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; s32 gainedExp = GetTaskExpValue(taskId); if (GetBattlerCoordsIndex(battler) == BATTLE_COORDS_DOUBLES || monId != gBattlerPartyIndexes[battler]) // Give exp without moving the expbar. @@ -1450,7 +1454,7 @@ static void Task_PrepareToGiveExpWithExpBar(u8 taskId) { u8 monIndex = gTasks[taskId].tExpTask_monId; s32 gainedExp = GetTaskExpValue(taskId); - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; struct Pokemon *mon = &gPlayerParty[monIndex]; u8 level = GetMonData(mon, MON_DATA_LEVEL); u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1481,7 +1485,7 @@ static void Task_GiveExpWithExpBar(u8 taskId) { u8 monId = gTasks[taskId].tExpTask_monId; s32 gainedExp = GetTaskExpValue(taskId); - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; struct Pokemon *mon = &gPlayerParty[monId]; newExpPoints = MoveBattleBar(battler, gHealthboxSpriteIds[battler], EXP_BAR, 0); @@ -1526,7 +1530,7 @@ static void Task_GiveExpWithExpBar(u8 taskId) static void Task_LaunchLvlUpAnim(u8 taskId) { - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; u8 monIndex = gTasks[taskId].tExpTask_monId; if (IsDoubleBattle() == TRUE && monIndex == gBattlerPartyIndexes[BATTLE_PARTNER(battler)]) @@ -1538,7 +1542,7 @@ static void Task_LaunchLvlUpAnim(u8 taskId) static void Task_UpdateLvlInHealthbox(u8 taskId) { - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { @@ -1555,12 +1559,12 @@ static void Task_UpdateLvlInHealthbox(u8 taskId) static void Task_SetControllerToWaitForString(u8 taskId) { - u8 battler = gTasks[taskId].tExpTask_battler; + enum BattlerId battler = gTasks[taskId].tExpTask_battler; gBattlerControllerFuncs[battler] = Controller_WaitForString; DestroyTask(taskId); } -static void OpenPartyMenuToChooseMon(u32 battler) +static void OpenPartyMenuToChooseMon(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -1574,7 +1578,7 @@ static void OpenPartyMenuToChooseMon(u32 battler) } } -static void WaitForMonSelection(u32 battler) +static void WaitForMonSelection(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -1590,7 +1594,7 @@ static void WaitForMonSelection(u32 battler) } } -static void OpenBagAndChooseItem(u32 battler) +static void OpenBagAndChooseItem(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -1601,7 +1605,7 @@ static void OpenBagAndChooseItem(u32 battler) } } -static void CompleteWhenChoseItem(u32 battler) +static void CompleteWhenChoseItem(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -1610,7 +1614,7 @@ static void CompleteWhenChoseItem(u32 battler) } } -static void PlayerHandleYesNoInput(u32 battler) +static void PlayerHandleYesNoInput(enum BattlerId battler) { if (JOY_NEW(DPAD_UP) && gMultiUsePlayerCursor != 0) { @@ -1646,7 +1650,7 @@ static void PlayerHandleYesNoInput(u32 battler) } } -static void MoveSelectionDisplayMoveNames(u32 battler) +static void MoveSelectionDisplayMoveNames(enum BattlerId battler) { s32 i; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); @@ -1666,13 +1670,13 @@ static void MoveSelectionDisplayMoveNames(u32 battler) } } -static void MoveSelectionDisplayPpString(u32 battler) +static void MoveSelectionDisplayPpString(enum BattlerId battler) { StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP); BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP); } -static void MoveSelectionDisplayPpNumber(u32 battler) +static void MoveSelectionDisplayPpNumber(enum BattlerId battler) { u8 *txtPtr; struct ChooseMoveStruct *moveInfo; @@ -1689,7 +1693,7 @@ static void MoveSelectionDisplayPpNumber(u32 battler) BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP_REMAINING); } -static void MoveSelectionDisplayMoveType(u32 battler) +static void MoveSelectionDisplayMoveType(enum BattlerId battler) { u8 *txtPtr, *end; u32 speciesId = gBattleMons[battler].species; @@ -1733,7 +1737,7 @@ static void MoveSelectionDisplayMoveType(u32 battler) BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MOVE_TYPE); } -static void TryMoveSelectionDisplayMoveDescription(u32 battler) +static void TryMoveSelectionDisplayMoveDescription(enum BattlerId battler) { if (!B_SHOW_MOVE_DESCRIPTION) return; @@ -1742,7 +1746,7 @@ static void TryMoveSelectionDisplayMoveDescription(u32 battler) MoveSelectionDisplayMoveDescription(battler); } -static void MoveSelectionDisplayMoveDescription(u32 battler) +static void MoveSelectionDisplayMoveDescription(enum BattlerId battler) { struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleResources->bufferA[battler][4]); enum Move move = moveInfo->moves[gMoveSelectionCursor[battler]]; @@ -1854,7 +1858,7 @@ static void PrintLinkStandbyMsg(void) } } -static void PlayerHandleLoadMonSprite(u32 battler) +static void PlayerHandleLoadMonSprite(enum BattlerId battler) { BattleLoadMonSpriteGfx(GetBattlerMon(battler), battler); gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler; @@ -1893,7 +1897,7 @@ static enum TrainerPicID PlayerGetTrainerBackPicId(void) // In emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) // that use an animated back pic. -static void PlayerHandleDrawTrainerPic(u32 battler) +static void PlayerHandleDrawTrainerPic(enum BattlerId battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -1950,24 +1954,24 @@ static void PlayerHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void PlayerHandleTrainerSlide(u32 battler) +static void PlayerHandleTrainerSlide(enum BattlerId battler) { enum TrainerPicID trainerPicId = PlayerGetTrainerBackPicId(); BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void PlayerHandleTrainerSlideBack(u32 battler) +static void PlayerHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 50, TRUE); } -static void PlayerHandlePaletteFade(u32 battler) +static void PlayerHandlePaletteFade(enum BattlerId battler) { BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK); BtlController_Complete(battler); } -static void PlayerHandlePause(u32 battler) +static void PlayerHandlePause(enum BattlerId battler) { u8 timer = gBattleResources->bufferA[battler][1]; @@ -1977,7 +1981,7 @@ static void PlayerHandlePause(u32 battler) BtlController_Complete(battler); } -static void HandleChooseActionAfterDma3(u32 battler) +static void HandleChooseActionAfterDma3(enum BattlerId battler) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -2004,7 +2008,7 @@ static void HandleChooseActionAfterDma3(u32 battler) } } -static void PlayerHandleChooseAction(u32 battler) +static void PlayerHandleChooseAction(enum BattlerId battler) { s32 i; @@ -2020,21 +2024,22 @@ static void PlayerHandleChooseAction(u32 battler) PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, battler, gBattlerPartyIndexes[battler]); BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo); - if (B_SHOW_PARTNER_TARGET && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && IsBattlerAlive(B_POSITION_PLAYER_RIGHT)) + enum BattlerId partner = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + if (B_SHOW_PARTNER_TARGET && gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER && IsBattlerAlive(partner)) { StringCopy(gStringVar1, COMPOUND_STRING("Partner will use:\n")); - enum Move move = GetChosenMoveFromPosition(B_POSITION_PLAYER_RIGHT); + enum Move move = GetBattlerChosenMove(partner); StringAppend(gStringVar1, GetMoveName(move)); - enum MoveTarget moveTarget = GetBattlerMoveTargetType(B_POSITION_PLAYER_RIGHT, move); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(partner, move); if (moveTarget == TARGET_SELECTED || moveTarget == TARGET_SMART) { - if (gAiBattleData->chosenTarget[B_POSITION_PLAYER_RIGHT] == B_POSITION_OPPONENT_LEFT) + if (gAiBattleData->chosenTarget[partner] == B_POSITION_OPPONENT_LEFT) StringAppend(gStringVar1, COMPOUND_STRING(" -{UP_ARROW}")); - else if (gAiBattleData->chosenTarget[B_POSITION_PLAYER_RIGHT] == B_POSITION_OPPONENT_RIGHT) + else if (gAiBattleData->chosenTarget[partner] == B_POSITION_OPPONENT_RIGHT) StringAppend(gStringVar1, COMPOUND_STRING(" {UP_ARROW}-")); - else if (gAiBattleData->chosenTarget[B_POSITION_PLAYER_RIGHT] == B_POSITION_PLAYER_LEFT) + else if (gAiBattleData->chosenTarget[partner] == B_POSITION_PLAYER_LEFT) StringAppend(gStringVar1, COMPOUND_STRING(" {DOWN_ARROW}-")); - else if (gAiBattleData->chosenTarget[B_POSITION_PLAYER_RIGHT] == B_POSITION_PLAYER_RIGHT) + else if (gAiBattleData->chosenTarget[partner] == B_POSITION_PLAYER_RIGHT) StringAppend(gStringVar1, COMPOUND_STRING(" -{DOWN_ARROW}")); } else if (moveTarget == TARGET_USER_AND_ALLY) @@ -2061,7 +2066,7 @@ static void PlayerHandleChooseAction(u32 battler) } } -static void PlayerHandleYesNoBox(u32 battler) +static void PlayerHandleYesNoBox(enum BattlerId battler) { if (IsOnPlayerSide(battler)) { @@ -2077,7 +2082,7 @@ static void PlayerHandleYesNoBox(u32 battler) } } -void HandleChooseMoveAfterDma3(u32 battler) +void HandleChooseMoveAfterDma3(enum BattlerId battler) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -2089,7 +2094,7 @@ void HandleChooseMoveAfterDma3(u32 battler) // arenaMindPoints is used here as a placeholder for a timer. -static void PlayerChooseMoveInBattlePalace(u32 battler) +static void PlayerChooseMoveInBattlePalace(enum BattlerId battler) { if (--gBattleStruct->arenaMindPoints[battler] == 0) { @@ -2099,7 +2104,7 @@ static void PlayerChooseMoveInBattlePalace(u32 battler) } } -void PlayerHandleChooseMove(u32 battler) +void PlayerHandleChooseMove(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -2128,7 +2133,7 @@ void PlayerHandleChooseMove(u32 battler) } } -void InitMoveSelectionsVarsAndStrings(u32 battler) +void InitMoveSelectionsVarsAndStrings(enum BattlerId battler) { LoadTypeIcons(battler); MoveSelectionDisplayMoveNames(battler); @@ -2142,7 +2147,7 @@ void InitMoveSelectionsVarsAndStrings(u32 battler) MoveSelectionDisplayMoveType(battler); } -static void PlayerHandleChooseItem(u32 battler) +static void PlayerHandleChooseItem(enum BattlerId battler) { s32 i; @@ -2154,7 +2159,7 @@ static void PlayerHandleChooseItem(u32 battler) gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[battler][1 + i]; } -static void PlayerHandleChoosePokemon(u32 battler) +static void PlayerHandleChoosePokemon(enum BattlerId battler) { s32 i; @@ -2181,14 +2186,14 @@ static void PlayerHandleChoosePokemon(u32 battler) } } -static void PlayerHandleCmd23(u32 battler) +static void PlayerHandleCmd23(enum BattlerId battler) { BattleStopLowHpSound(); BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK); BtlController_Complete(battler); } -void PlayerHandleExpUpdate(u32 battler) +void PlayerHandleExpUpdate(enum BattlerId battler) { u8 monId = gBattleResources->bufferA[battler][1]; s32 taskId, expPointsToGive; @@ -2216,7 +2221,7 @@ void PlayerHandleExpUpdate(u32 battler) #undef tExpTask_gainedExp_2 #undef tExpTask_frames -static void PlayerHandleStatusXor(u32 battler) +static void PlayerHandleStatusXor(enum BattlerId battler) { u32 val = GetMonData(GetBattlerMon(battler), MON_DATA_STATUS) ^ gBattleResources->bufferA[battler][1]; @@ -2224,7 +2229,7 @@ static void PlayerHandleStatusXor(u32 battler) BtlController_Complete(battler); } -static void PlayerHandleDMA3Transfer(u32 battler) +static void PlayerHandleDMA3Transfer(enum BattlerId battler) { u32 dstArg = gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8) @@ -2251,56 +2256,56 @@ static void PlayerHandleDMA3Transfer(u32 battler) BtlController_Complete(battler); } -static void PlayerHandlePlayBGM(u32 battler) +static void PlayerHandlePlayBGM(enum BattlerId battler) { PlayBGM(gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8)); BtlController_Complete(battler); } -static void PlayerHandleTwoReturnValues(u32 battler) +static void PlayerHandleTwoReturnValues(enum BattlerId battler) { BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, B_ACTION_USE_MOVE, 0); BtlController_Complete(battler); } -static void PlayerHandleChosenMonReturnValue(u32 battler) +static void PlayerHandleChosenMonReturnValue(enum BattlerId battler) { BtlController_EmitChosenMonReturnValue(battler, B_COMM_TO_ENGINE, 0, NULL); BtlController_Complete(battler); } -static void PlayerHandleOneReturnValue(u32 battler) +static void PlayerHandleOneReturnValue(enum BattlerId battler) { BtlController_EmitOneReturnValue(battler, B_COMM_TO_ENGINE, 0); BtlController_Complete(battler); } -static void PlayerHandleOneReturnValue_Duplicate(u32 battler) +static void PlayerHandleOneReturnValue_Duplicate(enum BattlerId battler) { BtlController_EmitOneReturnValue_Duplicate(battler, B_COMM_TO_ENGINE, 0); BtlController_Complete(battler); } -static void PlayerHandleIntroTrainerBallThrow(u32 battler) +static void PlayerHandleIntroTrainerBallThrow(enum BattlerId battler) { const u32 paletteIndex = PlayerGetTrainerBackPicId() - TRAINER_PIC_FRONT_COUNT; const u16 *trainerPal = gTrainerBacksprites[paletteIndex].palette.data; BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); } -static void PlayerHandleDrawPartyStatusSummary(u32 battler) +static void PlayerHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void PlayerHandleEndBounceEffect(u32 battler) +static void PlayerHandleEndBounceEffect(enum BattlerId battler) { EndBounceEffect(battler, BOUNCE_HEALTHBOX); EndBounceEffect(battler, BOUNCE_MON); BtlController_Complete(battler); } -static void PlayerHandleLinkStandbyMsg(u32 battler) +static void PlayerHandleLinkStandbyMsg(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][2]); switch (gBattleResources->bufferA[battler][1]) @@ -2319,7 +2324,7 @@ static void PlayerHandleLinkStandbyMsg(u32 battler) BtlController_Complete(battler); } -static void PlayerHandleResetActionMoveSelection(u32 battler) +static void PlayerHandleResetActionMoveSelection(enum BattlerId battler) { switch (gBattleResources->bufferA[battler][1]) { @@ -2337,7 +2342,7 @@ static void PlayerHandleResetActionMoveSelection(u32 battler) BtlController_Complete(battler); } -static void PlayerHandleEndLinkBattle(u32 battler) +static void PlayerHandleEndLinkBattle(enum BattlerId battler) { RecordedBattle_RecordAllBattlerData(&gBattleResources->bufferA[battler][4]); gBattleOutcome = gBattleResources->bufferA[battler][1]; @@ -2348,7 +2353,7 @@ static void PlayerHandleEndLinkBattle(u32 battler) gBattlerControllerFuncs[battler] = SetBattleEndCallbacks; } -static void Controller_WaitForDebug(u32 battler) +static void Controller_WaitForDebug(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -2356,7 +2361,7 @@ static void Controller_WaitForDebug(u32 battler) } } -static void PlayerHandleBattleDebug(u32 battler) +static void PlayerHandleBattleDebug(enum BattlerId battler) { BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); SetMainCallback2(CB2_BattleDebugMenu); @@ -2384,7 +2389,7 @@ static bool32 ShouldShowTypeEffectiveness(u32 targetId) return TRUE; } -static u32 CheckTypeEffectiveness(u32 battlerAtk, u32 battlerDef) +static u32 CheckTypeEffectiveness(enum BattlerId battlerAtk, enum BattlerId battlerDef) { struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battlerAtk][4]); struct BattleContext ctx = {0}; @@ -2412,14 +2417,14 @@ static u32 CheckTypeEffectiveness(u32 battlerAtk, u32 battlerDef) return EFFECTIVENESS_NORMAL; // Normal effectiveness } -static u32 CheckTargetTypeEffectiveness(u32 battler) +static u32 CheckTargetTypeEffectiveness(enum BattlerId battler) { - u32 battlerFoe = BATTLE_OPPOSITE(battler); + enum BattlerId battlerFoe = BATTLE_OPPOSITE(battler); u32 foeEffectiveness = CheckTypeEffectiveness(battler, battlerFoe); if (IsDoubleBattle()) { - u32 partnerFoe = BATTLE_PARTNER(battlerFoe); + enum BattlerId partnerFoe = BATTLE_PARTNER(battlerFoe); u32 partnerFoeEffectiveness = CheckTypeEffectiveness(battler, partnerFoe); if (!IsBattlerAlive(battlerFoe)) return partnerFoeEffectiveness; @@ -2430,7 +2435,7 @@ static u32 CheckTargetTypeEffectiveness(u32 battler) return foeEffectiveness; // fallthrough for any other circumstance } -static void MoveSelectionDisplayMoveEffectiveness(u32 foeEffectiveness, u32 battler) +static void MoveSelectionDisplayMoveEffectiveness(u32 foeEffectiveness, enum BattlerId battler) { static const u8 noIcon[] = _(""); static const u8 effectiveIcon[] = _("{CIRCLE_HOLLOW}"); diff --git a/src/battle_controller_player_partner.c b/src/battle_controller_player_partner.c index c4e3a35275..1eabd39076 100644 --- a/src/battle_controller_player_partner.c +++ b/src/battle_controller_player_partner.c @@ -36,19 +36,19 @@ #include "test/battle.h" #include "test/test_runner_battle.h" -static void PlayerPartnerHandleDrawTrainerPic(u32 battler); -static void PlayerPartnerHandleTrainerSlide(u32 battler); -static void PlayerPartnerHandleTrainerSlideBack(u32 battler); -static void PlayerPartnerHandleChooseAction(u32 battler); -static void PlayerPartnerHandleChooseMove(u32 battler); -static void PlayerPartnerHandleChoosePokemon(u32 battler); -static void PlayerPartnerHandleIntroTrainerBallThrow(u32 battler); -static void PlayerPartnerHandleDrawPartyStatusSummary(u32 battler); -static void PlayerPartnerHandleEndLinkBattle(u32 battler); +static void PlayerPartnerHandleDrawTrainerPic(enum BattlerId battler); +static void PlayerPartnerHandleTrainerSlide(enum BattlerId battler); +static void PlayerPartnerHandleTrainerSlideBack(enum BattlerId battler); +static void PlayerPartnerHandleChooseAction(enum BattlerId battler); +static void PlayerPartnerHandleChooseMove(enum BattlerId battler); +static void PlayerPartnerHandleChoosePokemon(enum BattlerId battler); +static void PlayerPartnerHandleIntroTrainerBallThrow(enum BattlerId battler); +static void PlayerPartnerHandleDrawPartyStatusSummary(enum BattlerId battler); +static void PlayerPartnerHandleEndLinkBattle(enum BattlerId battler); -static void PlayerPartnerBufferRunCommand(u32 battler); +static void PlayerPartnerBufferRunCommand(enum BattlerId battler); -static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -105,14 +105,14 @@ static void (*const sPlayerPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 bat [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToPlayerPartner(u32 battler) +void SetControllerToPlayerPartner(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_PLAYER_PARTNER; gBattlerControllerEndFuncs[battler] = PlayerPartnerBufferExecCompleted; gBattlerControllerFuncs[battler] = PlayerPartnerBufferRunCommand; } -static void PlayerPartnerBufferRunCommand(u32 battler) +static void PlayerPartnerBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -123,7 +123,7 @@ static void PlayerPartnerBufferRunCommand(u32 battler) } } -static void Intro_WaitForHealthbox(u32 battler) +static void Intro_WaitForHealthbox(enum BattlerId battler) { bool32 finished = FALSE; @@ -152,7 +152,7 @@ static void Intro_WaitForHealthbox(u32 battler) } // Also used by the link partner. -void Controller_PlayerPartnerShowIntroHealthbox(u32 battler) +void Controller_PlayerPartnerShowIntroHealthbox(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive @@ -182,7 +182,7 @@ void Controller_PlayerPartnerShowIntroHealthbox(u32 battler) } } -void PlayerPartnerBufferExecCompleted(u32 battler) +void PlayerPartnerBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = PlayerPartnerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -213,7 +213,7 @@ static enum TrainerPicID PlayerPartnerGetTrainerBackPicId(enum DifficultyLevel d // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it -static void PlayerPartnerHandleDrawTrainerPic(u32 battler) +static void PlayerPartnerHandleDrawTrainerPic(enum BattlerId battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -255,32 +255,32 @@ static void PlayerPartnerHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void PlayerPartnerHandleTrainerSlide(u32 battler) +static void PlayerPartnerHandleTrainerSlide(enum BattlerId battler) { enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); enum TrainerPicID trainerPicId = PlayerPartnerGetTrainerBackPicId(difficulty); BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void PlayerPartnerHandleTrainerSlideBack(u32 battler) +static void PlayerPartnerHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void PlayerPartnerHandleChooseAction(u32 battler) +static void PlayerPartnerHandleChooseAction(enum BattlerId battler) { AI_TrySwitchOrUseItem(battler); BtlController_Complete(battler); } -static void PlayerPartnerHandleChooseMove(u32 battler) +static void PlayerPartnerHandleChooseMove(enum BattlerId battler) { u32 chosenMoveIndex; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); chosenMoveIndex = gAiBattleData->chosenMoveIndex[battler]; gBattlerTarget = gAiBattleData->chosenTarget[battler]; - u32 moveTarget = GetBattlerMoveTargetType(battler, moveInfo->moves[chosenMoveIndex]); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(battler, moveInfo->moves[chosenMoveIndex]); if (moveTarget == TARGET_USER || moveTarget == TARGET_USER_OR_ALLY) { @@ -308,7 +308,7 @@ static void PlayerPartnerHandleChooseMove(u32 battler) BtlController_Complete(battler); } -static void PlayerPartnerHandleChoosePokemon(u32 battler) +static void PlayerPartnerHandleChoosePokemon(enum BattlerId battler) { s32 chosenMonId; // Choosing Revival Blessing target @@ -323,8 +323,8 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler) if (chosenMonId == PARTY_SIZE || !IsValidForBattle(&gPlayerParty[chosenMonId])) // just switch to the next mon { s32 firstId = (IsAiVsAiBattle()) ? 0 : (PARTY_SIZE / 2); - u32 battler1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u32 battler2 = IsDoubleBattle() ? GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT) : battler1; + enum BattlerId battler1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId battler2 = IsDoubleBattle() ? GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT) : battler1; for (chosenMonId = firstId; chosenMonId < PARTY_SIZE; chosenMonId++) { @@ -351,7 +351,7 @@ static void PlayerPartnerHandleChoosePokemon(u32 battler) BtlController_Complete(battler); } -static void PlayerPartnerHandleIntroTrainerBallThrow(u32 battler) +static void PlayerPartnerHandleIntroTrainerBallThrow(enum BattlerId battler) { const u16 *trainerPal; enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); @@ -366,12 +366,12 @@ static void PlayerPartnerHandleIntroTrainerBallThrow(u32 battler) BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_PlayerPartnerShowIntroHealthbox); } -static void PlayerPartnerHandleDrawPartyStatusSummary(u32 battler) +static void PlayerPartnerHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void PlayerPartnerHandleEndLinkBattle(u32 battler) +static void PlayerPartnerHandleEndLinkBattle(enum BattlerId battler) { gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); diff --git a/src/battle_controller_recorded_opponent.c b/src/battle_controller_recorded_opponent.c index d94025e955..bc68eb914b 100644 --- a/src/battle_controller_recorded_opponent.c +++ b/src/battle_controller_recorded_opponent.c @@ -35,20 +35,20 @@ #include "test/battle.h" #include "test/test_runner_battle.h" -static void RecordedOpponentHandleDrawTrainerPic(u32 battler); -static void RecordedOpponentHandleTrainerSlideBack(u32 battler); -static void RecordedOpponentHandleChooseAction(u32 battler); -static void RecordedOpponentHandleChooseMove(u32 battler); -static void RecordedOpponentHandleChooseItem(u32 battler); -static void RecordedOpponentHandleChoosePokemon(u32 battler); -static void RecordedOpponentHandleStatusAnimation(u32 battler); -static void RecordedOpponentHandleIntroTrainerBallThrow(u32 battler); -static void RecordedOpponentHandleDrawPartyStatusSummary(u32 battler); -static void RecordedOpponentHandleEndLinkBattle(u32 battler); +static void RecordedOpponentHandleDrawTrainerPic(enum BattlerId battler); +static void RecordedOpponentHandleTrainerSlideBack(enum BattlerId battler); +static void RecordedOpponentHandleChooseAction(enum BattlerId battler); +static void RecordedOpponentHandleChooseMove(enum BattlerId battler); +static void RecordedOpponentHandleChooseItem(enum BattlerId battler); +static void RecordedOpponentHandleChoosePokemon(enum BattlerId battler); +static void RecordedOpponentHandleStatusAnimation(enum BattlerId battler); +static void RecordedOpponentHandleIntroTrainerBallThrow(enum BattlerId battler); +static void RecordedOpponentHandleDrawPartyStatusSummary(enum BattlerId battler); +static void RecordedOpponentHandleEndLinkBattle(enum BattlerId battler); -static void RecordedOpponentBufferRunCommand(u32 battler); +static void RecordedOpponentBufferRunCommand(enum BattlerId battler); -static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -105,14 +105,14 @@ static void (*const sRecordedOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToRecordedOpponent(u32 battler) +void SetControllerToRecordedOpponent(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_RECORDED_OPPONENT; gBattlerControllerEndFuncs[battler] = RecordedOpponentBufferExecCompleted; gBattlerControllerFuncs[battler] = RecordedOpponentBufferRunCommand; } -static void RecordedOpponentBufferRunCommand(u32 battler) +static void RecordedOpponentBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -123,7 +123,7 @@ static void RecordedOpponentBufferRunCommand(u32 battler) } } -void RecordedOpponentBufferExecCompleted(u32 battler) +void RecordedOpponentBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = RecordedOpponentBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -139,7 +139,7 @@ void RecordedOpponentBufferExecCompleted(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool8 healthboxAnimDone = FALSE; @@ -180,7 +180,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { bool32 bgmRestored = FALSE; bool32 battlerAnimsDone = FALSE; @@ -270,15 +270,16 @@ static void Intro_TryShinyAnimShowHealthbox(u32 battler) } } -static void RecordedOpponentHandleDrawTrainerPic(u32 battler) +static void RecordedOpponentHandleDrawTrainerPic(enum BattlerId battler) { s16 xPos; enum TrainerPicID trainerPicId; + enum BattlerPosition position = GetBattlerPosition(battler); // Sets Multibattle test opponent sprites to not be Hiker if (IsMultibattleTest()) { - if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_LEFT) + if (position == B_POSITION_OPPONENT_LEFT) { trainerPicId = TRAINER_PIC_FRONT_LEAF; if (!(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) @@ -294,14 +295,14 @@ static void RecordedOpponentHandleDrawTrainerPic(u32 battler) } else if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - if ((GetBattlerPosition(battler) & BIT_FLANK) != 0) // second mon + if ((position & BIT_FLANK) != 0) // second mon xPos = 152; else // first mon xPos = 200; if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) { - if (battler == B_POSITION_OPPONENT_LEFT) + if (position == B_POSITION_OPPONENT_LEFT) trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentA); else trainerPicId = GetFrontierTrainerFrontSpriteId(TRAINER_BATTLE_PARAM.opponentB); @@ -327,18 +328,18 @@ static void RecordedOpponentHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, TRUE, xPos, 40, -1); } -static void RecordedOpponentHandleTrainerSlideBack(u32 battler) +static void RecordedOpponentHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void RecordedOpponentHandleChooseAction(u32 battler) +static void RecordedOpponentHandleChooseAction(enum BattlerId battler) { BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); BtlController_Complete(battler); } -static void RecordedOpponentHandleChooseMove(u32 battler) +static void RecordedOpponentHandleChooseMove(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -354,7 +355,7 @@ static void RecordedOpponentHandleChooseMove(u32 battler) BtlController_Complete(battler); } -static void RecordedOpponentHandleChooseItem(u32 battler) +static void RecordedOpponentHandleChooseItem(enum BattlerId battler) { u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); @@ -365,7 +366,7 @@ static void RecordedOpponentHandleChooseItem(u32 battler) BtlController_Complete(battler); } -static void RecordedOpponentHandleChoosePokemon(u32 battler) +static void RecordedOpponentHandleChoosePokemon(enum BattlerId battler) { gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing @@ -373,22 +374,22 @@ static void RecordedOpponentHandleChoosePokemon(u32 battler) BtlController_Complete(battler); } -static void RecordedOpponentHandleStatusAnimation(u32 battler) +static void RecordedOpponentHandleStatusAnimation(enum BattlerId battler) { BtlController_HandleStatusAnimation(battler); } -static void RecordedOpponentHandleIntroTrainerBallThrow(u32 battler) +static void RecordedOpponentHandleIntroTrainerBallThrow(enum BattlerId battler) { BtlController_HandleIntroTrainerBallThrow(battler, 0, NULL, 0, Intro_TryShinyAnimShowHealthbox); } -static void RecordedOpponentHandleDrawPartyStatusSummary(u32 battler) +static void RecordedOpponentHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_OPPONENT, TRUE); } -static void RecordedOpponentHandleEndLinkBattle(u32 battler) +static void RecordedOpponentHandleEndLinkBattle(enum BattlerId battler) { if (gBattleResources->bufferA[battler][1] == B_OUTCOME_DREW) gBattleOutcome = gBattleResources->bufferA[battler][1]; diff --git a/src/battle_controller_recorded_partner.c b/src/battle_controller_recorded_partner.c index e4c52415ce..3599f8f1cb 100644 --- a/src/battle_controller_recorded_partner.c +++ b/src/battle_controller_recorded_partner.c @@ -35,18 +35,18 @@ #include "constants/party_menu.h" #include "constants/trainers.h" -static void RecordedPartnerHandleDrawTrainerPic(u32 battler); -static void RecordedPartnerHandleTrainerSlide(u32 battler); -static void RecordedPartnerHandleTrainerSlideBack(u32 battler); -static void RecordedPartnerHandleChooseAction(u32 battler); -static void RecordedPartnerHandleChooseMove(u32 battler); -static void RecordedPartnerHandleChoosePokemon(u32 battler); -static void RecordedPartnerHandleIntroTrainerBallThrow(u32 battler); -static void RecordedPartnerHandleDrawPartyStatusSummary(u32 battler); -static void RecordedPartnerHandleEndLinkBattle(u32 battler); -static void RecordedPartnerBufferRunCommand(u32 battler); +static void RecordedPartnerHandleDrawTrainerPic(enum BattlerId battler); +static void RecordedPartnerHandleTrainerSlide(enum BattlerId battler); +static void RecordedPartnerHandleTrainerSlideBack(enum BattlerId battler); +static void RecordedPartnerHandleChooseAction(enum BattlerId battler); +static void RecordedPartnerHandleChooseMove(enum BattlerId battler); +static void RecordedPartnerHandleChoosePokemon(enum BattlerId battler); +static void RecordedPartnerHandleIntroTrainerBallThrow(enum BattlerId battler); +static void RecordedPartnerHandleDrawPartyStatusSummary(enum BattlerId battler); +static void RecordedPartnerHandleEndLinkBattle(enum BattlerId battler); +static void RecordedPartnerBufferRunCommand(enum BattlerId battler); -static void (*const sRecordedPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sRecordedPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -103,14 +103,14 @@ static void (*const sRecordedPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 b [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToRecordedPartner(u32 battler) +void SetControllerToRecordedPartner(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_RECORDED_PARTNER; gBattlerControllerEndFuncs[battler] = RecordedPartnerBufferExecCompleted; gBattlerControllerFuncs[battler] = RecordedPartnerBufferRunCommand; } -static void RecordedPartnerBufferRunCommand(u32 battler) +static void RecordedPartnerBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -121,7 +121,7 @@ static void RecordedPartnerBufferRunCommand(u32 battler) } } -static void Intro_WaitForHealthbox(u32 battler) +static void Intro_WaitForHealthbox(enum BattlerId battler) { bool32 finished = FALSE; @@ -149,7 +149,7 @@ static void Intro_WaitForHealthbox(u32 battler) } } -void Controller_RecordedPartnerShowIntroHealthbox(u32 battler) +void Controller_RecordedPartnerShowIntroHealthbox(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[BATTLE_PARTNER(battler)].ballAnimActive @@ -179,7 +179,7 @@ void Controller_RecordedPartnerShowIntroHealthbox(u32 battler) } } -void RecordedPartnerBufferExecCompleted(u32 battler) +void RecordedPartnerBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = RecordedPartnerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -210,7 +210,7 @@ static enum TrainerPicID RecordedPartnerGetTrainerBackPicId(enum DifficultyLevel // some explanation here // in emerald it's possible to have a tag battle in the battle frontier facilities with AI // which use the front sprite for both the player and the partner as opposed to any other battles (including the one with Steven) that use the back pic as well as animate it -static void RecordedPartnerHandleDrawTrainerPic(u32 battler) +static void RecordedPartnerHandleDrawTrainerPic(enum BattlerId battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -225,25 +225,25 @@ static void RecordedPartnerHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void RecordedPartnerHandleTrainerSlide(u32 battler) +static void RecordedPartnerHandleTrainerSlide(enum BattlerId battler) { enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); enum TrainerPicID trainerPicId = RecordedPartnerGetTrainerBackPicId(difficulty); BtlController_HandleTrainerSlide(battler, trainerPicId); } -static void RecordedPartnerHandleTrainerSlideBack(u32 battler) +static void RecordedPartnerHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void RecordedPartnerHandleChooseAction(u32 battler) +static void RecordedPartnerHandleChooseAction(enum BattlerId battler) { BtlController_EmitTwoReturnValues(battler, B_COMM_TO_ENGINE, RecordedBattle_GetBattlerAction(RECORDED_ACTION_TYPE, battler), 0); BtlController_Complete(battler); } -static void RecordedPartnerHandleChooseMove(u32 battler) +static void RecordedPartnerHandleChooseMove(enum BattlerId battler) { u8 moveIndex = RecordedBattle_GetBattlerAction(RECORDED_MOVE_SLOT, battler); u8 target = RecordedBattle_GetBattlerAction(RECORDED_MOVE_TARGET, battler); @@ -252,7 +252,7 @@ static void RecordedPartnerHandleChooseMove(u32 battler) BtlController_Complete(battler); } -static void RecordedPartnerHandleChoosePokemon(u32 battler) +static void RecordedPartnerHandleChoosePokemon(enum BattlerId battler) { gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing @@ -260,7 +260,7 @@ static void RecordedPartnerHandleChoosePokemon(u32 battler) BtlController_Complete(battler); } -static void RecordedPartnerHandleIntroTrainerBallThrow(u32 battler) +static void RecordedPartnerHandleIntroTrainerBallThrow(enum BattlerId battler) { const u16 *trainerPal; enum DifficultyLevel difficulty = GetBattlePartnerDifficultyLevel(gPartnerTrainerId); @@ -275,12 +275,12 @@ static void RecordedPartnerHandleIntroTrainerBallThrow(u32 battler) BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Controller_RecordedPartnerShowIntroHealthbox); } -static void RecordedPartnerHandleDrawPartyStatusSummary(u32 battler) +static void RecordedPartnerHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void RecordedPartnerHandleEndLinkBattle(u32 battler) +static void RecordedPartnerHandleEndLinkBattle(enum BattlerId battler) { gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); diff --git a/src/battle_controller_recorded_player.c b/src/battle_controller_recorded_player.c index 0860ffb7d4..fb1b7d2817 100644 --- a/src/battle_controller_recorded_player.c +++ b/src/battle_controller_recorded_player.c @@ -31,19 +31,19 @@ #include "test/battle.h" #include "test/test_runner_battle.h" -static void RecordedPlayerHandleDrawTrainerPic(u32 battler); -static void RecordedPlayerHandleTrainerSlideBack(u32 battler); -static void RecordedPlayerHandleChooseAction(u32 battler); -static void RecordedPlayerHandleChooseMove(u32 battler); -static void RecordedPlayerHandleChooseItem(u32 battler); -static void RecordedPlayerHandleChoosePokemon(u32 battler); -static void RecordedPlayerHandleStatusAnimation(u32 battler); -static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler); -static void RecordedPlayerHandleDrawPartyStatusSummary(u32 battler); -static void RecordedPlayerHandleEndLinkBattle(u32 battler); -static void RecordedPlayerBufferRunCommand(u32 battler); +static void RecordedPlayerHandleDrawTrainerPic(enum BattlerId battler); +static void RecordedPlayerHandleTrainerSlideBack(enum BattlerId battler); +static void RecordedPlayerHandleChooseAction(enum BattlerId battler); +static void RecordedPlayerHandleChooseMove(enum BattlerId battler); +static void RecordedPlayerHandleChooseItem(enum BattlerId battler); +static void RecordedPlayerHandleChoosePokemon(enum BattlerId battler); +static void RecordedPlayerHandleStatusAnimation(enum BattlerId battler); +static void RecordedPlayerHandleIntroTrainerBallThrow(enum BattlerId battler); +static void RecordedPlayerHandleDrawPartyStatusSummary(enum BattlerId battler); +static void RecordedPlayerHandleEndLinkBattle(enum BattlerId battler); +static void RecordedPlayerBufferRunCommand(enum BattlerId battler); -static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -100,14 +100,14 @@ static void (*const sRecordedPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 ba [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToRecordedPlayer(u32 battler) +void SetControllerToRecordedPlayer(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_RECORDED_PLAYER; gBattlerControllerEndFuncs[battler] = RecordedPlayerBufferExecCompleted; gBattlerControllerFuncs[battler] = RecordedPlayerBufferRunCommand; } -static void RecordedPlayerBufferRunCommand(u32 battler) +static void RecordedPlayerBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -118,7 +118,7 @@ static void RecordedPlayerBufferRunCommand(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool32 healthboxAnimDone = FALSE; @@ -184,7 +184,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { bool32 bgmRestored = FALSE; @@ -253,7 +253,7 @@ static void Intro_TryShinyAnimShowHealthbox(u32 battler) } } -void RecordedPlayerBufferExecCompleted(u32 battler) +void RecordedPlayerBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = RecordedPlayerBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -269,7 +269,7 @@ void RecordedPlayerBufferExecCompleted(u32 battler) } } -static void RecordedPlayerHandleDrawTrainerPic(u32 battler) +static void RecordedPlayerHandleDrawTrainerPic(enum BattlerId battler) { bool32 isFrontPic; s16 xPos, yPos; @@ -330,12 +330,12 @@ static void RecordedPlayerHandleDrawTrainerPic(u32 battler) BtlController_HandleDrawTrainerPic(battler, trainerPicId, isFrontPic, xPos, yPos, -1); } -static void RecordedPlayerHandleTrainerSlideBack(u32 battler) +static void RecordedPlayerHandleTrainerSlideBack(enum BattlerId battler) { BtlController_HandleTrainerSlideBack(battler, 35, FALSE); } -static void ChooseActionInBattlePalace(u32 battler) +static void ChooseActionInBattlePalace(enum BattlerId battler) { if (gBattleCommunication[4] >= gBattlersCount / 2) { @@ -344,7 +344,7 @@ static void ChooseActionInBattlePalace(u32 battler) } } -static void RecordedPlayerHandleChooseAction(u32 battler) +static void RecordedPlayerHandleChooseAction(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -357,7 +357,7 @@ static void RecordedPlayerHandleChooseAction(u32 battler) } } -static void RecordedPlayerHandleChooseMove(u32 battler) +static void RecordedPlayerHandleChooseMove(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_PALACE) { @@ -373,7 +373,7 @@ static void RecordedPlayerHandleChooseMove(u32 battler) BtlController_Complete(battler); } -static void RecordedPlayerHandleChooseItem(u32 battler) +static void RecordedPlayerHandleChooseItem(enum BattlerId battler) { u8 byte1 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); u8 byte2 = RecordedBattle_GetBattlerAction(RECORDED_ITEM_ID, battler); @@ -384,7 +384,7 @@ static void RecordedPlayerHandleChooseItem(u32 battler) BtlController_Complete(battler); } -static void RecordedPlayerHandleChoosePokemon(u32 battler) +static void RecordedPlayerHandleChoosePokemon(enum BattlerId battler) { gBattleStruct->monToSwitchIntoId[battler] = RecordedBattle_GetBattlerAction(RECORDED_PARTY_INDEX, battler); gSelectedMonPartyId = gBattleStruct->monToSwitchIntoId[battler]; // Revival Blessing @@ -392,12 +392,12 @@ static void RecordedPlayerHandleChoosePokemon(u32 battler) BtlController_Complete(battler); } -static void RecordedPlayerHandleStatusAnimation(u32 battler) +static void RecordedPlayerHandleStatusAnimation(enum BattlerId battler) { BtlController_HandleStatusAnimation(battler); } -static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler) +static void RecordedPlayerHandleIntroTrainerBallThrow(enum BattlerId battler) { enum TrainerPicID trainerPicId; const u16 *trainerPal; @@ -411,12 +411,12 @@ static void RecordedPlayerHandleIntroTrainerBallThrow(u32 battler) BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F9, trainerPal, 24, Intro_TryShinyAnimShowHealthbox); } -static void RecordedPlayerHandleDrawPartyStatusSummary(u32 battler) +static void RecordedPlayerHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, TRUE); } -static void RecordedPlayerHandleEndLinkBattle(u32 battler) +static void RecordedPlayerHandleEndLinkBattle(enum BattlerId battler) { gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 05697d366f..1d5d95fa9f 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -28,19 +28,19 @@ #include "constants/trainers.h" #include "constants/rgb.h" -static void SafariHandleDrawTrainerPic(u32 battler); -static void SafariHandleChooseAction(u32 battler); -static void SafariHandleChooseItem(u32 battler); -static void SafariHandleChoosePokemon(u32 battler); -static void SafariHandleFaintingCry(u32 battler); -static void SafariHandleIntroTrainerBallThrow(u32 battler); -static void SafariHandleEndLinkBattle(u32 battler); +static void SafariHandleDrawTrainerPic(enum BattlerId battler); +static void SafariHandleChooseAction(enum BattlerId battler); +static void SafariHandleChooseItem(enum BattlerId battler); +static void SafariHandleChoosePokemon(enum BattlerId battler); +static void SafariHandleFaintingCry(enum BattlerId battler); +static void SafariHandleIntroTrainerBallThrow(enum BattlerId battler); +static void SafariHandleEndLinkBattle(enum BattlerId battler); -static void SafariBufferRunCommand(u32 battler); -static void CompleteWhenChosePokeblock(u32 battler); -static void WaitForMonSelection(u32 battler); +static void SafariBufferRunCommand(enum BattlerId battler); +static void CompleteWhenChosePokeblock(enum BattlerId battler); +static void WaitForMonSelection(enum BattlerId battler); -static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_Empty, [CONTROLLER_GETRAWMONDATA] = BtlController_Empty, @@ -97,14 +97,14 @@ static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToSafari(u32 battler) +void SetControllerToSafari(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_SAFARI; gBattlerControllerEndFuncs[battler] = SafariBufferExecCompleted; gBattlerControllerFuncs[battler] = SafariBufferRunCommand; } -static void SafariBufferRunCommand(u32 battler) +static void SafariBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -115,7 +115,7 @@ static void SafariBufferRunCommand(u32 battler) } } -static void HandleInputChooseAction(u32 battler) +static void HandleInputChooseAction(enum BattlerId battler) { if (JOY_NEW(A_BUTTON)) { @@ -187,13 +187,13 @@ static void HandleInputChooseAction(u32 battler) } } -static void Controller_WaitForHealthbox(u32 battler) +static void Controller_WaitForHealthbox(enum BattlerId battler) { if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) BtlController_Complete(battler); } -static void SafariSetBattleEndCallbacks(u32 battler) +static void SafariSetBattleEndCallbacks(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -203,7 +203,7 @@ static void SafariSetBattleEndCallbacks(u32 battler) } } -static void SafariOpenPokeblockCase(u32 battler) +static void SafariOpenPokeblockCase(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -213,7 +213,7 @@ static void SafariOpenPokeblockCase(u32 battler) } } -static void CompleteWhenChosePokeblock(u32 battler) +static void CompleteWhenChosePokeblock(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -222,7 +222,7 @@ static void CompleteWhenChosePokeblock(u32 battler) } } -static void OpenPartyMenuToChooseMon(u32 battler) +static void OpenPartyMenuToChooseMon(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -234,7 +234,7 @@ static void OpenPartyMenuToChooseMon(u32 battler) } } -static void WaitForMonSelection(u32 battler) +static void WaitForMonSelection(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -257,7 +257,7 @@ static void WaitForMonSelection(u32 battler) } } -void SafariBufferExecCompleted(u32 battler) +void SafariBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = SafariBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -273,7 +273,7 @@ void SafariBufferExecCompleted(u32 battler) } } -static void SafariHandleDrawTrainerPic(u32 battler) +static void SafariHandleDrawTrainerPic(enum BattlerId battler) { enum TrainerPicID trainerPicId = gSaveBlock2Ptr->playerGender + TRAINER_PIC_BACK_BRENDAN; @@ -282,7 +282,7 @@ static void SafariHandleDrawTrainerPic(u32 battler) 30); } -static void HandleChooseActionAfterDma3(u32 battler) +static void HandleChooseActionAfterDma3(enum BattlerId battler) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -292,7 +292,7 @@ static void HandleChooseActionAfterDma3(u32 battler) } } -static void SafariHandleChooseAction(u32 battler) +static void SafariHandleChooseAction(enum BattlerId battler) { s32 i; @@ -307,14 +307,14 @@ static void SafariHandleChooseAction(u32 battler) BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT); } -static void SafariHandleChooseItem(u32 battler) +static void SafariHandleChooseItem(enum BattlerId battler) { BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); gBattlerControllerFuncs[battler] = SafariOpenPokeblockCase; gBattlerInMenuId = battler; } -static void SafariHandleChoosePokemon(u32 battler) +static void SafariHandleChoosePokemon(enum BattlerId battler) { for (s32 i = 0; i < ARRAY_COUNT(gBattlePartyCurrentOrder); i++) gBattlePartyCurrentOrder[i] = gBattleResources->bufferA[battler][4 + i]; @@ -341,7 +341,7 @@ static void SafariHandleChoosePokemon(u32 battler) // All of the other controllers(except Wally's) use CRY_MODE_FAINT. // Player is not a pokemon, so it can't really faint in the Safari anyway. -static void SafariHandleFaintingCry(u32 battler) +static void SafariHandleFaintingCry(enum BattlerId battler) { u16 species = GetMonData(GetBattlerMon(battler), MON_DATA_SPECIES); @@ -350,7 +350,7 @@ static void SafariHandleFaintingCry(u32 battler) BtlController_Complete(battler); } -static void SafariHandleIntroTrainerBallThrow(u32 battler) +static void SafariHandleIntroTrainerBallThrow(enum BattlerId battler) { UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], GetBattlerMon(battler), HEALTHBOX_SAFARI_ALL_TEXT); StartHealthboxSlideIn(battler); @@ -358,7 +358,7 @@ static void SafariHandleIntroTrainerBallThrow(u32 battler) gBattlerControllerFuncs[battler] = Controller_WaitForHealthbox; } -static void SafariHandleEndLinkBattle(u32 battler) +static void SafariHandleEndLinkBattle(enum BattlerId battler) { gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 14c93b56a4..36f51935f8 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -32,21 +32,21 @@ #include "constants/trainers.h" #include "constants/rgb.h" -static void WallyHandleDrawTrainerPic(u32 battler); -static void WallyHandleTrainerSlide(u32 battler); -static void WallyHandleChooseAction(u32 battler); -static void WallyHandleChooseMove(u32 battler); -static void WallyHandleChooseItem(u32 battler); -static void WallyHandleFaintingCry(u32 battler); -static void WallyHandleIntroTrainerBallThrow(u32 battler); -static void WallyHandleDrawPartyStatusSummary(u32 battler); -static void WallyHandleEndLinkBattle(u32 battler); +static void WallyHandleDrawTrainerPic(enum BattlerId battler); +static void WallyHandleTrainerSlide(enum BattlerId battler); +static void WallyHandleChooseAction(enum BattlerId battler); +static void WallyHandleChooseMove(enum BattlerId battler); +static void WallyHandleChooseItem(enum BattlerId battler); +static void WallyHandleFaintingCry(enum BattlerId battler); +static void WallyHandleIntroTrainerBallThrow(enum BattlerId battler); +static void WallyHandleDrawPartyStatusSummary(enum BattlerId battler); +static void WallyHandleEndLinkBattle(enum BattlerId battler); -static void WallyBufferRunCommand(u32 battler); -static void CompleteOnChosenItem(u32 battler); -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler); +static void WallyBufferRunCommand(enum BattlerId battler); +static void CompleteOnChosenItem(enum BattlerId battler); +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler); -static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = +static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(enum BattlerId battler) = { [CONTROLLER_GETMONDATA] = BtlController_HandleGetMonData, [CONTROLLER_GETRAWMONDATA] = BtlController_HandleGetRawMonData, @@ -103,7 +103,7 @@ static void (*const sWallyBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) = [CONTROLLER_TERMINATOR_NOP] = BtlController_TerminatorNop }; -void SetControllerToWally(u32 battler) +void SetControllerToWally(enum BattlerId battler) { gBattlerBattleController[battler] = BATTLE_CONTROLLER_WALLY; gBattlerControllerEndFuncs[battler] = WallyBufferExecCompleted; @@ -114,7 +114,7 @@ void SetControllerToWally(u32 battler) gBattleStruct->wallyMoveFrames = 0; } -static void WallyBufferRunCommand(u32 battler) +static void WallyBufferRunCommand(enum BattlerId battler) { if (IsBattleControllerActiveOnLocal(battler)) { @@ -125,7 +125,7 @@ static void WallyBufferRunCommand(u32 battler) } } -static void WallyHandleActions(u32 battler) +static void WallyHandleActions(enum BattlerId battler) { switch (gBattleStruct->wallyBattleState) { @@ -185,7 +185,7 @@ static void WallyHandleActions(u32 battler) } } -static void OpenBagAfterPaletteFade(u32 battler) +static void OpenBagAfterPaletteFade(enum BattlerId battler) { if (!gPaletteFade.active) { @@ -196,7 +196,7 @@ static void OpenBagAfterPaletteFade(u32 battler) } } -static void CompleteOnChosenItem(u32 battler) +static void CompleteOnChosenItem(enum BattlerId battler) { if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active) { @@ -205,7 +205,7 @@ static void CompleteOnChosenItem(u32 battler) } } -static void Intro_TryShinyAnimShowHealthbox(u32 battler) +static void Intro_TryShinyAnimShowHealthbox(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive) @@ -237,7 +237,7 @@ static void Intro_TryShinyAnimShowHealthbox(u32 battler) } } -static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) +static void Intro_WaitForShinyAnimAndHealthbox(enum BattlerId battler) { bool32 healthboxAnimDone = FALSE; @@ -262,7 +262,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(u32 battler) } } -void WallyBufferExecCompleted(u32 battler) +void WallyBufferExecCompleted(enum BattlerId battler) { gBattlerControllerFuncs[battler] = WallyBufferRunCommand; if (gBattleTypeFlags & BATTLE_TYPE_LINK) @@ -280,21 +280,21 @@ void WallyBufferExecCompleted(u32 battler) #define sSpeedX data[0] -static void WallyHandleDrawTrainerPic(u32 battler) +static void WallyHandleDrawTrainerPic(enum BattlerId battler) { BtlController_HandleDrawTrainerPic(battler, TRAINER_PIC_BACK_WALLY, FALSE, 80, 80 + 4 * (8 - gTrainerBacksprites[TRAINER_PIC_BACK_WALLY].coordinates.size), 30); } -static void WallyHandleTrainerSlide(u32 battler) +static void WallyHandleTrainerSlide(enum BattlerId battler) { BtlController_HandleTrainerSlide(battler, TRAINER_PIC_BACK_WALLY); } #undef sSpeedX -static void HandleChooseActionAfterDma3(u32 battler) +static void HandleChooseActionAfterDma3(enum BattlerId battler) { if (!IsDma3ManagerBusyWithBgCopy()) { @@ -304,7 +304,7 @@ static void HandleChooseActionAfterDma3(u32 battler) } } -static void WallyHandleChooseAction(u32 battler) +static void WallyHandleChooseAction(enum BattlerId battler) { s32 i; @@ -319,7 +319,7 @@ static void WallyHandleChooseAction(u32 battler) BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT); } -static void WallyHandleChooseMove(u32 battler) +static void WallyHandleChooseMove(enum BattlerId battler) { switch (gBattleStruct->wallyMovesState) { @@ -347,7 +347,7 @@ static void WallyHandleChooseMove(u32 battler) } } -static void WallyHandleChooseItem(u32 battler) +static void WallyHandleChooseItem(enum BattlerId battler) { BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); gBattlerControllerFuncs[battler] = OpenBagAfterPaletteFade; @@ -356,7 +356,7 @@ static void WallyHandleChooseItem(u32 battler) // All of the other controllers use CRY_MODE_FAINT. // Wally's Pokémon during the tutorial is never intended to faint, so that's probably why it's different here. -static void WallyHandleFaintingCry(u32 battler) +static void WallyHandleFaintingCry(enum BattlerId battler) { u16 species = GetMonData(GetBattlerMon(battler), MON_DATA_SPECIES); @@ -364,18 +364,18 @@ static void WallyHandleFaintingCry(u32 battler) BtlController_Complete(battler); } -static void WallyHandleIntroTrainerBallThrow(u32 battler) +static void WallyHandleIntroTrainerBallThrow(enum BattlerId battler) { const u16 *trainerPal = gTrainerBacksprites[TRAINER_PIC_BACK_WALLY].palette.data; BtlController_HandleIntroTrainerBallThrow(battler, 0xD6F8, trainerPal, 31, Intro_TryShinyAnimShowHealthbox); } -static void WallyHandleDrawPartyStatusSummary(u32 battler) +static void WallyHandleDrawPartyStatusSummary(enum BattlerId battler) { BtlController_HandleDrawPartyStatusSummary(battler, B_SIDE_PLAYER, FALSE); } -static void WallyHandleEndLinkBattle(u32 battler) +static void WallyHandleEndLinkBattle(enum BattlerId battler) { gBattleOutcome = gBattleResources->bufferA[battler][1]; FadeOutMapMusic(5); diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 6b4a0d7669..f64c98016f 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -39,9 +39,9 @@ static EWRAM_DATA u8 sLinkSendTaskId = 0; static EWRAM_DATA u8 sLinkReceiveTaskId = 0; -COMMON_DATA void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler) = {0}; +COMMON_DATA void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(enum BattlerId battler) = {0}; COMMON_DATA u8 gBattleControllerData[MAX_BATTLERS_COUNT] = {0}; // Used by the battle controllers to store misc sprite/task IDs for each battler -COMMON_DATA void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(u32 battler) = {0}; // Controller's buffer complete function for each battler +COMMON_DATA void (*gBattlerControllerEndFuncs[MAX_BATTLERS_COUNT])(enum BattlerId battler) = {0}; // Controller's buffer complete function for each battler u8 gBattlerBattleController[MAX_BATTLERS_COUNT] = {0}; // Battle controller for each battler static void CreateTasksForSendRecvLinkBuffers(void); @@ -53,8 +53,8 @@ static void Task_StartSendOutAnim(u8 taskId); static void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite); static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite); static u32 ReturnAnimIdForBattler(bool32 isPlayerSide, u32 specificBattler); -static void LaunchKOAnimation(u32 battlerId, u16 animId, bool32 isFront); -static void AnimateMonAfterKnockout(u32 battler); +static void LaunchKOAnimation(enum BattlerId battlerId, u16 animId, bool32 isFront); +static void AnimateMonAfterKnockout(enum BattlerId battler); bool32 IsAiVsAiBattle(void) @@ -62,45 +62,45 @@ bool32 IsAiVsAiBattle(void) return (B_FLAG_AI_VS_AI_BATTLE && FlagGet(B_FLAG_AI_VS_AI_BATTLE)); } -bool32 BattlerIsPlayer(u32 battlerId) +bool32 BattlerIsPlayer(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_PLAYER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_PLAYER); } -bool32 BattlerIsPartner(u32 battlerId) +bool32 BattlerIsPartner(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_PLAYER_PARTNER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_PARTNER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_LINK_PARTNER); } -bool32 BattlerIsOpponent(u32 battlerId) +bool32 BattlerIsOpponent(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_OPPONENT || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_OPPONENT || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_LINK_OPPONENT); } -bool32 BattlerIsRecorded(u32 battlerId) +bool32 BattlerIsRecorded(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_PLAYER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_PARTNER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_RECORDED_OPPONENT); } -bool32 BattlerIsLink(u32 battlerId) +bool32 BattlerIsLink(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_LINK_PARTNER || gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_LINK_OPPONENT); } -bool32 BattlerIsWally(u32 battlerId) +bool32 BattlerIsWally(enum BattlerId battlerId) { return (gBattlerBattleController[battlerId] == BATTLE_CONTROLLER_WALLY); } -bool32 BattlerHasAi(u32 battlerId) +bool32 BattlerHasAi(enum BattlerId battlerId) { switch (gBattlerBattleController[battlerId]) { @@ -174,8 +174,8 @@ void InitBattleControllers(void) if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - for (i = 0; i < gBattlersCount; i++) - BufferBattlePartyCurrentOrderBySide(i, 0); + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) + BufferBattlePartyCurrentOrderBySide(battler, 0); } for (i = 0; i < sizeof(gBattleStruct->tvMovePoints); i++) @@ -399,57 +399,57 @@ bool32 IsValidForBattleButDead(struct Pokemon *mon) && GetMonData(mon, MON_DATA_IS_EGG) == FALSE); } -static inline bool32 IsControllerPlayer(u32 battler) +static inline bool32 IsControllerPlayer(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == PlayerBufferExecCompleted); } -static inline bool32 IsControllerRecordedPlayer(u32 battler) +static inline bool32 IsControllerRecordedPlayer(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == RecordedPlayerBufferExecCompleted); } -static inline bool32 IsControllerRecordedPartner(u32 battler) +static inline bool32 IsControllerRecordedPartner(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == RecordedPartnerBufferExecCompleted); } -static inline bool32 IsControllerOpponent(u32 battler) +static inline bool32 IsControllerOpponent(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == OpponentBufferExecCompleted); } -static inline bool32 IsControllerPlayerPartner(u32 battler) +static inline bool32 IsControllerPlayerPartner(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == PlayerPartnerBufferExecCompleted); } -static inline bool32 IsControllerWally(u32 battler) +static inline bool32 IsControllerWally(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == WallyBufferExecCompleted); } -static inline bool32 IsControllerRecordedOpponent(u32 battler) +static inline bool32 IsControllerRecordedOpponent(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == RecordedOpponentBufferExecCompleted); } -static inline bool32 IsControllerLinkOpponent(u32 battler) +static inline bool32 IsControllerLinkOpponent(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == LinkOpponentBufferExecCompleted); } -static inline bool32 IsControllerLinkPartner(u32 battler) +static inline bool32 IsControllerLinkPartner(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == LinkPartnerBufferExecCompleted); } -static inline bool32 IsControllerSafari(u32 battler) +static inline bool32 IsControllerSafari(enum BattlerId battler) { return (gBattlerControllerEndFuncs[battler] == SafariBufferExecCompleted); } -bool32 ShouldUpdateTvData(u32 battler) +bool32 ShouldUpdateTvData(enum BattlerId battler) { return (IsControllerPlayer(battler) || IsControllerLinkPartner(battler) @@ -458,13 +458,11 @@ bool32 ShouldUpdateTvData(u32 battler) static void SetBattlePartyIds(void) { - s32 i, j; - if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI)) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { - for (j = 0; j < PARTY_SIZE; j++) + for (u32 j = 0; j < PARTY_SIZE; j++) { if (i < 2) { @@ -509,7 +507,7 @@ static void SetBattlePartyIds(void) } } -static void PrepareBufferDataTransfer(u32 battler, u32 bufferId, u8 *data, u16 size) +static void PrepareBufferDataTransfer(enum BattlerId battler, u32 bufferId, u8 *data, u16 size) { s32 i; @@ -585,7 +583,7 @@ enum // We want to send a message. Place it into the "send" buffer. // First argument is a BATTLELINKCOMMTYPE_ -void PrepareBufferDataTransferLink(u32 battler, u32 bufferId, u16 size, u8 *data) +void PrepareBufferDataTransferLink(enum BattlerId battler, u32 bufferId, u16 size, u8 *data) { s32 alignedSize; s32 i; @@ -763,7 +761,7 @@ void TryReceiveLinkBattleData(void) static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId) { u16 blockSize; - u8 battler; + enum BattlerId battler; u8 playerId; #define BYTE_TO_RECEIVE(offset) \ @@ -819,7 +817,7 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId) #undef tCurrentBlock_End #undef tCurrentBlock_Start -void BtlController_EmitGetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck) +void BtlController_EmitGetMonData(enum BattlerId battler, u32 bufferId, u8 requestId, u8 monToCheck) { gBattleResources->transferBuffer[0] = CONTROLLER_GETMONDATA; gBattleResources->transferBuffer[1] = requestId; @@ -828,7 +826,7 @@ void BtlController_EmitGetMonData(u32 battler, u32 bufferId, u8 requestId, u8 mo PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -static void UNUSED BtlController_EmitGetRawMonData(u32 battler, u32 bufferId, u8 monId, u8 bytes) +static void UNUSED BtlController_EmitGetRawMonData(enum BattlerId battler, u32 bufferId, u8 monId, u8 bytes) { gBattleResources->transferBuffer[0] = CONTROLLER_GETRAWMONDATA; gBattleResources->transferBuffer[1] = monId; @@ -837,7 +835,7 @@ static void UNUSED BtlController_EmitGetRawMonData(u32 battler, u32 bufferId, u8 PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSetMonData(u32 battler, u32 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data) +void BtlController_EmitSetMonData(enum BattlerId battler, u32 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data) { s32 i; @@ -849,7 +847,7 @@ void BtlController_EmitSetMonData(u32 battler, u32 bufferId, u8 requestId, u8 mo PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 3 + bytes); } -static void UNUSED BtlController_EmitSetRawMonData(u32 battler, u32 bufferId, u8 monId, u8 bytes, void *data) +static void UNUSED BtlController_EmitSetRawMonData(enum BattlerId battler, u32 bufferId, u8 monId, u8 bytes, void *data) { s32 i; @@ -861,7 +859,7 @@ static void UNUSED BtlController_EmitSetRawMonData(u32 battler, u32 bufferId, u8 PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, bytes + 3); } -void BtlController_EmitLoadMonSprite(u32 battler, u32 bufferId) +void BtlController_EmitLoadMonSprite(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_LOADMONSPRITE; gBattleResources->transferBuffer[1] = CONTROLLER_LOADMONSPRITE; @@ -870,7 +868,7 @@ void BtlController_EmitLoadMonSprite(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSwitchInAnim(u32 battler, u32 bufferId, u8 partyId, bool8 dontClearTransform, bool8 dontClearSubstituteBit) +void BtlController_EmitSwitchInAnim(enum BattlerId battler, u32 bufferId, u8 partyId, bool8 dontClearTransform, bool8 dontClearSubstituteBit) { gBattleResources->transferBuffer[0] = CONTROLLER_SWITCHINANIM; gBattleResources->transferBuffer[1] = partyId; @@ -879,14 +877,14 @@ void BtlController_EmitSwitchInAnim(u32 battler, u32 bufferId, u8 partyId, bool8 PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitReturnMonToBall(u32 battler, u32 bufferId, bool8 skipAnim) +void BtlController_EmitReturnMonToBall(enum BattlerId battler, u32 bufferId, bool8 skipAnim) { gBattleResources->transferBuffer[0] = CONTROLLER_RETURNMONTOBALL; gBattleResources->transferBuffer[1] = skipAnim; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitDrawTrainerPic(u32 battler, u32 bufferId) +void BtlController_EmitDrawTrainerPic(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_DRAWTRAINERPIC; gBattleResources->transferBuffer[1] = CONTROLLER_DRAWTRAINERPIC; @@ -895,7 +893,7 @@ void BtlController_EmitDrawTrainerPic(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitTrainerSlide(u32 battler, u32 bufferId) +void BtlController_EmitTrainerSlide(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_TRAINERSLIDE; gBattleResources->transferBuffer[1] = CONTROLLER_TRAINERSLIDE; @@ -904,7 +902,7 @@ void BtlController_EmitTrainerSlide(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitTrainerSlideBack(u32 battler, u32 bufferId) +void BtlController_EmitTrainerSlideBack(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_TRAINERSLIDEBACK; gBattleResources->transferBuffer[1] = CONTROLLER_TRAINERSLIDEBACK; @@ -913,7 +911,7 @@ void BtlController_EmitTrainerSlideBack(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitFaintAnimation(u32 battler, u32 bufferId) +void BtlController_EmitFaintAnimation(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_FAINTANIMATION; gBattleResources->transferBuffer[1] = CONTROLLER_FAINTANIMATION; @@ -922,7 +920,7 @@ void BtlController_EmitFaintAnimation(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -static void UNUSED BtlController_EmitPaletteFade(u32 battler, u32 bufferId) +static void UNUSED BtlController_EmitPaletteFade(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_PALETTEFADE; gBattleResources->transferBuffer[1] = CONTROLLER_PALETTEFADE; @@ -931,14 +929,14 @@ static void UNUSED BtlController_EmitPaletteFade(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitBallThrowAnim(u32 battler, u32 bufferId, u8 caseId) +void BtlController_EmitBallThrowAnim(enum BattlerId battler, u32 bufferId, u8 caseId) { gBattleResources->transferBuffer[0] = CONTROLLER_BALLTHROWANIM; gBattleResources->transferBuffer[1] = caseId; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -static void UNUSED BtlController_EmitPause(u32 battler, u32 bufferId, u8 toWait, void *data) +static void UNUSED BtlController_EmitPause(enum BattlerId battler, u32 bufferId, u8 toWait, void *data) { s32 i; @@ -949,7 +947,7 @@ static void UNUSED BtlController_EmitPause(u32 battler, u32 bufferId, u8 toWait, PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, toWait * 3 + 2); } -void BtlController_EmitMoveAnimation(u32 battler, u32 bufferId, enum Move move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, u8 multihit) +void BtlController_EmitMoveAnimation(enum BattlerId battler, u32 bufferId, enum Move move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, u8 multihit) { gBattleResources->transferBuffer[0] = CONTROLLER_MOVEANIMATION; gBattleResources->transferBuffer[1] = move; @@ -988,7 +986,7 @@ void BtlController_EmitMoveAnimation(u32 battler, u32 bufferId, enum Move move, PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 16 + sizeof(struct LinkBattleAnim)); } -void BtlController_EmitPrintString(u32 battler, u32 bufferId, enum StringID stringID) +void BtlController_EmitPrintString(enum BattlerId battler, u32 bufferId, enum StringID stringID) { s32 i; struct BattleMsgData *stringInfo; @@ -1020,7 +1018,7 @@ void BtlController_EmitPrintString(u32 battler, u32 bufferId, enum StringID stri PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(struct BattleMsgData) + 4); } -void BtlController_EmitPrintSelectionString(u32 battler, u32 bufferId, enum StringID stringID) +void BtlController_EmitPrintSelectionString(enum BattlerId battler, u32 bufferId, enum StringID stringID) { s32 i; struct BattleMsgData *stringInfo; @@ -1050,7 +1048,7 @@ void BtlController_EmitPrintSelectionString(u32 battler, u32 bufferId, enum Stri } // itemId only relevant for B_ACTION_USE_ITEM -void BtlController_EmitChooseAction(u32 battler, u32 bufferId, u8 action, enum Item itemId) +void BtlController_EmitChooseAction(enum BattlerId battler, u32 bufferId, u8 action, enum Item itemId) { gBattleResources->transferBuffer[0] = CONTROLLER_CHOOSEACTION; gBattleResources->transferBuffer[1] = action; @@ -1061,7 +1059,7 @@ void BtlController_EmitChooseAction(u32 battler, u32 bufferId, u8 action, enum I // Only used by the forfeit prompt in the Battle Frontier // For other Yes/No boxes in battle, see Cmd_yesnobox -void BtlController_EmitYesNoBox(u32 battler, u32 bufferId) +void BtlController_EmitYesNoBox(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_YESNOBOX; gBattleResources->transferBuffer[1] = CONTROLLER_YESNOBOX; @@ -1070,7 +1068,7 @@ void BtlController_EmitYesNoBox(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitChooseMove(u32 battler, u32 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData) +void BtlController_EmitChooseMove(enum BattlerId battler, u32 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData) { s32 i; @@ -1083,7 +1081,7 @@ void BtlController_EmitChooseMove(u32 battler, u32 bufferId, bool8 isDoubleBattl PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(*movePpData) + 4); } -void BtlController_EmitChooseItem(u32 battler, u32 bufferId, u8 *battlePartyOrder) +void BtlController_EmitChooseItem(enum BattlerId battler, u32 bufferId, u8 *battlePartyOrder) { s32 i; @@ -1093,7 +1091,7 @@ void BtlController_EmitChooseItem(u32 battler, u32 bufferId, u8 *battlePartyOrde PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitChoosePokemon(u32 battler, u32 bufferId, u8 caseId, u8 slotId, u16 abilityId, u8 battlerPreventingSwitchout, u8 *data) +void BtlController_EmitChoosePokemon(enum BattlerId battler, u32 bufferId, u8 caseId, u8 slotId, u16 abilityId, enum BattlerId battlerPreventingSwitchout, u8 *data) { s32 i; @@ -1108,7 +1106,7 @@ void BtlController_EmitChoosePokemon(u32 battler, u32 bufferId, u8 caseId, u8 sl PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 9); // Only 7 bytes were written. } -static void UNUSED BtlController_EmitCmd23(u32 battler, u32 bufferId) +static void UNUSED BtlController_EmitCmd23(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_23; gBattleResources->transferBuffer[1] = CONTROLLER_23; @@ -1118,7 +1116,7 @@ static void UNUSED BtlController_EmitCmd23(u32 battler, u32 bufferId) } // why is the argument u16 if it's being cast to s16 anyway? -void BtlController_EmitHealthBarUpdate(u32 battler, u32 bufferId, u16 hpValue) +void BtlController_EmitHealthBarUpdate(enum BattlerId battler, u32 bufferId, u16 hpValue) { gBattleResources->transferBuffer[0] = CONTROLLER_HEALTHBARUPDATE; gBattleResources->transferBuffer[1] = 0; @@ -1127,7 +1125,7 @@ void BtlController_EmitHealthBarUpdate(u32 battler, u32 bufferId, u16 hpValue) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitExpUpdate(u32 battler, u32 bufferId, u8 partyId, s32 expPoints) +void BtlController_EmitExpUpdate(enum BattlerId battler, u32 bufferId, u8 partyId, s32 expPoints) { gBattleResources->transferBuffer[0] = CONTROLLER_EXPUPDATE; gBattleResources->transferBuffer[1] = partyId; @@ -1138,7 +1136,7 @@ void BtlController_EmitExpUpdate(u32 battler, u32 bufferId, u8 partyId, s32 expP PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } -void BtlController_EmitStatusIconUpdate(u32 battler, u32 bufferId, u32 status) +void BtlController_EmitStatusIconUpdate(enum BattlerId battler, u32 bufferId, u32 status) { gBattleResources->transferBuffer[0] = CONTROLLER_STATUSICONUPDATE; gBattleResources->transferBuffer[1] = status; @@ -1148,7 +1146,7 @@ void BtlController_EmitStatusIconUpdate(u32 battler, u32 bufferId, u32 status) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 5); } -void BtlController_EmitStatusAnimation(u32 battler, u32 bufferId, bool8 isVolatile, u32 status) +void BtlController_EmitStatusAnimation(enum BattlerId battler, u32 bufferId, bool8 isVolatile, u32 status) { gBattleResources->transferBuffer[0] = CONTROLLER_STATUSANIMATION; gBattleResources->transferBuffer[1] = isVolatile; @@ -1159,14 +1157,14 @@ void BtlController_EmitStatusAnimation(u32 battler, u32 bufferId, bool8 isVolati PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } -static void UNUSED BtlController_EmitStatusXor(u32 battler, u32 bufferId, u8 b) +static void UNUSED BtlController_EmitStatusXor(enum BattlerId battler, u32 bufferId, u8 b) { gBattleResources->transferBuffer[0] = CONTROLLER_STATUSXOR; gBattleResources->transferBuffer[1] = b; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitDataTransfer(u32 battler, u32 bufferId, u16 size, void *data) +void BtlController_EmitDataTransfer(enum BattlerId battler, u32 bufferId, u16 size, void *data) { s32 i; @@ -1179,7 +1177,7 @@ void BtlController_EmitDataTransfer(u32 battler, u32 bufferId, u16 size, void *d PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 4); } -static void UNUSED BtlController_EmitDMA3Transfer(u32 battler, u32 bufferId, void *dst, u16 size, void *data) +static void UNUSED BtlController_EmitDMA3Transfer(enum BattlerId battler, u32 bufferId, void *dst, u16 size, void *data) { s32 i; @@ -1195,7 +1193,7 @@ static void UNUSED BtlController_EmitDMA3Transfer(u32 battler, u32 bufferId, voi PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 7); } -static void UNUSED BtlController_EmitPlayBGM(u32 battler, u32 bufferId, u16 songId, void *data) +static void UNUSED BtlController_EmitPlayBGM(enum BattlerId battler, u32 bufferId, u16 songId, void *data) { s32 i; @@ -1210,7 +1208,7 @@ static void UNUSED BtlController_EmitPlayBGM(u32 battler, u32 bufferId, u16 song PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, songId + 3); } -static void UNUSED BtlController_EmitCmd32(u32 battler, u32 bufferId, u16 size, void *data) +static void UNUSED BtlController_EmitCmd32(enum BattlerId battler, u32 bufferId, u16 size, void *data) { s32 i; @@ -1222,7 +1220,7 @@ static void UNUSED BtlController_EmitCmd32(u32 battler, u32 bufferId, u16 size, PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, size + 3); } -void BtlController_EmitTwoReturnValues(u32 battler, u32 bufferId, u8 ret8, u32 ret32) +void BtlController_EmitTwoReturnValues(enum BattlerId battler, u32 bufferId, u8 ret8, u32 ret32) { gBattleResources->transferBuffer[0] = CONTROLLER_TWORETURNVALUES; gBattleResources->transferBuffer[1] = ret8; @@ -1233,7 +1231,7 @@ void BtlController_EmitTwoReturnValues(u32 battler, u32 bufferId, u8 ret8, u32 r PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 6); } -void BtlController_EmitChosenMonReturnValue(u32 battler, u32 bufferId, u8 partyId, u8 *battlePartyOrder) +void BtlController_EmitChosenMonReturnValue(enum BattlerId battler, u32 bufferId, u8 partyId, u8 *battlePartyOrder) { s32 i; @@ -1247,7 +1245,7 @@ void BtlController_EmitChosenMonReturnValue(u32 battler, u32 bufferId, u8 partyI PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 5); } -void BtlController_EmitOneReturnValue(u32 battler, u32 bufferId, u16 ret) +void BtlController_EmitOneReturnValue(enum BattlerId battler, u32 bufferId, u16 ret) { gBattleResources->transferBuffer[0] = CONTROLLER_ONERETURNVALUE; gBattleResources->transferBuffer[1] = ret; @@ -1256,7 +1254,7 @@ void BtlController_EmitOneReturnValue(u32 battler, u32 bufferId, u16 ret) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitOneReturnValue_Duplicate(u32 battler, u32 bufferId, u16 ret) +void BtlController_EmitOneReturnValue_Duplicate(enum BattlerId battler, u32 bufferId, u16 ret) { gBattleResources->transferBuffer[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE; gBattleResources->transferBuffer[1] = ret; @@ -1265,7 +1263,7 @@ void BtlController_EmitOneReturnValue_Duplicate(u32 battler, u32 bufferId, u16 r PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitHitAnimation(u32 battler, u32 bufferId) +void BtlController_EmitHitAnimation(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_HITANIMATION; gBattleResources->transferBuffer[1] = CONTROLLER_HITANIMATION; @@ -1274,7 +1272,7 @@ void BtlController_EmitHitAnimation(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitCantSwitch(u32 battler, u32 bufferId) +void BtlController_EmitCantSwitch(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_CANTSWITCH; gBattleResources->transferBuffer[1] = CONTROLLER_CANTSWITCH; @@ -1283,7 +1281,7 @@ void BtlController_EmitCantSwitch(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitPlaySE(u32 battler, u32 bufferId, u16 songId) +void BtlController_EmitPlaySE(enum BattlerId battler, u32 bufferId, u16 songId) { gBattleResources->transferBuffer[0] = CONTROLLER_PLAYSE; gBattleResources->transferBuffer[1] = songId; @@ -1292,7 +1290,7 @@ void BtlController_EmitPlaySE(u32 battler, u32 bufferId, u16 songId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitPlayFanfareOrBGM(u32 battler, u32 bufferId, u16 songId, bool8 playBGM) +void BtlController_EmitPlayFanfareOrBGM(enum BattlerId battler, u32 bufferId, u16 songId, bool8 playBGM) { gBattleResources->transferBuffer[0] = CONTROLLER_PLAYFANFAREORBGM; gBattleResources->transferBuffer[1] = songId; @@ -1301,7 +1299,7 @@ void BtlController_EmitPlayFanfareOrBGM(u32 battler, u32 bufferId, u16 songId, b PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitFaintingCry(u32 battler, u32 bufferId) +void BtlController_EmitFaintingCry(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_FAINTINGCRY; gBattleResources->transferBuffer[1] = CONTROLLER_FAINTINGCRY; @@ -1310,14 +1308,14 @@ void BtlController_EmitFaintingCry(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitIntroSlide(u32 battler, u32 bufferId, u8 environmentId) +void BtlController_EmitIntroSlide(enum BattlerId battler, u32 bufferId, u8 environmentId) { gBattleResources->transferBuffer[0] = CONTROLLER_INTROSLIDE; gBattleResources->transferBuffer[1] = environmentId; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitIntroTrainerBallThrow(u32 battler, u32 bufferId) +void BtlController_EmitIntroTrainerBallThrow(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_INTROTRAINERBALLTHROW; gBattleResources->transferBuffer[1] = CONTROLLER_INTROTRAINERBALLTHROW; @@ -1326,7 +1324,7 @@ void BtlController_EmitIntroTrainerBallThrow(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitDrawPartyStatusSummary(u32 battler, u32 bufferId, struct HpAndStatus *hpAndStatus, u8 flags) +void BtlController_EmitDrawPartyStatusSummary(enum BattlerId battler, u32 bufferId, struct HpAndStatus *hpAndStatus, u8 flags) { s32 i; @@ -1339,7 +1337,7 @@ void BtlController_EmitDrawPartyStatusSummary(u32 battler, u32 bufferId, struct PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, sizeof(struct HpAndStatus) * PARTY_SIZE + 4); } -void BtlController_EmitHidePartyStatusSummary(u32 battler, u32 bufferId) +void BtlController_EmitHidePartyStatusSummary(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; gBattleResources->transferBuffer[1] = CONTROLLER_HIDEPARTYSTATUSSUMMARY; @@ -1348,7 +1346,7 @@ void BtlController_EmitHidePartyStatusSummary(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitEndBounceEffect(u32 battler, u32 bufferId) +void BtlController_EmitEndBounceEffect(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_ENDBOUNCE; gBattleResources->transferBuffer[1] = CONTROLLER_ENDBOUNCE; @@ -1357,7 +1355,7 @@ void BtlController_EmitEndBounceEffect(u32 battler, u32 bufferId) PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitSpriteInvisibility(u32 battler, u32 bufferId, bool8 isInvisible) +void BtlController_EmitSpriteInvisibility(enum BattlerId battler, u32 bufferId, bool8 isInvisible) { gBattleResources->transferBuffer[0] = CONTROLLER_SPRITEINVISIBILITY; gBattleResources->transferBuffer[1] = isInvisible; @@ -1366,7 +1364,7 @@ void BtlController_EmitSpriteInvisibility(u32 battler, u32 bufferId, bool8 isInv PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 4); } -void BtlController_EmitBattleAnimation(u32 battler, u32 bufferId, u8 animationId, u16 argument) +void BtlController_EmitBattleAnimation(enum BattlerId battler, u32 bufferId, u8 animationId, u16 argument) { gBattleResources->transferBuffer[0] = CONTROLLER_BATTLEANIMATION; gBattleResources->transferBuffer[1] = animationId; @@ -1386,7 +1384,7 @@ void BtlController_EmitBattleAnimation(u32 battler, u32 bufferId, u8 animationId } // mode is a LINK_STANDBY_* constant -void BtlController_EmitLinkStandbyMsg(u32 battler, u32 bufferId, u8 mode, bool32 record) +void BtlController_EmitLinkStandbyMsg(enum BattlerId battler, u32 bufferId, u8 mode, bool32 record) { gBattleResources->transferBuffer[0] = CONTROLLER_LINKSTANDBYMSG; gBattleResources->transferBuffer[1] = mode; @@ -1399,14 +1397,14 @@ void BtlController_EmitLinkStandbyMsg(u32 battler, u32 bufferId, u8 mode, bool32 PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, gBattleResources->transferBuffer[2] + 4); } -void BtlController_EmitResetActionMoveSelection(u32 battler, u32 bufferId, u8 caseId) +void BtlController_EmitResetActionMoveSelection(enum BattlerId battler, u32 bufferId, u8 caseId) { gBattleResources->transferBuffer[0] = CONTROLLER_RESETACTIONMOVESELECTION; gBattleResources->transferBuffer[1] = caseId; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 2); } -void BtlController_EmitEndLinkBattle(u32 battler, u32 bufferId, u8 battleOutcome) +void BtlController_EmitEndLinkBattle(enum BattlerId battler, u32 bufferId, u8 battleOutcome) { gBattleResources->transferBuffer[0] = CONTROLLER_ENDLINKBATTLE; gBattleResources->transferBuffer[1] = battleOutcome; @@ -1416,7 +1414,7 @@ void BtlController_EmitEndLinkBattle(u32 battler, u32 bufferId, u8 battleOutcome PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, gBattleResources->transferBuffer[4] + 6); } -void BtlController_EmitDebugMenu(u32 battler, u32 bufferId) +void BtlController_EmitDebugMenu(enum BattlerId battler, u32 bufferId) { gBattleResources->transferBuffer[0] = CONTROLLER_DEBUGMENU; PrepareBufferDataTransfer(battler, bufferId, gBattleResources->transferBuffer, 1); @@ -1425,12 +1423,12 @@ void BtlController_EmitDebugMenu(u32 battler, u32 bufferId) // Standardized Controller functions // Can be used for all the controllers. -void BtlController_Complete(u32 battler) +void BtlController_Complete(enum BattlerId battler) { gBattlerControllerEndFuncs[battler](battler); } -static u32 GetBattlerMonData(u32 battler, struct Pokemon *party, u32 monId, u8 *dst) +static u32 GetBattlerMonData(enum BattlerId battler, struct Pokemon *party, u32 monId, u8 *dst) { struct BattlePokemon battleMon; struct MovePpInfo moveData; @@ -1746,7 +1744,7 @@ static u32 GetBattlerMonData(u32 battler, struct Pokemon *party, u32 monId, u8 * return size; } -static void SetBattlerMonData(u32 battler, struct Pokemon *party, u32 monId) +static void SetBattlerMonData(enum BattlerId battler, struct Pokemon *party, u32 monId) { struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleResources->bufferA[battler][3]; struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleResources->bufferA[battler][3]; @@ -1966,7 +1964,7 @@ static void SetBattlerMonData(u32 battler, struct Pokemon *party, u32 monId) } // In normal singles, if follower Pokémon exists, and the Pokémon following is being sent out, have it slide in instead of being thrown -static bool8 ShouldDoSlideInAnim(u32 battler) +static bool8 ShouldDoSlideInAnim(enum BattlerId battler) { struct ObjectEvent *followerObj = GetFollowerObject(); if (!followerObj || followerObj->invisible) @@ -1985,7 +1983,7 @@ static bool8 ShouldDoSlideInAnim(u32 battler) return TRUE; } -void StartSendOutAnim(u32 battler, bool32 dontClearTransform, bool32 dontClearSubstituteBit, bool32 doSlideIn) +void StartSendOutAnim(enum BattlerId battler, bool32 dontClearTransform, bool32 dontClearSubstituteBit, bool32 doSlideIn) { u16 species; struct Pokemon *mon = GetBattlerMon(battler); @@ -2029,7 +2027,7 @@ void StartSendOutAnim(u32 battler, bool32 dontClearTransform, bool32 dontClearSu gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(battler, 0, sendoutType); } -static void FreeMonSprite(u32 battler) +static void FreeMonSprite(enum BattlerId battler) { FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[battler]]); DestroySprite(&gSprites[gBattlerSpriteIds[battler]]); @@ -2038,7 +2036,7 @@ static void FreeMonSprite(u32 battler) SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); } -static void Controller_ReturnMonToBall2(u32 battler) +static void Controller_ReturnMonToBall2(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) { @@ -2047,7 +2045,7 @@ static void Controller_ReturnMonToBall2(u32 battler) } } -static void Controller_ReturnMonToBall(u32 battler) +static void Controller_ReturnMonToBall(enum BattlerId battler) { switch (gBattleSpritesDataPtr->healthBoxesData[battler].animationState) { @@ -2068,7 +2066,7 @@ static void Controller_ReturnMonToBall(u32 battler) } } -static void Controller_FaintPlayerMon(u32 battler) +static void Controller_FaintPlayerMon(enum BattlerId battler) { u32 spriteId = gBattlerSpriteIds[battler]; if (gSprites[spriteId].y + gSprites[spriteId].y2 > DISPLAY_HEIGHT) @@ -2081,7 +2079,7 @@ static void Controller_FaintPlayerMon(u32 battler) } } -static void Controller_FaintOpponentMon(u32 battler) +static void Controller_FaintOpponentMon(enum BattlerId battler) { if (!gSprites[gBattlerSpriteIds[battler]].inUse) { @@ -2090,7 +2088,7 @@ static void Controller_FaintOpponentMon(u32 battler) } } -static void Controller_DoMoveAnimation(u32 battler) +static void Controller_DoMoveAnimation(enum BattlerId battler) { enum Move move = gBattleResources->bufferA[battler][1] | (gBattleResources->bufferA[battler][2] << 8); @@ -2140,7 +2138,7 @@ static void Controller_DoMoveAnimation(u32 battler) } } -static void Controller_HandleTrainerSlideBack(u32 battler) +static void Controller_HandleTrainerSlideBack(enum BattlerId battler) { if (gSprites[gBattleStruct->trainerSlideSpriteIds[battler]].callback == SpriteCallbackDummy) { @@ -2152,7 +2150,7 @@ static void Controller_HandleTrainerSlideBack(u32 battler) } } -void Controller_WaitForHealthBar(u32 battler) +void Controller_WaitForHealthBar(enum BattlerId battler) { s16 hpValue = MoveBattleBar(battler, gHealthboxSpriteIds[battler], HEALTH_BAR, 0); @@ -2169,37 +2167,37 @@ void Controller_WaitForHealthBar(u32 battler) } } -static void Controller_WaitForBallThrow(u32 battler) +static void Controller_WaitForBallThrow(enum BattlerId battler) { if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive) BtlController_Complete(battler); } -static void Controller_WaitForBattleAnimation(u32 battler) +static void Controller_WaitForBattleAnimation(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].animFromTableActive) BtlController_Complete(battler); } -static void Controller_WaitForStatusAnimation(u32 battler) +static void Controller_WaitForStatusAnimation(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive) BtlController_Complete(battler); } -static void Controller_WaitForTrainerPic(u32 battler) +static void Controller_WaitForTrainerPic(enum BattlerId battler) { if (gSprites[gBattleStruct->trainerSlideSpriteIds[battler]].callback == SpriteCallbackDummy) BtlController_Complete(battler); } -void Controller_WaitForString(u32 battler) +void Controller_WaitForString(enum BattlerId battler) { if (!IsTextPrinterActiveOnWindow(B_WIN_MSG)) BtlController_Complete(battler); } -static void Controller_WaitForPartyStatusSummary(u32 battler) +static void Controller_WaitForPartyStatusSummary(enum BattlerId battler) { if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer++ > 92) { @@ -2208,7 +2206,7 @@ static void Controller_WaitForPartyStatusSummary(u32 battler) } } -static void Controller_HitAnimation(u32 battler) +static void Controller_HitAnimation(enum BattlerId battler) { u32 spriteId = gBattlerSpriteIds[battler]; @@ -2228,22 +2226,22 @@ static void Controller_HitAnimation(u32 battler) } // Used for all the commands which do nothing. -void BtlController_Empty(u32 battler) +void BtlController_Empty(enum BattlerId battler) { BtlController_Complete(battler); } // Dummy function at the end of the table. -void BtlController_TerminatorNop(u32 battler) +void BtlController_TerminatorNop(enum BattlerId battler) { } -void BattleControllerDummy(u32 battler) +void BattleControllerDummy(enum BattlerId battler) { } // Handlers of the controller commands -void BtlController_HandleGetMonData(u32 battler) +void BtlController_HandleGetMonData(enum BattlerId battler) { u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data struct Pokemon *party = GetBattlerParty(battler); @@ -2269,7 +2267,7 @@ void BtlController_HandleGetMonData(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleGetRawMonData(u32 battler) +void BtlController_HandleGetRawMonData(enum BattlerId battler) { struct BattlePokemon battleMon; struct Pokemon *mon = GetBattlerMon(battler); @@ -2285,7 +2283,7 @@ void BtlController_HandleGetRawMonData(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleSetMonData(u32 battler) +void BtlController_HandleSetMonData(enum BattlerId battler) { struct Pokemon *party = GetBattlerParty(battler); u32 i, monToCheck; @@ -2307,7 +2305,7 @@ void BtlController_HandleSetMonData(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleSetRawMonData(u32 battler) +void BtlController_HandleSetRawMonData(enum BattlerId battler) { u32 i; u8 *dst = (u8 *)GetBattlerMon(battler) + gBattleResources->bufferA[battler][1]; @@ -2318,7 +2316,7 @@ void BtlController_HandleSetRawMonData(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleLoadMonSprite(u32 battler) +void BtlController_HandleLoadMonSprite(enum BattlerId battler) { struct Pokemon *mon = GetBattlerMon(battler); u16 species = GetBattlerVisualSpecies(battler); @@ -2345,7 +2343,7 @@ void BtlController_HandleLoadMonSprite(u32 battler) gBattlerControllerFuncs[battler] = WaitForMonAnimAfterLoad; } -void BtlController_HandleSwitchInAnim(u32 battler) +void BtlController_HandleSwitchInAnim(enum BattlerId battler) { bool32 isPlayerSide = (IsControllerPlayer(battler) || IsControllerPlayerPartner(battler) @@ -2372,7 +2370,7 @@ void BtlController_HandleSwitchInAnim(u32 battler) gBattlerControllerFuncs[battler] = BtlController_HandleSwitchInTryShinyAnim; } -void BtlController_HandleReturnMonToBall(u32 battler) +void BtlController_HandleReturnMonToBall(enum BattlerId battler) { if (gBattleResources->bufferA[battler][1] == 0) { @@ -2392,7 +2390,7 @@ void BtlController_HandleReturnMonToBall(u32 battler) #define sSpeedX data[0] -void BtlController_HandleDrawTrainerPic(u32 battler, enum TrainerPicID trainerPicId, bool32 isFrontPic, s16 xPos, s16 yPos, s32 subpriority) +void BtlController_HandleDrawTrainerPic(enum BattlerId battler, enum TrainerPicID trainerPicId, bool32 isFrontPic, s16 xPos, s16 yPos, s32 subpriority) { if (!IsOnPlayerSide(battler)) // Always the front sprite for the opponent. { @@ -2457,7 +2455,7 @@ void BtlController_HandleDrawTrainerPic(u32 battler, enum TrainerPicID trainerPi gBattlerControllerFuncs[battler] = Controller_WaitForTrainerPic; } -void BtlController_HandleTrainerSlide(u32 battler, enum TrainerPicID trainerPicId) +void BtlController_HandleTrainerSlide(enum BattlerId battler, enum TrainerPicID trainerPicId) { if (IsOnPlayerSide(battler)) { @@ -2494,7 +2492,7 @@ void BtlController_HandleTrainerSlide(u32 battler, enum TrainerPicID trainerPicI #undef sSpeedX -void BtlController_HandleTrainerSlideBack(u32 battler, s16 data0, bool32 startAnim) +void BtlController_HandleTrainerSlideBack(enum BattlerId battler, s16 data0, bool32 startAnim) { SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattleStruct->trainerSlideSpriteIds[battler]]); gSprites[gBattleStruct->trainerSlideSpriteIds[battler]].data[0] = data0; @@ -2510,7 +2508,7 @@ void BtlController_HandleTrainerSlideBack(u32 battler, s16 data0, bool32 startAn #define sSpeedX data[1] #define sSpeedY data[2] -void BtlController_HandleFaintAnimation(u32 battler) +void BtlController_HandleFaintAnimation(enum BattlerId battler) { SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]); if (gBattleSpritesDataPtr->healthBoxesData[battler].animationState == 0) @@ -2549,7 +2547,7 @@ void BtlController_HandleFaintAnimation(u32 battler) #undef sSpeedX #undef sSpeedY -static void HandleBallThrow(u32 battler, u32 target, u32 animId, bool32 allowCriticalCapture) +static void HandleBallThrow(enum BattlerId battler, enum BattlerId target, u32 animId, bool32 allowCriticalCapture) { gDoingBattleAnim = TRUE; if (allowCriticalCapture && IsCriticalCapture()) @@ -2559,11 +2557,11 @@ static void HandleBallThrow(u32 battler, u32 target, u32 animId, bool32 allowCri gBattlerControllerFuncs[battler] = Controller_WaitForBallThrow; } -void BtlController_HandleBallThrowAnim(u32 battler) +void BtlController_HandleBallThrowAnim(enum BattlerId battler) { bool32 allowCriticalCapture = FALSE; u32 animId = B_ANIM_BALL_THROW; - u32 target = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId target = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); if (BattlerIsPlayer(battler)) { @@ -2579,7 +2577,7 @@ void BtlController_HandleBallThrowAnim(u32 battler) HandleBallThrow(battler, target, animId, allowCriticalCapture); } -void BtlController_HandleMoveAnimation(u32 battler) +void BtlController_HandleMoveAnimation(enum BattlerId battler) { if (!IsBattleSEPlaying(battler)) { @@ -2600,7 +2598,7 @@ void BtlController_HandleMoveAnimation(u32 battler) } } -void BtlController_HandlePrintString(u32 battler) +void BtlController_HandlePrintString(enum BattlerId battler) { u16 *stringId; @@ -2628,7 +2626,7 @@ void BtlController_HandlePrintString(u32 battler) BattleArena_DeductSkillPoints(battler, *stringId); } -void BtlController_HandlePrintStringPlayerOnly(u32 battler) +void BtlController_HandlePrintStringPlayerOnly(enum BattlerId battler) { if (IsOnPlayerSide(battler)) BtlController_HandlePrintString(battler); @@ -2636,7 +2634,7 @@ void BtlController_HandlePrintStringPlayerOnly(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleHealthBarUpdate(u32 battler) +void BtlController_HandleHealthBarUpdate(enum BattlerId battler) { s32 maxHP, curHP; s16 hpVal; @@ -2666,7 +2664,7 @@ void BtlController_HandleHealthBarUpdate(u32 battler) gBattlerControllerFuncs[battler] = Controller_WaitForHealthBar; } -void BtlController_HandleStatusIconUpdate(u32 battler) +void BtlController_HandleStatusIconUpdate(enum BattlerId battler) { if (!IsBattleSEPlaying(battler)) { @@ -2688,7 +2686,7 @@ void BtlController_HandleStatusIconUpdate(u32 battler) } } -void BtlController_HandleStatusAnimation(u32 battler) +void BtlController_HandleStatusAnimation(enum BattlerId battler) { if (!IsBattleSEPlaying(battler)) { @@ -2698,7 +2696,7 @@ void BtlController_HandleStatusAnimation(u32 battler) } } -void BtlController_HandleHitAnimation(u32 battler) +void BtlController_HandleHitAnimation(enum BattlerId battler) { if (gSprites[gBattlerSpriteIds[battler]].invisible == TRUE || (gTestRunnerHeadless && !gBattleTestRunnerState->forceMoveAnim)) { @@ -2713,7 +2711,7 @@ void BtlController_HandleHitAnimation(u32 battler) } } -void BtlController_HandlePlaySE(u32 battler) +void BtlController_HandlePlaySE(enum BattlerId battler) { if (gTestRunnerHeadless && !gBattleTestRunnerState->forceMoveAnim) { @@ -2726,7 +2724,7 @@ void BtlController_HandlePlaySE(u32 battler) BtlController_Complete(battler); } -void BtlController_HandlePlayFanfareOrBGM(u32 battler) +void BtlController_HandlePlayFanfareOrBGM(enum BattlerId battler) { if (gTestRunnerHeadless && !gBattleTestRunnerState->forceMoveAnim) { @@ -2746,7 +2744,7 @@ void BtlController_HandlePlayFanfareOrBGM(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleFaintingCry(u32 battler) +void BtlController_HandleFaintingCry(enum BattlerId battler) { struct Pokemon *party = GetBattlerParty(battler); s8 pan; @@ -2760,14 +2758,14 @@ void BtlController_HandleFaintingCry(u32 battler) BtlController_Complete(battler); } -void BtlController_HandleIntroSlide(u32 battler) +void BtlController_HandleIntroSlide(enum BattlerId battler) { HandleIntroSlide(gBattleResources->bufferA[battler][1]); gIntroSlideFlags |= 1; BtlController_Complete(battler); } -void BtlController_HandleSpriteInvisibility(u32 battler) +void BtlController_HandleSpriteInvisibility(enum BattlerId battler) { if (IsBattlerSpritePresent(battler)) { @@ -2777,12 +2775,12 @@ void BtlController_HandleSpriteInvisibility(u32 battler) BtlController_Complete(battler); } -bool32 TwoPlayerIntroMons(u32 battler) // Double battle with both player pokemon active. +bool32 TwoPlayerIntroMons(enum BattlerId battler) // Double battle with both player pokemon active. { return (IsDoubleBattle() && IsValidForBattle(GetBattlerMon(battler ^ BIT_FLANK))); } -bool32 TwoOpponentIntroMons(u32 battler) // Double battle with both opponent pokemon active. +bool32 TwoOpponentIntroMons(enum BattlerId battler) // Double battle with both opponent pokemon active. { return (IsDoubleBattle() && IsValidForBattle(GetBattlerMon(battler)) @@ -2799,7 +2797,7 @@ bool32 TwoOpponentIntroMons(u32 battler) // Double battle with both opponent pok // Sprite data for SpriteCB_FreePlayerSpriteLoadMonSprite #define sBattlerId data[5] -void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, const u16 *trainerPal, s16 framesToWait, void (*controllerCallback)(u32 battler)) +void BtlController_HandleIntroTrainerBallThrow(enum BattlerId battler, u16 tagTrainerPal, const u16 *trainerPal, s16 framesToWait, void (*controllerCallback)(enum BattlerId battler)) { u8 paletteNum, taskId; enum BattleSide side = GetBattlerSide(battler); @@ -2846,7 +2844,7 @@ void BtlController_HandleIntroTrainerBallThrow(u32 battler, u16 tagTrainerPal, c gBattlerControllerFuncs[battler] = BattleControllerDummy; } -static bool32 TwoMonsAtSendOut(u32 battler) +static bool32 TwoMonsAtSendOut(enum BattlerId battler) { if (IsOnPlayerSide(battler)) { @@ -2876,8 +2874,8 @@ static void Task_StartSendOutAnim(u8 taskId) } else { - u32 battlerPartner; - u32 battler = gTasks[taskId].tBattlerId; + enum BattlerId battlerPartner; + enum BattlerId battler = gTasks[taskId].tBattlerId; if (TwoMonsAtSendOut(battler)) { @@ -2907,7 +2905,7 @@ static void Task_StartSendOutAnim(u8 taskId) static void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite) { - u8 battler = sprite->sBattlerId; + enum BattlerId battler = sprite->sBattlerId; // Free player trainer sprite FreeSpriteOamMatrix(sprite); @@ -2928,7 +2926,7 @@ static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite) #undef sBattlerId -void BtlController_HandleDrawPartyStatusSummary(u32 battler, enum BattleSide side, bool32 considerDelay) +void BtlController_HandleDrawPartyStatusSummary(enum BattlerId battler, enum BattleSide side, bool32 considerDelay) { if (gBattleResources->bufferA[battler][1] != 0 && IsOnPlayerSide(battler)) { @@ -2962,14 +2960,14 @@ void BtlController_HandleDrawPartyStatusSummary(u32 battler, enum BattleSide sid } } -void BtlController_HandleHidePartyStatusSummary(u32 battler) +void BtlController_HandleHidePartyStatusSummary(enum BattlerId battler) { if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown) gTasks[gBattlerStatusSummaryTaskId[battler]].func = Task_HidePartyStatusSummary; BtlController_Complete(battler); } -void BtlController_HandleBattleAnimation(u32 battler) +void BtlController_HandleBattleAnimation(enum BattlerId battler) { if ((gBattleTypeFlags & (BATTLE_TYPE_SAFARI | BATTLE_TYPE_WALLY_TUTORIAL)) || !IsBattleSEPlaying(battler)) @@ -2989,7 +2987,7 @@ void BtlController_HandleBattleAnimation(u32 battler) } } -void AnimateMonAfterPokeBallFail(u32 battler) +void AnimateMonAfterPokeBallFail(enum BattlerId battler) { if (B_ANIMATE_MON_AFTER_FAILED_POKEBALL == FALSE) return; @@ -2998,13 +2996,13 @@ void AnimateMonAfterPokeBallFail(u32 battler) TryShinyAnimation(gBattlerTarget, GetBattlerMon(gBattlerTarget)); } -static void AnimateMonAfterKnockout(u32 battler) +static void AnimateMonAfterKnockout(enum BattlerId battler) { if (B_ANIMATE_MON_AFTER_KO == FALSE) return; - u32 oppositeBattler = BATTLE_OPPOSITE(battler); - u32 partnerBattler = BATTLE_PARTNER(oppositeBattler); + enum BattlerId oppositeBattler = BATTLE_OPPOSITE(battler); + enum BattlerId partnerBattler = BATTLE_PARTNER(oppositeBattler); bool32 wasPlayerSideKnockedOut = (IsOnPlayerSide(battler)); if (IsBattlerAlive(oppositeBattler)) @@ -3014,7 +3012,7 @@ static void AnimateMonAfterKnockout(u32 battler) LaunchKOAnimation(partnerBattler, ReturnAnimIdForBattler(wasPlayerSideKnockedOut, partnerBattler), wasPlayerSideKnockedOut); } -static void LaunchKOAnimation(u32 battlerId, u16 animId, bool32 isFront) +static void LaunchKOAnimation(enum BattlerId battlerId, u16 animId, bool32 isFront) { u32 species = GetBattlerVisualSpecies(battlerId); u32 spriteId = gBattlerSpriteIds[battlerId]; @@ -3045,7 +3043,7 @@ static u32 ReturnAnimIdForBattler(bool32 wasPlayerSideKnockedOut, u32 specificBa return GetSpeciesBackAnimSet(species); } -void TrySetBattlerShadowSpriteCallback(u32 battler) +void TrySetBattlerShadowSpriteCallback(enum BattlerId battler) { if (gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteIdPrimary].callback == SpriteCallbackDummy && (B_ENEMY_MON_SHADOW_STYLE <= GEN_3 || P_GBA_STYLE_SPECIES_GFX == TRUE @@ -3053,7 +3051,7 @@ void TrySetBattlerShadowSpriteCallback(u32 battler) SetBattlerShadowSpriteCallback(battler, GetBattlerVisualSpecies(battler)); } -void TryShinyAnimAfterMonAnim(u32 battler) +void TryShinyAnimAfterMonAnim(enum BattlerId battler) { if (gSprites[gBattlerSpriteIds[battler]].x2 == 0) { @@ -3072,13 +3070,13 @@ void TryShinyAnimAfterMonAnim(u32 battler) } } -void WaitForMonAnimAfterLoad(u32 battler) +void WaitForMonAnimAfterLoad(enum BattlerId battler) { if (gSprites[gBattlerSpriteIds[battler]].animEnded && gSprites[gBattlerSpriteIds[battler]].x2 == 0) BtlController_Complete(battler); } -void BtlController_HandleSwitchInShowSubstitute(u32 battler) +void BtlController_HandleSwitchInShowSubstitute(enum BattlerId battler) { if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy) { @@ -3097,14 +3095,14 @@ void BtlController_HandleSwitchInShowSubstitute(u32 battler) } } -void BtlController_HandleSwitchInWaitAndEnd(u32 battler) +void BtlController_HandleSwitchInWaitAndEnd(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy) BtlController_Complete(battler); } -void BtlController_Intro_DelayAndEnd(u32 battler) +void BtlController_Intro_DelayAndEnd(enum BattlerId battler) { if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1) { @@ -3113,7 +3111,7 @@ void BtlController_Intro_DelayAndEnd(u32 battler) } } -void BtlController_HandleSwitchInSoundAndEnd(u32 battler) +void BtlController_HandleSwitchInSoundAndEnd(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive && !IsCryPlayingOrClearCrySongs()) { @@ -3129,7 +3127,7 @@ void BtlController_HandleSwitchInSoundAndEnd(u32 battler) } } -void BtlController_HandleSwitchInShowHealthbox(u32 battler) +void BtlController_HandleSwitchInShowHealthbox(enum BattlerId battler) { enum BattleSide side = GetBattlerSide(battler); if (gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim @@ -3156,7 +3154,7 @@ void BtlController_HandleSwitchInShowHealthbox(u32 battler) } } -static void SwitchIn_CleanShinyAnimShowSubstitute(u32 battler) +static void SwitchIn_CleanShinyAnimShowSubstitute(enum BattlerId battler) { if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim @@ -3177,7 +3175,7 @@ static void SwitchIn_CleanShinyAnimShowSubstitute(u32 battler) } } -void BtlController_HandleSwitchInTryShinyAnim(u32 battler) +void BtlController_HandleSwitchInTryShinyAnim(enum BattlerId battler) { if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) @@ -3205,7 +3203,7 @@ void BtlController_HandleSwitchInTryShinyAnim(u32 battler) } } -void UpdateFriendshipFromXItem(u32 battler) +void UpdateFriendshipFromXItem(enum BattlerId battler) { struct Pokemon *party = GetBattlerParty(battler); @@ -3231,14 +3229,14 @@ void UpdateFriendshipFromXItem(u32 battler) } } -bool32 ShouldBattleRestrictionsApply(u32 battler) +bool32 ShouldBattleRestrictionsApply(enum BattlerId battler) { return IsControllerPlayer(battler); } void FreeShinyStars(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim) return; diff --git a/src/battle_debug.c b/src/battle_debug.c index 851c862b38..7395cb18e2 100644 --- a/src/battle_debug.c +++ b/src/battle_debug.c @@ -54,8 +54,8 @@ struct BattleDebugModifyArrows struct BattleDebugMenu { - u8 battlerId:2; - u8 aiBattlerId:2; + enum BattlerId battlerId:3; + enum BattlerId aiBattlerId:3; u8 battlerWindowId; @@ -602,7 +602,7 @@ static const u16 sBgColor[] = {RGB_WHITE}; static void Task_DebugMenuFadeOut(u8 taskId); static void Task_DebugMenuProcessInput(u8 taskId); static void Task_DebugMenuFadeIn(u8 taskId); -static void PrintOnBattlerWindow(u8 windowId, u8 battlerId); +static void PrintOnBattlerWindow(u8 windowId, enum BattlerId battler); static void UpdateWindowsOnChangedBattler(struct BattleDebugMenu *data); static void CreateSecondaryListMenu(struct BattleDebugMenu *data); static void PrintSecondaryEntries(struct BattleDebugMenu *data); @@ -915,14 +915,14 @@ static void PutAiInfoText(struct BattleDebugMenu *data) } // items info - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - if (IsOnPlayerSide(i) && IsBattlerAlive(i)) + if (IsOnPlayerSide(battler) && IsBattlerAlive(battler)) { - enum Ability ability = gAiLogicData->abilities[i]; - enum HoldEffect holdEffect = gAiLogicData->holdEffects[i]; - enum Item item = gAiLogicData->items[i]; - u8 x = (i == B_POSITION_PLAYER_LEFT) ? 83 + (i) * 75 : 83 + (i-1) * 75; + enum Ability ability = gAiLogicData->abilities[battler]; + enum HoldEffect holdEffect = gAiLogicData->holdEffects[battler]; + enum Item item = gAiLogicData->items[battler]; + u8 x = (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT) ? 83 + battler * 75 : 83 + (battler - 1) * 75; AddTextPrinterParameterized(data->aiMovesWindowId, FONT_SMALL, gAbilitiesInfo[ability].name, x, 0, 0, NULL); AddTextPrinterParameterized(data->aiMovesWindowId, FONT_SMALL, GetItemName(item), x, 15, 0, NULL); AddTextPrinterParameterized(data->aiMovesWindowId, FONT_SMALL, GetHoldEffectName(holdEffect), x, 30, 0, NULL); @@ -1311,15 +1311,15 @@ static void Task_DebugMenuFadeOut(u8 taskId) } } -static void PrintOnBattlerWindow(u8 windowId, u8 battlerId) +static void PrintOnBattlerWindow(u8 windowId, enum BattlerId battler) { u8 text[POKEMON_NAME_LENGTH + 10]; - text[0] = CHAR_0 + battlerId; + text[0] = CHAR_0 + battler; text[1] = CHAR_SPACE; text[2] = CHAR_HYPHEN; text[3] = CHAR_SPACE; - StringCopy(&text[4], gBattleMons[battlerId].nickname); + StringCopy(&text[4], gBattleMons[battler].nickname); FillWindowPixelBuffer(windowId, 0x11); AddTextPrinterParameterized(windowId, FONT_NORMAL, text, 0, 0, 0, NULL); diff --git a/src/battle_dynamax.c b/src/battle_dynamax.c index a101f424af..20a0f69f21 100644 --- a/src/battle_dynamax.c +++ b/src/battle_dynamax.c @@ -70,7 +70,7 @@ static const struct GMaxMove sGMaxMoveTable[] = }; // Returns whether a battler can Dynamax. -bool32 CanDynamax(u32 battler) +bool32 CanDynamax(enum BattlerId battler) { u16 species = GetBattlerVisualSpecies(battler); enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); @@ -120,7 +120,7 @@ bool32 CanDynamax(u32 battler) } // Returns whether a battler is transformed into a Gigantamax form. -bool32 IsGigantamaxed(u32 battler) +bool32 IsGigantamaxed(enum BattlerId battler) { struct Pokemon *mon = GetBattlerMon(battler); if ((gSpeciesInfo[gBattleMons[battler].species].isGigantamax) && GetMonData(mon, MON_DATA_GIGANTAMAX_FACTOR)) @@ -144,7 +144,7 @@ void ApplyDynamaxHPMultiplier(struct Pokemon* mon) } // Returns the non-Dynamax HP of a Pokemon. -u32 GetNonDynamaxHP(u32 battler) +u32 GetNonDynamaxHP(enum BattlerId battler) { if (GetActiveGimmick(battler) != GIMMICK_DYNAMAX || gBattleMons[battler].species == SPECIES_SHEDINJA) return gBattleMons[battler].hp; @@ -158,7 +158,7 @@ u32 GetNonDynamaxHP(u32 battler) } // Returns the non-Dynamax Max HP of a Pokemon. -u32 GetNonDynamaxMaxHP(u32 battler) +u32 GetNonDynamaxMaxHP(enum BattlerId battler) { if (GetActiveGimmick(battler) != GIMMICK_DYNAMAX || gBattleMons[battler].species == SPECIES_SHEDINJA) return gBattleMons[battler].maxHP; @@ -172,7 +172,7 @@ u32 GetNonDynamaxMaxHP(u32 battler) } // Sets flags used for Dynamaxing and checks Gigantamax forms. -void ActivateDynamax(u32 battler) +void ActivateDynamax(enum BattlerId battler) { // Set appropriate use flags. SetActiveGimmick(battler, GIMMICK_DYNAMAX); @@ -194,7 +194,7 @@ void ActivateDynamax(u32 battler) } // Unsets the flags used for Dynamaxing and reverts max HP if needed. -void UndoDynamax(u32 battler) +void UndoDynamax(enum BattlerId battler) { // Revert HP if battler is still Dynamaxed. if (GetActiveGimmick(battler) == GIMMICK_DYNAMAX) @@ -234,7 +234,7 @@ bool32 IsMoveBlockedByMaxGuard(enum Move move) } } -static enum Move GetTypeBasedMaxMove(u32 battler, enum Type type) +static enum Move GetTypeBasedMaxMove(enum BattlerId battler, enum Type type) { // Gigantamax check u32 i; @@ -263,7 +263,7 @@ static enum Move GetTypeBasedMaxMove(u32 battler, enum Type type) } // Returns the appropriate Max Move or G-Max Move for a battler to use. -enum Move GetMaxMove(u32 battler, enum Move baseMove) +enum Move GetMaxMove(enum BattlerId battler, enum Move baseMove) { enum Type moveType; SetTypeBeforeUsingMove(baseMove, battler); diff --git a/src/battle_end_turn.c b/src/battle_end_turn.c index a244de5f4c..4d0dd41b10 100644 --- a/src/battle_end_turn.c +++ b/src/battle_end_turn.c @@ -15,7 +15,7 @@ static u32 GetBattlerSideForMessage(enum BattleSide side) { - u32 battler = 0; + enum BattlerId battler = 0; for (battler = 0; battler < gBattlersCount; battler++) { @@ -26,23 +26,22 @@ static u32 GetBattlerSideForMessage(enum BattleSide side) return battler; } -static bool32 HandleEndTurnOrder(u32 battler) +static bool32 HandleEndTurnOrder(enum BattlerId battler) { bool32 effect = FALSE; gBattleTurnCounter++; gBattleStruct->eventState.endTurn++; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattlerByTurnOrder[i] = i; SortBattlersBySpeed(gBattlerByTurnOrder, FALSE); return effect; } -static bool32 HandleEndTurnVarious(u32 battler) +static bool32 HandleEndTurnVarious(enum BattlerId battler) { - u32 i; bool32 effect = FALSE; gBattleStruct->eventState.endTurn++; @@ -50,13 +49,13 @@ static bool32 HandleEndTurnVarious(u32 battler) if (gFieldTimers.fairyLockTimer > 0 && --gFieldTimers.fairyLockTimer == 0) gFieldStatuses &= ~STATUS_FIELD_FAIRY_LOCK; - for (i = 0; i < NUM_BATTLE_SIDES; i++) + for (enum BattleSide i = 0; i < NUM_BATTLE_SIDES; i++) { if (gSideTimers[i].damageNonTypesTimer > 0 && --gSideTimers[i].damageNonTypesTimer == 0) gSideStatuses[i] &= ~SIDE_STATUS_DAMAGE_NON_TYPES; } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.throatChopTimer > 0) gBattleMons[i].volatiles.throatChopTimer--; @@ -87,13 +86,13 @@ static bool32 HandleEndTurnVarious(u32 battler) return effect; } -static bool32 HandleEndTurnWeather(u32 battler) +static bool32 HandleEndTurnWeather(enum BattlerId battler) { gBattleStruct->eventState.endTurn++; return EndOrContinueWeather(); } -static bool32 HandleEndTurnWeatherDamage(u32 battler) +static bool32 HandleEndTurnWeatherDamage(enum BattlerId battler) { bool32 effect = FALSE; @@ -182,7 +181,7 @@ static bool32 HandleEndTurnWeatherDamage(u32 battler) return effect; } -static bool32 HandleEndTurnEmergencyExit(u32 battler) +static bool32 HandleEndTurnEmergencyExit(enum BattlerId battler) { bool32 effect = FALSE; enum Ability ability = GetBattlerAbility(battler); @@ -201,7 +200,7 @@ static bool32 HandleEndTurnEmergencyExit(u32 battler) return effect; } -static bool32 HandleEndTurnAffection(u32 battler) +static bool32 HandleEndTurnAffection(enum BattlerId battler) { bool32 effect = FALSE; @@ -224,7 +223,7 @@ static bool32 HandleEndTurnAffection(u32 battler) // Note: Technically Future Sight, Doom Desire and Wish need a queue but // I think we should accept this slight inconsistency so custom moves don't have to touch this code -static bool32 HandleEndTurnFutureSight(u32 battler) +static bool32 HandleEndTurnFutureSight(enum BattlerId battler) { bool32 effect = FALSE; @@ -258,7 +257,7 @@ static bool32 HandleEndTurnFutureSight(u32 battler) return effect; } -static bool32 HandleEndTurnWish(u32 battler) +static bool32 HandleEndTurnWish(enum BattlerId battler) { bool32 effect = FALSE; @@ -288,7 +287,7 @@ static bool32 HandleEndTurnWish(u32 battler) return effect; } -static bool32 HandleEndTurnFirstEventBlock(u32 battler) +static bool32 HandleEndTurnFirstEventBlock(enum BattlerId battler) { bool32 effect = FALSE; enum BattleSide side; @@ -392,7 +391,7 @@ static bool32 HandleEndTurnFirstEventBlock(u32 battler) return effect; } -static bool32 HandleEndTurnAquaRing(u32 battler) +static bool32 HandleEndTurnAquaRing(enum BattlerId battler) { bool32 effect = FALSE; @@ -411,7 +410,7 @@ static bool32 HandleEndTurnAquaRing(u32 battler) return effect; } -static bool32 HandleEndTurnIngrain(u32 battler) +static bool32 HandleEndTurnIngrain(enum BattlerId battler) { bool32 effect = FALSE; @@ -430,7 +429,7 @@ static bool32 HandleEndTurnIngrain(u32 battler) return effect; } -static bool32 HandleEndTurnLeechSeed(u32 battler) +static bool32 HandleEndTurnLeechSeed(enum BattlerId battler) { bool32 effect = FALSE; @@ -470,7 +469,7 @@ static bool32 HandleEndTurnLeechSeed(u32 battler) return effect; } -static bool32 HandleEndTurnPoison(u32 battler) +static bool32 HandleEndTurnPoison(enum BattlerId battler) { bool32 effect = FALSE; @@ -511,7 +510,7 @@ static bool32 HandleEndTurnPoison(u32 battler) return effect; } -static bool32 HandleEndTurnBurn(u32 battler) +static bool32 HandleEndTurnBurn(enum BattlerId battler) { bool32 effect = FALSE; @@ -538,7 +537,7 @@ static bool32 HandleEndTurnBurn(u32 battler) return effect; } -static bool32 HandleEndTurnFrostbite(u32 battler) +static bool32 HandleEndTurnFrostbite(enum BattlerId battler) { bool32 effect = FALSE; @@ -556,7 +555,7 @@ static bool32 HandleEndTurnFrostbite(u32 battler) return effect; } -static bool32 HandleEndTurnNightmare(u32 battler) +static bool32 HandleEndTurnNightmare(enum BattlerId battler) { bool32 effect = FALSE; @@ -581,7 +580,7 @@ static bool32 HandleEndTurnNightmare(u32 battler) return effect; } -static bool32 HandleEndTurnCurse(u32 battler) +static bool32 HandleEndTurnCurse(enum BattlerId battler) { bool32 effect = FALSE; @@ -599,7 +598,7 @@ static bool32 HandleEndTurnCurse(u32 battler) return effect; } -static bool32 HandleEndTurnWrap(u32 battler) +static bool32 HandleEndTurnWrap(enum BattlerId battler) { bool32 effect = FALSE; @@ -636,7 +635,7 @@ static bool32 HandleEndTurnWrap(u32 battler) return effect; } -static bool32 HandleEndTurnSaltCure(u32 battler) +static bool32 HandleEndTurnSaltCure(enum BattlerId battler) { bool32 effect = FALSE; @@ -660,7 +659,7 @@ static bool32 HandleEndTurnSaltCure(u32 battler) return effect; } -static bool32 HandleEndTurnOctolock(u32 battler) +static bool32 HandleEndTurnOctolock(enum BattlerId battler) { bool32 effect = FALSE; @@ -677,7 +676,7 @@ static bool32 HandleEndTurnOctolock(u32 battler) return effect; } -static bool32 HandleEndTurnSyrupBomb(u32 battler) +static bool32 HandleEndTurnSyrupBomb(enum BattlerId battler) { bool32 effect = FALSE; @@ -696,7 +695,7 @@ static bool32 HandleEndTurnSyrupBomb(u32 battler) return effect; } -static bool32 HandleEndTurnTaunt(u32 battler) +static bool32 HandleEndTurnTaunt(enum BattlerId battler) { bool32 effect = FALSE; @@ -713,7 +712,7 @@ static bool32 HandleEndTurnTaunt(u32 battler) return effect; } -static bool32 HandleEndTurnTorment(u32 battler) +static bool32 HandleEndTurnTorment(enum BattlerId battler) { bool32 effect = FALSE; @@ -730,7 +729,7 @@ static bool32 HandleEndTurnTorment(u32 battler) return effect; } -static bool32 HandleEndTurnEncore(u32 battler) +static bool32 HandleEndTurnEncore(enum BattlerId battler) { bool32 effect = FALSE; @@ -757,7 +756,7 @@ static bool32 HandleEndTurnEncore(u32 battler) return effect; } -static bool32 HandleEndTurnDisable(u32 battler) +static bool32 HandleEndTurnDisable(enum BattlerId battler) { bool32 effect = FALSE; @@ -788,7 +787,7 @@ static bool32 HandleEndTurnDisable(u32 battler) return effect; } -static bool32 HandleEndTurnMagnetRise(u32 battler) +static bool32 HandleEndTurnMagnetRise(enum BattlerId battler) { bool32 effect = FALSE; @@ -805,7 +804,7 @@ static bool32 HandleEndTurnMagnetRise(u32 battler) return effect; } -static bool32 HandleEndTurnTelekinesis(u32 battler) +static bool32 HandleEndTurnTelekinesis(enum BattlerId battler) { bool32 effect = FALSE; @@ -821,7 +820,7 @@ static bool32 HandleEndTurnTelekinesis(u32 battler) return effect; } -static bool32 HandleEndTurnHealBlock(u32 battler) +static bool32 HandleEndTurnHealBlock(enum BattlerId battler) { bool32 effect = FALSE; @@ -839,7 +838,7 @@ static bool32 HandleEndTurnHealBlock(u32 battler) return effect; } -static bool32 HandleEndTurnEmbargo(u32 battler) +static bool32 HandleEndTurnEmbargo(enum BattlerId battler) { bool32 effect = FALSE; @@ -855,7 +854,7 @@ static bool32 HandleEndTurnEmbargo(u32 battler) return effect; } -static bool32 HandleEndTurnYawn(u32 battler) +static bool32 HandleEndTurnYawn(enum BattlerId battler) { bool32 effect = FALSE; @@ -919,7 +918,7 @@ static bool32 HandleEndTurnYawn(u32 battler) return effect; } -static bool32 HandleEndTurnPerishSong(u32 battler) +static bool32 HandleEndTurnPerishSong(enum BattlerId battler) { bool32 effect = FALSE; @@ -945,7 +944,7 @@ static bool32 HandleEndTurnPerishSong(u32 battler) return effect; } -static bool32 HandleEndTurnRoost(u32 battler) +static bool32 HandleEndTurnRoost(enum BattlerId battler) { bool32 effect = FALSE; @@ -957,7 +956,7 @@ static bool32 HandleEndTurnRoost(u32 battler) return effect; } -static bool32 HandleEndTurnSecondEventBlock(u32 battler) +static bool32 HandleEndTurnSecondEventBlock(enum BattlerId battler) { bool32 effect = FALSE; @@ -1078,7 +1077,7 @@ static bool32 HandleEndTurnSecondEventBlock(u32 battler) return effect; } -static bool32 HandleEndTurnTrickRoom(u32 battler) +static bool32 HandleEndTurnTrickRoom(enum BattlerId battler) { bool32 effect = FALSE; @@ -1094,7 +1093,7 @@ static bool32 HandleEndTurnTrickRoom(u32 battler) return effect; } -static bool32 HandleEndTurnGravity(u32 battler) +static bool32 HandleEndTurnGravity(enum BattlerId battler) { bool32 effect = FALSE; @@ -1110,7 +1109,7 @@ static bool32 HandleEndTurnGravity(u32 battler) return effect; } -static bool32 HandleEndTurnWaterSport(u32 battler) +static bool32 HandleEndTurnWaterSport(enum BattlerId battler) { bool32 effect = FALSE; @@ -1126,7 +1125,7 @@ static bool32 HandleEndTurnWaterSport(u32 battler) return effect; } -static bool32 HandleEndTurnMudSport(u32 battler) +static bool32 HandleEndTurnMudSport(enum BattlerId battler) { bool32 effect = FALSE; @@ -1142,7 +1141,7 @@ static bool32 HandleEndTurnMudSport(u32 battler) return effect; } -static bool32 HandleEndTurnWonderRoom(u32 battler) +static bool32 HandleEndTurnWonderRoom(enum BattlerId battler) { bool32 effect = FALSE; @@ -1158,7 +1157,7 @@ static bool32 HandleEndTurnWonderRoom(u32 battler) return effect; } -static bool32 HandleEndTurnMagicRoom(u32 battler) +static bool32 HandleEndTurnMagicRoom(enum BattlerId battler) { bool32 effect = FALSE; @@ -1188,7 +1187,7 @@ static bool32 EndTurnTerrain(u32 terrainFlag, u32 stringTableId) return FALSE; } -static bool32 HandleEndTurnTerrain(u32 battler) +static bool32 HandleEndTurnTerrain(enum BattlerId battler) { bool32 effect = FALSE; @@ -1206,7 +1205,7 @@ static bool32 HandleEndTurnTerrain(u32 battler) return effect; } -static bool32 HandleEndTurnThirdEventBlock(u32 battler) +static bool32 HandleEndTurnThirdEventBlock(enum BattlerId battler) { bool32 effect = FALSE; @@ -1312,7 +1311,7 @@ static bool32 HandleEndTurnThirdEventBlock(u32 battler) return effect; } -static bool32 HandleEndTurnFormChangeAbilities(u32 battler) +static bool32 HandleEndTurnFormChangeAbilities(enum BattlerId battler) { bool32 effect = FALSE; @@ -1336,13 +1335,13 @@ static bool32 HandleEndTurnFormChangeAbilities(u32 battler) return effect; } -static bool32 HandleEndTurnEjectPack(u32 battler) +static bool32 HandleEndTurnEjectPack(enum BattlerId battler) { gBattleStruct->eventState.endTurn++; return TrySwitchInEjectPack(END_TURN); } -static bool32 HandleEndTurnDynamax(u32 battler) +static bool32 HandleEndTurnDynamax(enum BattlerId battler) { bool32 effect = FALSE; @@ -1359,7 +1358,7 @@ static bool32 HandleEndTurnDynamax(u32 battler) return effect; } -static bool32 TryEndTurnTrainerSlide(u32 battler) +static bool32 TryEndTurnTrainerSlide(enum BattlerId battler) { return ((ShouldDoTrainerSlide(battler, TRAINER_SLIDE_LAST_LOW_HP) != TRAINER_SLIDE_TARGET_NONE) || (ShouldDoTrainerSlide(battler, TRAINER_SLIDE_LAST_HALF_HP) != TRAINER_SLIDE_TARGET_NONE) @@ -1370,7 +1369,7 @@ static bool32 TryEndTurnTrainerSlide(u32 battler) || (ShouldDoTrainerSlide(battler, TRAINER_SLIDE_ENEMY_MON_UNAFFECTED) != TRAINER_SLIDE_TARGET_NONE)); } -static bool32 HandleEndTurnTrainerASlides(u32 battler) +static bool32 HandleEndTurnTrainerASlides(enum BattlerId battler) { gBattleStruct->eventState.endTurnBattler++; bool32 slide = TryEndTurnTrainerSlide(B_BATTLER_1); @@ -1379,7 +1378,7 @@ static bool32 HandleEndTurnTrainerASlides(u32 battler) return slide; } -static bool32 HandleEndTurnTrainerBSlides(u32 battler) +static bool32 HandleEndTurnTrainerBSlides(enum BattlerId battler) { gBattleStruct->eventState.endTurnBattler++; @@ -1390,7 +1389,7 @@ static bool32 HandleEndTurnTrainerBSlides(u32 battler) if (slide == TRUE) { - if ((TRAINER_BATTLE_PARAM.opponentB == TRAINER_BATTLE_PARAM.opponentA) + if ((TRAINER_BATTLE_PARAM.opponentB == TRAINER_BATTLE_PARAM.opponentA) || (TRAINER_BATTLE_PARAM.opponentB == TRAINER_NONE) || (TRAINER_BATTLE_PARAM.opponentB == 0xFFFF)) BattleScriptExecute(BattleScript_TrainerASlideMsgEnd2); @@ -1401,7 +1400,7 @@ static bool32 HandleEndTurnTrainerBSlides(u32 battler) return slide; } -static bool32 HandleEndTurnTrainerPartnerSlides(u32 battler) +static bool32 HandleEndTurnTrainerPartnerSlides(enum BattlerId battler) { gBattleStruct->eventState.endTurnBattler++; @@ -1429,7 +1428,7 @@ static bool32 HandleEndTurnTrainerPartnerSlides(u32 battler) some commands end2 */ -static bool32 (*const sEndTurnEffectHandlers[])(u32 battler) = +static bool32 (*const sEndTurnEffectHandlers[])(enum BattlerId battler) = { [ENDTURN_ORDER] = HandleEndTurnOrder, [ENDTURN_VARIOUS] = HandleEndTurnVarious, diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index ea3cb1ab46..e98dbce079 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -31,8 +31,8 @@ #include "constants/event_objects.h" // only for SHADOW_SIZE constants // this file's functions -static u8 GetBattlePalaceMoveGroup(u8 battler, enum Move move); -static u16 GetBattlePalaceTarget(u32 battler); +static u8 GetBattlePalaceMoveGroup(enum BattlerId battler, enum Move move); +static u16 GetBattlePalaceTarget(enum BattlerId battler); static void SpriteCB_TrainerSlideVertical(struct Sprite *sprite); static bool8 ShouldAnimBeDoneRegardlessOfSubstitute(u8 animId); static void Task_ClearBitWhenBattleTableAnimDone(u8 taskId); @@ -140,7 +140,7 @@ void FreeBattleSpritesData(void) } // Pokémon chooses move to use in Battle Palace rather than player -u16 ChooseMoveAndTargetInBattlePalace(u32 battler) +u16 ChooseMoveAndTargetInBattlePalace(enum BattlerId battler) { s32 i, var1, var2; s32 chosenMoveIndex = -1; @@ -317,7 +317,7 @@ u16 ChooseMoveAndTargetInBattlePalace(u32 battler) #undef numMultipleMoveGroups #undef randSelectGroup -static u8 GetBattlePalaceMoveGroup(u8 battler, enum Move move) +static u8 GetBattlePalaceMoveGroup(enum BattlerId battler, enum Move move) { switch (GetBattlerMoveTargetType(battler, move)) { @@ -347,11 +347,11 @@ static u8 GetBattlePalaceMoveGroup(u8 battler, enum Move move) } } -static u16 GetBattlePalaceTarget(u32 battler) +static u16 GetBattlePalaceTarget(enum BattlerId battler) { if (IsDoubleBattle()) { - u8 opposing1, opposing2; + enum BattlerId opposing1, opposing2; if (IsOnPlayerSide(battler)) { @@ -460,7 +460,7 @@ static void SpriteCB_TrainerSlideVertical(struct Sprite *sprite) #undef sSpeedX -void InitAndLaunchChosenStatusAnimation(u32 battler, bool32 isVolatile, u32 status) +void InitAndLaunchChosenStatusAnimation(enum BattlerId battler, bool32 isVolatile, u32 status) { gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive = 1; if (!isVolatile) @@ -566,7 +566,7 @@ static bool8 ShouldAnimBeDoneRegardlessOfSubstitute(u8 animId) #define tBattlerId data[0] -void InitAndLaunchSpecialAnimation(u8 activeBattler, u8 atkBattler, u8 defBattler, u8 tableId) +void InitAndLaunchSpecialAnimation(enum BattlerId activeBattler, enum BattlerId atkBattler, enum BattlerId defBattler, u8 tableId) { u8 taskId; @@ -591,7 +591,7 @@ static void Task_ClearBitWhenSpecialAnimDone(u8 taskId) #undef tBattlerId // Check if SE has finished or 30 calls, whichever comes first -bool8 IsBattleSEPlaying(u8 battler) +bool8 IsBattleSEPlaying(enum BattlerId battler) { u8 zero = 0; @@ -614,7 +614,7 @@ bool8 IsBattleSEPlaying(u8 battler) return TRUE; } -void BattleLoadMonSpriteGfx(struct Pokemon *mon, u32 battler) +void BattleLoadMonSpriteGfx(struct Pokemon *mon, enum BattlerId battler) { u32 personalityValue, isShiny, species, paletteOffset; enum BattlerPosition position; @@ -689,7 +689,7 @@ void BattleGfxSfxDummy2(u16 species) { } -void DecompressTrainerFrontPic(u16 frontPicId, u8 battler) +void DecompressTrainerFrontPic(u16 frontPicId, enum BattlerId battler) { enum BattlerPosition position = GetBattlerPosition(battler); DecompressPicFromTable(&gTrainerSprites[frontPicId].frontPic, @@ -697,7 +697,7 @@ void DecompressTrainerFrontPic(u16 frontPicId, u8 battler) LoadSpritePalette(&gTrainerSprites[frontPicId].palette); } -void DecompressTrainerBackPic(enum TrainerPicID backPicId, u8 battler) +void DecompressTrainerBackPic(enum TrainerPicID backPicId, enum BattlerId battler) { enum BattlerPosition position = GetBattlerPosition(battler); CopyTrainerBackspriteFramesToDest(backPicId, gMonSpritesGfxPtr->spritesGfx[position]); @@ -780,7 +780,7 @@ bool8 BattleLoadAllHealthBoxesGfx(u8 state) { if (state == 2) { - switch (GetBattlerCoordsIndex(B_POSITION_PLAYER_LEFT)) + switch (GetBattlerCoordsIndex(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT))) { default: LoadCompressedSpriteSheet(&sSpriteSheets_DoublesPlayerHealthbox[0]); @@ -903,18 +903,16 @@ static void ClearSpritesBattlerHealthboxAnimData(void) void CopyAllBattleSpritesInvisibilities(void) { - s32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleSpritesDataPtr->battlerData[i].invisible = gSprites[gBattlerSpriteIds[i]].invisible; } -void CopyBattleSpriteInvisibility(u8 battler) +void CopyBattleSpriteInvisibility(enum BattlerId battler) { gBattleSpritesDataPtr->battlerData[battler].invisible = gSprites[gBattlerSpriteIds[battler]].invisible; } -void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, u8 changeType) +void HandleSpeciesGfxDataChange(enum BattlerId battlerAtk, enum BattlerId battlerDef, u8 changeType) { u32 personalityValue, paletteOffset, targetSpecies; enum BattlerPosition position; @@ -1006,7 +1004,7 @@ void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, u8 changeType) StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerAtk]], 0); } -void BattleLoadSubstituteOrMonSpriteGfx(u8 battler, bool8 loadMonSprite) +void BattleLoadSubstituteOrMonSpriteGfx(enum BattlerId battler, bool8 loadMonSprite) { s32 i, palOffset; enum BattlerPosition position; @@ -1040,7 +1038,7 @@ void BattleLoadSubstituteOrMonSpriteGfx(u8 battler, bool8 loadMonSprite) } } -void LoadBattleMonGfxAndAnimate(u8 battler, bool8 loadMonSprite, u8 spriteId) +void LoadBattleMonGfxAndAnimate(enum BattlerId battler, bool8 loadMonSprite, u8 spriteId) { BattleLoadSubstituteOrMonSpriteGfx(battler, loadMonSprite); StartSpriteAnim(&gSprites[spriteId], 0); @@ -1051,19 +1049,19 @@ void LoadBattleMonGfxAndAnimate(u8 battler, bool8 loadMonSprite, u8 spriteId) gSprites[spriteId].y = GetBattlerSpriteDefault_Y(battler); } -void TrySetBehindSubstituteSpriteBit(u8 battler, enum Move move) +void TrySetBehindSubstituteSpriteBit(enum BattlerId battler, enum Move move) { enum BattleMoveEffects effect = GetMoveEffect(move); if (effect == EFFECT_SUBSTITUTE || effect == EFFECT_SHED_TAIL) gBattleSpritesDataPtr->battlerData[battler].behindSubstitute = 1; } -void ClearBehindSubstituteBit(u8 battler) +void ClearBehindSubstituteBit(enum BattlerId battler) { gBattleSpritesDataPtr->battlerData[battler].behindSubstitute = 0; } -void HandleLowHpMusicChange(struct Pokemon *mon, u8 battler) +void HandleLowHpMusicChange(struct Pokemon *mon, enum BattlerId battler) { u16 hp = GetMonData(mon, MON_DATA_HP); u16 maxHP = GetMonData(mon, MON_DATA_MAX_HP); @@ -1095,7 +1093,7 @@ void HandleLowHpMusicChange(struct Pokemon *mon, u8 battler) void BattleStopLowHpSound(void) { - u8 playerBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId playerBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); gBattleSpritesDataPtr->battlerData[playerBattler].lowHpSong = 0; if (IsDoubleBattle()) @@ -1116,8 +1114,8 @@ void HandleBattleLowHpMusicChange(void) { if (gMain.inBattle) { - u8 playerBattler1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u8 playerBattler2 = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + enum BattlerId playerBattler1 = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId playerBattler2 = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); u8 battler1PartyId = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[playerBattler1]); u8 battler2PartyId = GetPartyIdFromBattlePartyId(gBattlerPartyIndexes[playerBattler2]); @@ -1130,9 +1128,7 @@ void HandleBattleLowHpMusicChange(void) void SetBattlerSpriteAffineMode(u8 affineMode) { - s32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsBattlerSpritePresent(i)) { @@ -1157,7 +1153,7 @@ void SetBattlerSpriteAffineMode(u8 affineMode) #define SPRITE_SIDE_LEFT 0 #define SPRITE_SIDE_RIGHT 1 -void CreateEnemyShadowSprite(u32 battler) +void CreateEnemyShadowSprite(enum BattlerId battler) { if (B_ENEMY_MON_SHADOW_STYLE >= GEN_4 && P_GBA_STYLE_SPECIES_GFX == FALSE) { @@ -1210,8 +1206,8 @@ void CreateEnemyShadowSprite(u32 battler) void LoadAndCreateEnemyShadowSprites(void) { - u8 battler; - u32 i; + enum BattlerId battler; + enum BattlerId i; if (B_ENEMY_MON_SHADOW_STYLE >= GEN_4 && P_GBA_STYLE_SPECIES_GFX == FALSE) { @@ -1254,7 +1250,7 @@ void SpriteCB_EnemyShadow(struct Sprite *shadowSprite) } bool8 invisible = FALSE; - u8 battler = shadowSprite->tBattlerId; + enum BattlerId battler = shadowSprite->tBattlerId; struct Sprite *battlerSprite = &gSprites[gBattlerSpriteIds[battler]]; u16 transformSpecies = SanitizeSpeciesId(gBattleSpritesDataPtr->battlerData[battler].transformSpecies); @@ -1311,7 +1307,7 @@ void SpriteCB_SetInvisible(struct Sprite *sprite) sprite->invisible = TRUE; } -void SetBattlerShadowSpriteCallback(u8 battler, u16 species) +void SetBattlerShadowSpriteCallback(enum BattlerId battler, u16 species) { if (B_ENEMY_MON_SHADOW_STYLE >= GEN_4 && P_GBA_STYLE_SPECIES_GFX == FALSE) { @@ -1361,7 +1357,7 @@ void SetBattlerShadowSpriteCallback(u8 battler, u16 species) } } -void HideBattlerShadowSprite(u8 battler) +void HideBattlerShadowSprite(enum BattlerId battler) { gSprites[gBattleSpritesDataPtr->healthBoxesData[battler].shadowSpriteIdPrimary].callback = SpriteCB_SetInvisible; if (B_ENEMY_MON_SHADOW_STYLE >= GEN_4 && P_GBA_STYLE_SPECIES_GFX == FALSE) @@ -1392,7 +1388,7 @@ void FillAroundBattleWindows(void) } } -void ClearTemporarySpeciesSpriteData(u32 battler, bool32 dontClearTransform, bool32 dontClearSubstitute) +void ClearTemporarySpeciesSpriteData(enum BattlerId battler, bool32 dontClearTransform, bool32 dontClearSubstitute) { if (!dontClearTransform) gBattleSpritesDataPtr->battlerData[battler].transformSpecies = SPECIES_NONE; diff --git a/src/battle_gimmick.c b/src/battle_gimmick.c index dec65c2bb1..26d189efec 100644 --- a/src/battle_gimmick.c +++ b/src/battle_gimmick.c @@ -19,11 +19,10 @@ // Populates gBattleStruct->gimmick.usableGimmick for each battler. void AssignUsableGimmicks(void) { - u32 battler, gimmick; - for (battler = 0; battler < gBattlersCount; ++battler) + for (enum BattlerId battler = 0; battler < gBattlersCount; ++battler) { gBattleStruct->gimmick.usableGimmick[battler] = GIMMICK_NONE; - for (gimmick = 0; gimmick < GIMMICKS_COUNT; ++gimmick) + for (enum Gimmick gimmick = 0; gimmick < GIMMICKS_COUNT; ++gimmick) { if (CanActivateGimmick(battler, gimmick)) { @@ -35,13 +34,13 @@ void AssignUsableGimmicks(void) } // Returns whether a battler is able to use a gimmick. Checks consumption and gimmick specific functions. -bool32 CanActivateGimmick(u32 battler, enum Gimmick gimmick) +bool32 CanActivateGimmick(enum BattlerId battler, enum Gimmick gimmick) { return gGimmicksInfo[gimmick].CanActivate != NULL && gGimmicksInfo[gimmick].CanActivate(battler); } // Returns whether the player has a gimmick selected while in the move selection menu. -bool32 IsGimmickSelected(u32 battler, enum Gimmick gimmick) +bool32 IsGimmickSelected(enum BattlerId battler, enum Gimmick gimmick) { // There's no player select in tests, but some gimmicks need to test choice before they are fully activated. #if TESTING @@ -52,26 +51,26 @@ bool32 IsGimmickSelected(u32 battler, enum Gimmick gimmick) } // Sets a battler as having a gimmick active using their party index. -void SetActiveGimmick(u32 battler, enum Gimmick gimmick) +void SetActiveGimmick(enum BattlerId battler, enum Gimmick gimmick) { gBattleStruct->gimmick.activeGimmick[GetBattlerSide(battler)][gBattlerPartyIndexes[battler]] = gimmick; } // Returns a battler's active gimmick, if any. -enum Gimmick GetActiveGimmick(u32 battler) +enum Gimmick GetActiveGimmick(enum BattlerId battler) { return gBattleStruct->gimmick.activeGimmick[GetBattlerSide(battler)][gBattlerPartyIndexes[battler]]; } // Returns whether a trainer mon is intended to use an unrestrictive gimmick via .useGimmick (i.e Tera). -bool32 ShouldTrainerBattlerUseGimmick(u32 battler, enum Gimmick gimmick) +bool32 ShouldTrainerBattlerUseGimmick(enum BattlerId battler, enum Gimmick gimmick) { // There are no trainer party settings in battles, but the AI needs to know which gimmick to use. #if TESTING return gimmick == TestRunner_Battle_GetChosenGimmick(GetBattlerTrainer(battler), gBattlerPartyIndexes[battler]); #else // The player can bypass these checks because they can choose through the controller. - if (IsOnPlayerSide(battler) && !((gBattleTypeFlags & BATTLE_TYPE_MULTI) && battler == B_POSITION_PLAYER_RIGHT)) + if (IsOnPlayerSide(battler) && !((gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)) { return TRUE; } @@ -89,11 +88,11 @@ bool32 ShouldTrainerBattlerUseGimmick(u32 battler, enum Gimmick gimmick) } // Returns whether a trainer has used a gimmick during a battle. -bool32 HasTrainerUsedGimmick(u32 battler, enum Gimmick gimmick) +bool32 HasTrainerUsedGimmick(enum BattlerId battler, enum Gimmick gimmick) { if (IsDoubleBattle() && (IsPartnerMonFromSameTrainer(battler) || (gimmick == GIMMICK_DYNAMAX))) { - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId partner = BATTLE_PARTNER(battler); if (gBattleStruct->gimmick.activated[partner][gimmick] || ((gBattleStruct->gimmick.toActivate & (1u << partner)) && gBattleStruct->gimmick.usableGimmick[partner] == gimmick)) return TRUE; @@ -103,7 +102,7 @@ bool32 HasTrainerUsedGimmick(u32 battler, enum Gimmick gimmick) } // Sets a gimmick as used by a trainer with checks for Multi Battles. -void SetGimmickAsActivated(u32 battler, enum Gimmick gimmick) +void SetGimmickAsActivated(enum BattlerId battler, enum Gimmick gimmick) { gBattleStruct->gimmick.activated[battler][gimmick] = TRUE; if (IsDoubleBattle() && (IsPartnerMonFromSameTrainer(battler) || (gimmick == GIMMICK_DYNAMAX))) @@ -128,7 +127,7 @@ void ChangeGimmickTriggerSprite(u32 spriteId, u32 animId) StartSpriteAnim(&gSprites[spriteId], animId); } -void CreateGimmickTriggerSprite(u32 battler) +void CreateGimmickTriggerSprite(enum BattlerId battler) { const struct GimmickInfo * gimmick = &gGimmicksInfo[gBattleStruct->gimmick.usableGimmick[battler]]; @@ -173,7 +172,7 @@ bool32 IsGimmickTriggerSpriteActive(void) return FALSE; } -bool32 IsGimmickTriggerSpriteMatchingBattler(u32 battler) +bool32 IsGimmickTriggerSpriteMatchingBattler(enum BattlerId battler) { if (battler == gSprites[gBattleStruct->gimmick.triggerSpriteId].tBattler) return TRUE; @@ -274,7 +273,7 @@ void LoadIndicatorSpritesGfx(void) static void SpriteCb_GimmickIndicator(struct Sprite *sprite) { - u32 battler = sprite->tBattler; + enum BattlerId battler = sprite->tBattler; sprite->x = gSprites[gHealthboxSpriteIds[battler]].x + sprite->tPosX + sprite->tLevelXDelta; sprite->x2 = gSprites[gHealthboxSpriteIds[battler]].x2; @@ -286,7 +285,7 @@ static inline u32 GetIndicatorSpriteId(u32 healthboxId) return gBattleStruct->gimmick.indicatorSpriteId[gSprites[healthboxId].hMain_Battler]; } -const u32 *GetIndicatorSpriteSrc(u32 battler) +const u32 *GetIndicatorSpriteSrc(enum BattlerId battler) { u32 gimmick = GetActiveGimmick(battler); @@ -311,7 +310,7 @@ const u32 *GetIndicatorSpriteSrc(u32 battler) } } -u32 GetIndicatorPalTag(u32 battler) +u32 GetIndicatorPalTag(enum BattlerId battler) { u32 gimmick = GetActiveGimmick(battler); if (IsBattlerPrimalReverted(battler)) @@ -326,7 +325,7 @@ u32 GetIndicatorPalTag(u32 battler) void UpdateIndicatorVisibilityAndType(u32 healthboxId, bool32 invisible) { - u32 battler = gSprites[healthboxId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxId].hMain_Battler; u32 palTag = GetIndicatorPalTag(battler); struct Sprite *sprite = &gSprites[GetIndicatorSpriteId(healthboxId)]; @@ -378,7 +377,7 @@ static const s8 sIndicatorPositions[][2] = [B_POSITION_OPPONENT_RIGHT] = {40, -9}, }; -void CreateIndicatorSprite(u32 battler) +void CreateIndicatorSprite(enum BattlerId battler) { enum BattlerPosition position; u32 spriteId; diff --git a/src/battle_hold_effects.c b/src/battle_hold_effects.c index fd0a1d3935..42903c2421 100644 --- a/src/battle_hold_effects.c +++ b/src/battle_hold_effects.c @@ -36,7 +36,7 @@ bool32 IsForceTriggerItemActivation(enum HoldEffect holdEffect) || gHoldEffectsInfo[holdEffect].onHpThreshold; } -static enum ItemEffect TryDoublePrize(u32 battler) +static enum ItemEffect TryDoublePrize(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -49,7 +49,7 @@ static enum ItemEffect TryDoublePrize(u32 battler) return effect; } -enum ItemEffect TryBoosterEnergy(u32 battler, enum Ability ability) +enum ItemEffect TryBoosterEnergy(enum BattlerId battler, enum Ability ability) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -71,7 +71,7 @@ enum ItemEffect TryBoosterEnergy(u32 battler, enum Ability ability) return effect; } -static enum ItemEffect TryRoomService(u32 battler) +static enum ItemEffect TryRoomService(enum BattlerId battler) { if (gFieldStatuses & STATUS_FIELD_TRICK_ROOM && CompareStat(battler, STAT_SPEED, MIN_STAT_STAGE, CMP_GREATER_THAN, GetBattlerAbility(battler))) { @@ -87,7 +87,7 @@ static enum ItemEffect TryRoomService(u32 battler) return ITEM_NO_EFFECT; } -enum ItemEffect TryHandleSeed(u32 battler, u32 terrainFlag, enum Stat statId) +enum ItemEffect TryHandleSeed(enum BattlerId battler, u32 terrainFlag, enum Stat statId) { if (gFieldStatuses & terrainFlag && CompareStat(battler, statId, MAX_STAT_STAGE, CMP_LESS_THAN, GetBattlerAbility(battler))) { @@ -101,7 +101,7 @@ enum ItemEffect TryHandleSeed(u32 battler, u32 terrainFlag, enum Stat statId) return ITEM_NO_EFFECT; } -static enum ItemEffect TryTerrainSeeds(u32 battler, enum Item item) +static enum ItemEffect TryTerrainSeeds(enum BattlerId battler, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -124,7 +124,7 @@ static enum ItemEffect TryTerrainSeeds(u32 battler, enum Item item) return effect; } -static bool32 CanBeInfinitelyConfused(u32 battler) +static bool32 CanBeInfinitelyConfused(enum BattlerId battler) { enum Ability ability = GetBattlerAbility(battler); if (ability == ABILITY_OWN_TEMPO @@ -134,7 +134,7 @@ static bool32 CanBeInfinitelyConfused(u32 battler) return TRUE; } -static enum ItemEffect TryBerserkGene(u32 battler) +static enum ItemEffect TryBerserkGene(enum BattlerId battler) { if (CanBeInfinitelyConfused(battler)) gBattleMons[battler].volatiles.infiniteConfusion = TRUE; @@ -146,7 +146,7 @@ static enum ItemEffect TryBerserkGene(u32 battler) return ITEM_STATS_CHANGE; } -static enum ItemEffect RestoreWhiteHerbStats(u32 battler, ActivationTiming timing) +static enum ItemEffect RestoreWhiteHerbStats(enum BattlerId battler, ActivationTiming timing) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -169,7 +169,7 @@ static enum ItemEffect RestoreWhiteHerbStats(u32 battler, ActivationTiming timin return effect; } -static enum ItemEffect TryConsumeMirrorHerb(u32 battler) +static enum ItemEffect TryConsumeMirrorHerb(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -184,7 +184,7 @@ static enum ItemEffect TryConsumeMirrorHerb(u32 battler) return effect; } -static enum ItemEffect TryKingsRock(u32 battlerAtk, u32 battlerDef, enum Item item) +static enum ItemEffect TryKingsRock(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -210,7 +210,7 @@ static enum ItemEffect TryKingsRock(u32 battlerAtk, u32 battlerDef, enum Item it return effect; } -static enum ItemEffect TryAirBalloon(u32 battler, ActivationTiming timing) +static enum ItemEffect TryAirBalloon(enum BattlerId battler, ActivationTiming timing) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -232,7 +232,7 @@ static enum ItemEffect TryAirBalloon(u32 battler, ActivationTiming timing) return effect; } -static enum ItemEffect TryRockyHelmet(u32 battlerDef, u32 battlerAtk, enum Item item) +static enum ItemEffect TryRockyHelmet(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Ability ability = GetBattlerAbility(battlerAtk); @@ -251,7 +251,7 @@ static enum ItemEffect TryRockyHelmet(u32 battlerDef, u32 battlerAtk, enum Item return effect; } -static enum ItemEffect TryWeaknessPolicy(u32 battlerDef) +static enum ItemEffect TryWeaknessPolicy(enum BattlerId battlerDef) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -266,7 +266,7 @@ static enum ItemEffect TryWeaknessPolicy(u32 battlerDef) return effect; } -static enum ItemEffect TrySnowball(u32 battlerDef) +static enum ItemEffect TrySnowball(enum BattlerId battlerDef) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -282,7 +282,7 @@ static enum ItemEffect TrySnowball(u32 battlerDef) return effect; } -static enum ItemEffect TryLuminousMoss(u32 battlerDef) +static enum ItemEffect TryLuminousMoss(enum BattlerId battlerDef) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -298,7 +298,7 @@ static enum ItemEffect TryLuminousMoss(u32 battlerDef) return effect; } -static enum ItemEffect TryCellBattery(u32 battlerDef) +static enum ItemEffect TryCellBattery(enum BattlerId battlerDef) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -314,7 +314,7 @@ static enum ItemEffect TryCellBattery(u32 battlerDef) return effect; } -static enum ItemEffect TryAbsorbBulb(u32 battlerDef) +static enum ItemEffect TryAbsorbBulb(enum BattlerId battlerDef) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -330,7 +330,7 @@ static enum ItemEffect TryAbsorbBulb(u32 battlerDef) return effect; } -static enum ItemEffect TryJabocaBerry(u32 battlerDef, u32 battlerAtk, enum Item item) +static enum ItemEffect TryJabocaBerry(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -352,7 +352,7 @@ static enum ItemEffect TryJabocaBerry(u32 battlerDef, u32 battlerAtk, enum Item return effect; } -static enum ItemEffect TryRowapBerry(u32 battlerDef, u32 battlerAtk, enum Item item) +static enum ItemEffect TryRowapBerry(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -374,7 +374,7 @@ static enum ItemEffect TryRowapBerry(u32 battlerDef, u32 battlerAtk, enum Item i return effect; } -static enum ItemEffect TrySetEnigmaBerry(u32 battlerDef, u32 battlerAtk) +static enum ItemEffect TrySetEnigmaBerry(enum BattlerId battlerDef, enum BattlerId battlerAtk) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -395,7 +395,7 @@ static enum ItemEffect TrySetEnigmaBerry(u32 battlerDef, u32 battlerAtk) return effect; } -static enum ItemEffect TryBlunderPolicy(u32 battlerAtk) +static enum ItemEffect TryBlunderPolicy(enum BattlerId battlerAtk) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -412,7 +412,7 @@ static enum ItemEffect TryBlunderPolicy(u32 battlerAtk) return effect; } -static enum ItemEffect TryMentalHerb(u32 battler) +static enum ItemEffect TryMentalHerb(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -472,7 +472,7 @@ static enum ItemEffect TryMentalHerb(u32 battler) return effect; } -static enum ItemEffect TryThroatSpray(u32 battlerAtk) +static enum ItemEffect TryThroatSpray(enum BattlerId battlerAtk) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -491,7 +491,7 @@ static enum ItemEffect TryThroatSpray(u32 battlerAtk) return effect; } -static enum ItemEffect DamagedStatBoostBerryEffect(u32 battlerDef, u32 battlerAtk, enum Stat statId, enum DamageCategory category) +static enum ItemEffect DamagedStatBoostBerryEffect(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Stat statId, enum DamageCategory category) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -517,7 +517,7 @@ static enum ItemEffect DamagedStatBoostBerryEffect(u32 battlerDef, u32 battlerAt return effect; } -static enum ItemEffect TryShellBell(u32 battlerAtk) +static enum ItemEffect TryShellBell(enum BattlerId battlerAtk) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -538,7 +538,7 @@ static enum ItemEffect TryShellBell(u32 battlerAtk) return effect; } -static enum ItemEffect TryLifeOrb(u32 battlerAtk) +static enum ItemEffect TryLifeOrb(enum BattlerId battlerAtk) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -557,7 +557,7 @@ static enum ItemEffect TryLifeOrb(u32 battlerAtk) return effect; } -static enum ItemEffect TryStickyBarbOnTargetHit(u32 battlerDef, u32 battlerAtk, enum Item item) +static enum ItemEffect TryStickyBarbOnTargetHit(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -578,7 +578,7 @@ static enum ItemEffect TryStickyBarbOnTargetHit(u32 battlerDef, u32 battlerAtk, return effect; } -static enum ItemEffect TryStickyBarbOnEndTurn(u32 battler, enum Item item) +static enum ItemEffect TryStickyBarbOnEndTurn(enum BattlerId battler, enum Item item) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -593,7 +593,7 @@ static enum ItemEffect TryStickyBarbOnEndTurn(u32 battler, enum Item item) return effect; } -static enum ItemEffect TryToxicOrb(u32 battler) +static enum ItemEffect TryToxicOrb(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Ability ability = GetBattlerAbility(battler); @@ -608,7 +608,7 @@ static enum ItemEffect TryToxicOrb(u32 battler) return effect; } -static enum ItemEffect TryFlameOrb(u32 battler) +static enum ItemEffect TryFlameOrb(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Ability ability = GetBattlerAbility(battler); @@ -623,7 +623,7 @@ static enum ItemEffect TryFlameOrb(u32 battler) return effect; } -static enum ItemEffect TryLeftovers(u32 battler, enum HoldEffect holdEffect) +static enum ItemEffect TryLeftovers(enum BattlerId battler, enum HoldEffect holdEffect) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -639,7 +639,7 @@ static enum ItemEffect TryLeftovers(u32 battler, enum HoldEffect holdEffect) return effect; } -static enum ItemEffect TryBlackSludgeDamage(u32 battler, enum HoldEffect holdEffect) +static enum ItemEffect TryBlackSludgeDamage(enum BattlerId battler, enum HoldEffect holdEffect) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -654,7 +654,7 @@ static enum ItemEffect TryBlackSludgeDamage(u32 battler, enum HoldEffect holdEff return effect; } -static enum ItemEffect TryCureParalysis(u32 battler) +static enum ItemEffect TryCureParalysis(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -669,7 +669,7 @@ static enum ItemEffect TryCureParalysis(u32 battler) return effect; } -static enum ItemEffect TryCurePoison(u32 battler) +static enum ItemEffect TryCurePoison(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -684,7 +684,7 @@ static enum ItemEffect TryCurePoison(u32 battler) return effect; } -static enum ItemEffect TryCureBurn(u32 battler) +static enum ItemEffect TryCureBurn(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -699,7 +699,7 @@ static enum ItemEffect TryCureBurn(u32 battler) return effect; } -static enum ItemEffect TryCureFreezeOrFrostbite(u32 battler) +static enum ItemEffect TryCureFreezeOrFrostbite(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -722,7 +722,7 @@ static enum ItemEffect TryCureFreezeOrFrostbite(u32 battler) return effect; } -static enum ItemEffect TryCureSleep(u32 battler) +static enum ItemEffect TryCureSleep(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -739,7 +739,7 @@ static enum ItemEffect TryCureSleep(u32 battler) return effect; } -static enum ItemEffect TryCureConfusion(u32 battler) +static enum ItemEffect TryCureConfusion(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -753,7 +753,7 @@ static enum ItemEffect TryCureConfusion(u32 battler) return effect; } -static enum ItemEffect TryCureAnyStatus(u32 battler) +static enum ItemEffect TryCureAnyStatus(enum BattlerId battler) { enum ItemEffect effect = ITEM_NO_EFFECT; u32 string = 0; @@ -811,7 +811,7 @@ enum HealAmount PERCENT_HEAL_AMOUNT, }; -static u32 ItemHealHp(u32 battler, enum Item itemId, enum HealAmount percentHeal) +static u32 ItemHealHp(enum BattlerId battler, enum Item itemId, enum HealAmount percentHeal) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Ability ability = GetBattlerAbility(battler); @@ -837,7 +837,7 @@ static u32 ItemHealHp(u32 battler, enum Item itemId, enum HealAmount percentHeal return effect; } -static u32 ItemRestorePp(u32 battler, enum Item itemId) +static u32 ItemRestorePp(enum BattlerId battler, enum Item itemId) { enum ItemEffect effect = ITEM_NO_EFFECT; struct Pokemon *mon = GetBattlerMon(battler); @@ -877,7 +877,7 @@ static u32 ItemRestorePp(u32 battler, enum Item itemId) return effect; } -static enum ItemEffect HealConfuseBerry(u32 battler, enum Item itemId, enum Flavor flavorId) +static enum ItemEffect HealConfuseBerry(enum BattlerId battler, enum Item itemId, enum Flavor flavorId) { enum ItemEffect effect = ITEM_NO_EFFECT; u32 hpFraction = B_CONFUSE_BERRIES_HEAL >= GEN_7 ? 4 : 2; @@ -900,7 +900,7 @@ static enum ItemEffect HealConfuseBerry(u32 battler, enum Item itemId, enum Flav return effect; } -static enum ItemEffect StatRaiseBerry(u32 battler, enum Item itemId, enum Stat statId) +static enum ItemEffect StatRaiseBerry(enum BattlerId battler, enum Item itemId, enum Stat statId) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Ability ability = GetBattlerAbility(battler); @@ -919,7 +919,7 @@ static enum ItemEffect StatRaiseBerry(u32 battler, enum Item itemId, enum Stat s return effect; } -static enum ItemEffect CriticalHitRatioUp(u32 battler, enum Item itemId) +static enum ItemEffect CriticalHitRatioUp(enum BattlerId battler, enum Item itemId) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -935,7 +935,7 @@ static enum ItemEffect CriticalHitRatioUp(u32 battler, enum Item itemId) return effect; } -static enum ItemEffect RandomStatRaiseBerry(u32 battler, enum Item itemId) +static enum ItemEffect RandomStatRaiseBerry(enum BattlerId battler, enum Item itemId) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Stat stat; @@ -973,7 +973,7 @@ static enum ItemEffect RandomStatRaiseBerry(u32 battler, enum Item itemId) return effect; } -static enum ItemEffect TrySetMicleBerry(u32 battler, enum Item itemId) +static enum ItemEffect TrySetMicleBerry(enum BattlerId battler, enum Item itemId) { enum ItemEffect effect = ITEM_NO_EFFECT; @@ -986,7 +986,7 @@ static enum ItemEffect TrySetMicleBerry(u32 battler, enum Item itemId) return effect; } -enum ItemEffect ItemBattleEffects(u32 itemBattler, u32 battler, enum HoldEffect holdEffect, ActivationTiming timing) +enum ItemEffect ItemBattleEffects(enum BattlerId itemBattler, enum BattlerId battler, enum HoldEffect holdEffect, ActivationTiming timing) { enum ItemEffect effect = ITEM_NO_EFFECT; enum Item item; diff --git a/src/battle_interface.c b/src/battle_interface.c index 56083fc8de..d780c8c525 100644 --- a/src/battle_interface.c +++ b/src/battle_interface.c @@ -191,10 +191,10 @@ static void SpriteCB_StatusSummaryBalls_Enter(struct Sprite *); static void SpriteCB_StatusSummaryBalls_Exit(struct Sprite *); static void SpriteCB_StatusSummaryBalls_OnSwitchout(struct Sprite *); -static u8 GetStatusIconForBattlerId(u8, u8); +static u8 GetStatusIconForBattlerId(u8, enum BattlerId); static s32 CalcNewBarValue(s32, s32, s32, s32 *, u8, u16); static u8 GetScaledExpFraction(s32, s32, s32, u8); -static void MoveBattleBarGraphically(u8, u8); +static void MoveBattleBarGraphically(enum BattlerId, u8); static u8 CalcBarFilledPixels(s32, s32, s32, s32 *, u8 *, u8); static void SpriteCb_AbilityPopUp(struct Sprite *); @@ -594,7 +594,7 @@ static const union TextColor sHealthBoxTextColor = // This function is here to cover a specific case - one player's mon in a 2 vs 1 double battle. In this scenario - display singles layout. // The same goes for a 2 vs 1 where opponent has only one pokemon. -enum BattleCoordTypes GetBattlerCoordsIndex(u32 battler) +enum BattleCoordTypes GetBattlerCoordsIndex(enum BattlerId battler) { if (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT && gPlayerPartyCount == 1 && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) return BATTLE_COORDS_SINGLES; @@ -606,7 +606,7 @@ enum BattleCoordTypes GetBattlerCoordsIndex(u32 battler) return BATTLE_COORDS_SINGLES; } -u8 CreateBattlerHealthboxSprites(u8 battler) +u8 CreateBattlerHealthboxSprites(enum BattlerId battler) { s16 data6 = 0; u8 healthboxLeftSpriteId, healthboxRightSpriteId; @@ -755,7 +755,7 @@ static void SpriteCB_HealthBoxOther(struct Sprite *sprite) sprite->y2 = gSprites[healthboxMainSpriteId].y2; } -void SetBattleBarStruct(u8 battler, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue) +void SetBattleBarStruct(enum BattlerId battler, u8 healthboxSpriteId, s32 maxVal, s32 oldVal, s32 receivedValue) { gBattleSpritesDataPtr->battleBars[battler].healthboxSpriteId = healthboxSpriteId; gBattleSpritesDataPtr->battleBars[battler].maxValue = maxVal; @@ -809,9 +809,7 @@ static void TryToggleHealboxVisibility(u32 priority, u32 healthboxLeftSpriteId, void UpdateOamPriorityInAllHealthboxes(u8 priority, bool32 hideHPBoxes) { - s32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { u8 healthboxLeftSpriteId = gHealthboxSpriteIds[i]; u8 healthboxRightSpriteId = gSprites[gHealthboxSpriteIds[i]].oam.affineParam; @@ -844,7 +842,7 @@ static const s16 sBattlerHealthboxCoords[BATTLE_COORDS_COUNT][MAX_BATTLERS_COUNT }, }; -void GetBattlerHealthboxCoords(u8 battler, s16 *x, s16 *y) +void GetBattlerHealthboxCoords(enum BattlerId battler, s16 *x, s16 *y) { enum BattlerPosition position = GetBattlerPosition(battler); enum BattleCoordTypes index = GetBattlerCoordsIndex(battler); @@ -853,7 +851,7 @@ void GetBattlerHealthboxCoords(u8 battler, s16 *x, s16 *y) *y = sBattlerHealthboxCoords[index][position][1]; } -void InitBattlerHealthboxCoords(u8 battler) +void InitBattlerHealthboxCoords(enum BattlerId battler) { s16 x, y; @@ -864,7 +862,7 @@ void InitBattlerHealthboxCoords(u8 battler) static void UpdateLvlInHealthbox(u8 healthboxSpriteId, u8 lvl) { u8 text[16]; - u8 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; u32 spriteId = gSprites[healthboxSpriteId].oam.affineParam; // Don't print Lv char if mon has a gimmick with an indicator active. @@ -939,7 +937,7 @@ static void UpdateOpponentHpTextDoubles(u32 healthboxSpriteId, u32 barSpriteId, { u8 text[32], *txtPtr; u32 i, var; - u32 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; if (gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars) // don't print text if only bars are visible { @@ -985,7 +983,7 @@ static void UpdateOpponentHpTextSingles(u32 healthboxSpriteId, s16 value, u32 ma { u8 text[32]; u32 var, i; - u32 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; memcpy(text, sEmptyWhiteText_GrayHighlight, sizeof(sEmptyWhiteText_GrayHighlight)); if (gBattleSpritesDataPtr->battlerData[battler].hpNumbersNoBars) // don't print text if only bars are visible @@ -1009,7 +1007,7 @@ static void UpdateOpponentHpTextSingles(u32 healthboxSpriteId, s16 value, u32 ma void UpdateHpTextInHealthbox(u32 healthboxSpriteId, u32 maxOrCurrent, s16 currHp, s16 maxHp) { - u32 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; switch (GetBattlerCoordsIndex(battler)) { default: @@ -1036,7 +1034,7 @@ void UpdateHpTextInHealthbox(u32 healthboxSpriteId, u32 maxOrCurrent, s16 currHp static void UpdateHpTextInHealthboxInDoubles(u32 healthboxSpriteId, u32 maxOrCurrent, s16 currHp, s16 maxHp) { u32 barSpriteId = gSprites[healthboxSpriteId].data[5]; - u32 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; if (IsOnPlayerSide(battler)) { @@ -1126,9 +1124,9 @@ static void PrintSafariMonInfo(u8 healthboxSpriteId, struct Pokemon *mon) void SwapHpBarsWithHpText(void) { - u32 healthBarSpriteId, i; + u32 healthBarSpriteId; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { struct Pokemon *mon = GetBattlerMon(i); if (gSprites[gHealthboxSpriteIds[i]].callback == SpriteCallbackDummy @@ -1205,7 +1203,7 @@ void SwapHpBarsWithHpText(void) #define tIsBattleStart data[10] #define tBlend data[15] -u8 CreatePartyStatusSummarySprites(u8 battler, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart) +u8 CreatePartyStatusSummarySprites(enum BattlerId battler, struct HpAndStatus *partyInfo, bool8 skipPlayer, bool8 isBattleStart) { bool8 isOpponent; s16 bar_X, bar_Y, bar_pos2_X, bar_data0; @@ -1431,7 +1429,7 @@ void Task_HidePartyStatusSummary(u8 taskId) u8 ballIconSpriteIds[PARTY_SIZE]; bool8 isBattleStart; u8 summaryBarSpriteId; - u8 battler; + enum BattlerId battler; s32 i; isBattleStart = gTasks[taskId].tIsBattleStart; @@ -1500,7 +1498,7 @@ static void Task_HidePartyStatusSummary_BattleStart_2(u8 taskId) u8 ballIconSpriteIds[PARTY_SIZE]; s32 i; - u8 battler = gTasks[taskId].tBattler; + enum BattlerId battler = gTasks[taskId].tBattler; if (--gTasks[taskId].tBlend == -1) { u8 summaryBarSpriteId = gTasks[taskId].tSummaryBarSpriteId; @@ -1538,7 +1536,7 @@ static void Task_HidePartyStatusSummary_DuringBattle(u8 taskId) { u8 ballIconSpriteIds[PARTY_SIZE]; s32 i; - u8 battler = gTasks[taskId].tBattler; + enum BattlerId battler = gTasks[taskId].tBattler; if (--gTasks[taskId].tBlend >= 0) { @@ -1727,7 +1725,8 @@ static void UpdateNickInHealthbox(u8 healthboxSpriteId, struct Pokemon *mon) static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus) { - u8 battler, healthBarSpriteId; + enum BattlerId battler; + u8 healthBarSpriteId; if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) return; @@ -1751,7 +1750,8 @@ static void TryAddPokeballIconToHealthbox(u8 healthboxSpriteId, bool8 noStatus) static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId) { s32 i; - u8 battler, healthBarSpriteId; + enum BattlerId battler; + u8 healthBarSpriteId; u32 status, pltAdder; const u8 *statusGfxPtr; s16 tileNumAdder; @@ -1838,7 +1838,7 @@ static void UpdateStatusIconInHealthbox(u8 healthboxSpriteId) TryAddPokeballIconToHealthbox(healthboxSpriteId, FALSE); } -static u8 GetStatusIconForBattlerId(u8 statusElementId, u8 battler) +static u8 GetStatusIconForBattlerId(u8 statusElementId, enum BattlerId battler) { u8 ret = statusElementId; @@ -1948,7 +1948,7 @@ static void UpdateLeftNoOfBallsTextOnHealthbox(u8 healthboxSpriteId) void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elementId) { - u32 battler = gSprites[healthboxSpriteId].hMain_Battler; + enum BattlerId battler = gSprites[healthboxSpriteId].hMain_Battler; s32 maxHp = GetMonData(mon, MON_DATA_MAX_HP); s32 currHp = GetMonData(mon, MON_DATA_HP); @@ -2028,7 +2028,7 @@ void UpdateHealthboxAttribute(u8 healthboxSpriteId, struct Pokemon *mon, u8 elem #define B_EXPBAR_PIXELS 64 #define B_HEALTHBAR_PIXELS 48 -s32 MoveBattleBar(u8 battler, u8 healthboxSpriteId, u8 whichBar, u8 unused) +s32 MoveBattleBar(enum BattlerId battler, u8 healthboxSpriteId, u8 whichBar, u8 unused) { s32 currentBarValue; @@ -2066,7 +2066,7 @@ s32 MoveBattleBar(u8 battler, u8 healthboxSpriteId, u8 whichBar, u8 unused) return currentBarValue; } -static void MoveBattleBarGraphically(u8 battler, u8 whichBar) +static void MoveBattleBarGraphically(enum BattlerId battler, u8 whichBar) { u8 array[8]; u8 level; @@ -2470,7 +2470,7 @@ static void TextIntoAbilityPopUp(void *dest, u8 *windowTileData, s32 windowWidth #undef PIXELS } -static void PrintOnAbilityPopUp(const u8 *str, u8 *spriteTileData1, u8 *spriteTileData2, u32 x, u32 y, u32 bgColor, u32 fgColor, u32 shadowColor, u32 printNickname, u32 battler) +static void PrintOnAbilityPopUp(const u8 *str, u8 *spriteTileData1, u8 *spriteTileData2, u32 x, u32 y, u32 bgColor, u32 fgColor, u32 shadowColor, u32 printNickname, enum BattlerId battler) { u32 windowId, fontId; u8 *windowTileData = AddTextPrinterAndCreateWindowOnAbilityPopUp(str, x, y, bgColor, fgColor, shadowColor, &windowId); @@ -2496,7 +2496,7 @@ static void PrintOnAbilityPopUp(const u8 *str, u8 *spriteTileData1, u8 *spriteTi RemoveWindow(windowId); } -static void PrintBattlerOnAbilityPopUp(u8 battler, u8 spriteId1, u8 spriteId2) +static void PrintBattlerOnAbilityPopUp(enum BattlerId battler, u8 spriteId1, u8 spriteId2) { u32 totalChar = 0, lastChar; struct Pokemon *illusionMon = GetIllusionMonPtr(battler); @@ -2541,7 +2541,7 @@ static void PrintAbilityOnAbilityPopUp(enum Ability ability, u8 spriteId1, u8 sp static inline bool32 IsAnyAbilityPopUpActive(void) { u32 activeAbilityPopUps = 0; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleStruct->battlerState[battler].activeAbilityPopUps) activeAbilityPopUps++; @@ -2550,7 +2550,7 @@ static inline bool32 IsAnyAbilityPopUpActive(void) return activeAbilityPopUps; } -void CreateAbilityPopUp(u8 battler, enum Ability ability, bool32 isDoubleBattle) +void CreateAbilityPopUp(enum BattlerId battler, enum Ability ability, bool32 isDoubleBattle) { u8 *spriteIds; u32 xSlide, tileTag; @@ -2613,7 +2613,7 @@ void CreateAbilityPopUp(u8 battler, enum Ability ability, bool32 isDoubleBattle) PrintAbilityOnAbilityPopUp(ability, spriteIds[0], spriteIds[1]); } -void UpdateAbilityPopup(u8 battler) +void UpdateAbilityPopup(enum BattlerId battler) { u8 *spriteIds = gBattleStruct->abilityPopUpSpriteIds[battler]; enum Ability ability = (gBattleScripting.abilityPopupOverwrite) ? gBattleScripting.abilityPopupOverwrite @@ -2688,7 +2688,7 @@ static void SpriteCb_AbilityPopUp(struct Sprite *sprite) } } -void DestroyAbilityPopUp(u8 battler) +void DestroyAbilityPopUp(enum BattlerId battler) { if (gBattleStruct->battlerState[battler].activeAbilityPopUps) { @@ -2701,7 +2701,7 @@ static void Task_FreeAbilityPopUpGfx(u8 taskId) { if (!IsAnyAbilityPopUpActive()) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (IndexOfSpriteTileTag(TAG_ABILITY_POP_UP_PLAYER1 + battler) != 0xFF) FreeSpriteTilesByTag(TAG_ABILITY_POP_UP_PLAYER1 + battler); diff --git a/src/battle_main.c b/src/battle_main.c index fc275cacba..cb169aed5f 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -112,7 +112,7 @@ static void TryDoEventsBeforeFirstTurn(void); static void HandleTurnActionSelectionState(void); static void RunTurnActionsFunctions(void); static void SetActionsAndBattlersTurnOrder(void); -static void UpdateBattlerPartyOrdersOnSwitch(u32 battler); +static void UpdateBattlerPartyOrdersOnSwitch(enum BattlerId battler); static bool8 AllAtActionConfirmed(void); static void TryChangeTurnOrder(void); static void TryChangingTurnOrderEffects(struct BattleCalcValues *calcValues, u32 *quickClawRandom, u32 *quickDrawRandom); @@ -157,8 +157,8 @@ EWRAM_DATA u8 gBattlersCount = 0; EWRAM_DATA u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gBattlerPositions[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gActionsByTurnOrder[MAX_BATTLERS_COUNT] = {0}; -EWRAM_DATA u8 gBattlerByTurnOrder[MAX_BATTLERS_COUNT] = {0}; -EWRAM_DATA u8 gBattlersBySpeed[MAX_BATTLERS_COUNT] = {0}; +EWRAM_DATA enum BattlerId gBattlerByTurnOrder[MAX_BATTLERS_COUNT] = {0}; +EWRAM_DATA enum BattlerId gBattlersBySpeed[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u8 gCurrentTurnActionNumber = 0; EWRAM_DATA u8 gCurrentActionFuncId = 0; EWRAM_DATA struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT] = {0}; @@ -171,11 +171,11 @@ EWRAM_DATA u16 gCalledMove = 0; EWRAM_DATA s32 gBideDmg[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA u16 gLastUsedItem = 0; EWRAM_DATA enum Ability gLastUsedAbility = 0; -EWRAM_DATA u8 gBattlerAttacker = 0; -EWRAM_DATA u8 gBattlerTarget = 0; -EWRAM_DATA u8 gBattlerFainted = 0; -EWRAM_DATA u8 gEffectBattler = 0; -EWRAM_DATA u8 gPotentialItemEffectBattler = 0; +EWRAM_DATA enum BattlerId gBattlerAttacker = 0; +EWRAM_DATA enum BattlerId gBattlerTarget = 0; +EWRAM_DATA enum BattlerId gBattlerFainted = 0; +EWRAM_DATA enum BattlerId gEffectBattler = 0; +EWRAM_DATA enum BattlerId gPotentialItemEffectBattler = 0; EWRAM_DATA u8 gAbsentBattlerFlags = 0; EWRAM_DATA u8 gMultiHitCounter = 0; EWRAM_DATA const u8 *gBattlescriptCurrInstr = NULL; @@ -233,7 +233,7 @@ EWRAM_DATA u16 gMoveToLearn = 0; EWRAM_DATA u32 gFieldStatuses = 0; EWRAM_DATA struct FieldTimer gFieldTimers = {0}; EWRAM_DATA u16 gBattleTurnCounter = 0; -EWRAM_DATA u8 gBattlerAbility = 0; +EWRAM_DATA enum BattlerId gBattlerAbility = 0; EWRAM_DATA struct QueuedStatBoost gQueuedStatBoosts[MAX_BATTLERS_COUNT] = {0}; EWRAM_DATA bool8 gHasFetchedBall = FALSE; EWRAM_DATA u16 gLastUsedBall = 0; @@ -709,7 +709,7 @@ static void SetAllPlayersBerryData(void) { s32 numPlayers; struct BattleEnigmaBerry *src; - u32 battler; + enum BattlerId battler; if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { @@ -2684,7 +2684,7 @@ void SpriteCallbackDummy_2(struct Sprite *sprite) void SpriteCB_FaintOpponentMon(struct Sprite *sprite) { - u8 battler = sprite->sBattler; + enum BattlerId battler = sprite->sBattler; u32 personality = GetMonData(GetBattlerMon(battler), MON_DATA_PERSONALITY); u16 species; u8 yOffset; @@ -2815,7 +2815,7 @@ void SpriteCB_FaintSlideAnim(struct Sprite *sprite) #define sBouncerSpriteId data[6] #define sWhich data[7] -void DoBounceEffect(u8 battler, u8 which, s8 delta, s8 amplitude) +void DoBounceEffect(enum BattlerId battler, u8 which, s8 delta, s8 amplitude) { u8 invisibleSpriteId; u8 bouncerSpriteId; @@ -2857,7 +2857,7 @@ void DoBounceEffect(u8 battler, u8 which, s8 delta, s8 amplitude) gSprites[bouncerSpriteId].y2 = 0; } -void EndBounceEffect(u8 battler, u8 which) +void EndBounceEffect(enum BattlerId battler, u8 which) { u8 bouncerSpriteId; @@ -2973,10 +2973,8 @@ void BeginBattleIntro(void) static void BattleMainCB1(void) { - u32 battler; - gBattleMainFunc(); - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) gBattlerControllerFuncs[battler](battler); } @@ -3117,17 +3115,16 @@ static void BattleStartClearSetData(void) #define UNPACK_VOLATILE_BATON_PASSABLES(_enum, _fieldName, _typeMaxValue, ...) __VA_OPT__(if ((FIRST(__VA_ARGS__)) & V_BATON_PASSABLE) gBattleMons[battler].volatiles._fieldName = volatilesCopy->_fieldName;) -void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy) +void SwitchInClearSetData(enum BattlerId battler, struct Volatiles *volatilesCopy) { - s32 i; enum BattleMoveEffects effect = GetMoveEffect(gCurrentMove); ClearIllusionMon(battler); if (effect != EFFECT_BATON_PASS) { - for (i = 0; i < NUM_BATTLE_STATS; i++) + for (enum Stat i = 0; i < NUM_BATTLE_STATS; i++) gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.escapePrevention && gBattleMons[i].volatiles.battlerPreventingEscape == battler) gBattleMons[i].volatiles.escapePrevention = FALSE; @@ -3152,6 +3149,7 @@ void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy) * ...etc */ + enum BattlerId i; for (i = 0; i < gBattlersCount; i++) { if (!IsBattlerAlly(battler, i) @@ -3165,7 +3163,7 @@ void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy) SWAP(gBattleMons[battler].attack, gBattleMons[battler].defense, i); } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.infatuation == INFATUATED_WITH(battler)) gBattleMons[i].volatiles.infatuation = 0; @@ -3223,14 +3221,14 @@ void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy) ClearPursuitValuesIfSet(battler); - for (i = 0; i < ARRAY_COUNT(gSideTimers); i++) + for (u32 i = 0; i < ARRAY_COUNT(gSideTimers); i++) { // Switched into sticky web user slot, so reset stored battler ID if (gSideTimers[i].stickyWebBattlerId == battler) gSideTimers[i].stickyWebBattlerId = 0xFF; } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (i != battler && !IsBattlerAlly(i, battler)) gBattleStruct->lastTakenMove[i] = MOVE_NONE; @@ -3258,26 +3256,25 @@ void SwitchInClearSetData(u32 battler, struct Volatiles *volatilesCopy) enum BattleTrainer trainer = GetBattlerTrainer(battler); u32 partyIndex = gBattlerPartyIndexes[battler]; if (TestRunner_Battle_GetForcedAbility(trainer, partyIndex)) - gBattleMons[i].ability = TestRunner_Battle_GetForcedAbility(trainer, partyIndex); + gBattleMons[battler].ability = TestRunner_Battle_GetForcedAbility(trainer, partyIndex); } #endif // TESTING Ai_UpdateSwitchInData(battler); } -const u8* FaintClearSetData(u32 battler) +const u8* FaintClearSetData(enum BattlerId battler) { - s32 i; const u8 *result = NULL; - for (i = 0; i < NUM_BATTLE_STATS; i++) + for (enum Stat i = 0; i < NUM_BATTLE_STATS; i++) gBattleMons[battler].statStages[i] = DEFAULT_STAT_STAGE; bool32 keepGastroAcid = gBattleMons[battler].volatiles.gastroAcid; memset(&gBattleMons[battler].volatiles, 0, sizeof(struct Volatiles)); gBattleMons[battler].volatiles.gastroAcid = keepGastroAcid; // Edge case: Keep Gastro Acid if pokemon's ability can have effect after fainting, for example Innards Out. - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.escapePrevention && gBattleMons[i].volatiles.battlerPreventingEscape == battler) gBattleMons[i].volatiles.escapePrevention = FALSE; @@ -3329,7 +3326,7 @@ const u8* FaintClearSetData(u32 battler) if (gBattleStruct->battlerState[battler].commanderSpecies != SPECIES_NONE) { - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId partner = BATTLE_PARTNER(battler); if (IsBattlerAlive(partner)) { BtlController_EmitSpriteInvisibility(partner, B_COMM_TO_CONTROLLER, FALSE); @@ -3337,14 +3334,14 @@ const u8* FaintClearSetData(u32 battler) } } - for (i = 0; i < ARRAY_COUNT(gSideTimers); i++) + for (u32 i = 0; i < ARRAY_COUNT(gSideTimers); i++) { // User of sticky web fainted, so reset the stored battler ID if (gSideTimers[i].stickyWebBattlerId == battler) gSideTimers[i].stickyWebBattlerId = 0xFF; } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (i != battler && !IsBattlerAlly(i, battler)) gBattleStruct->lastTakenMove[i] = MOVE_NONE; @@ -3405,7 +3402,7 @@ const u8* FaintClearSetData(u32 battler) static void DoBattleIntro(void) { s32 i; - u32 battler; + enum BattlerId battler; switch ((enum BattleIntroStates)gBattleStruct->eventState.battleIntro) { @@ -3742,12 +3739,12 @@ static void TryDoEventsBeforeFirstTurn(void) // Set invalid mons as absent(for example when starting a double battle with only one pokemon). if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI)) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - gBattleStruct->monToSwitchIntoId[i] = PARTY_SIZE; // Included here because switches can happen before during set ups (eg. eject pack) - struct Pokemon *mon = GetBattlerMon(i); - if (!IsBattlerAlive(i) || gBattleMons[i].species == SPECIES_NONE || GetMonData(mon, MON_DATA_IS_EGG)) - gAbsentBattlerFlags |= 1u << i; + gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; // Included here because switches can happen before during set ups (eg. eject pack) + struct Pokemon *mon = GetBattlerMon(battler); + if (!IsBattlerAlive(battler) || gBattleMons[battler].species == SPECIES_NONE || GetMonData(mon, MON_DATA_IS_EGG)) + gAbsentBattlerFlags |= 1u << battler; } } @@ -3755,12 +3752,12 @@ static void TryDoEventsBeforeFirstTurn(void) #if TESTING if (gTestRunnerEnabled) { - for (i = 0; i < gBattlersCount; ++i) + for (enum BattlerId battler = 0; battler < gBattlersCount; ++battler) { - enum BattleTrainer trainer = GetBattlerTrainer(i); - u32 partyIndex = gBattlerPartyIndexes[i]; + enum BattleTrainer trainer = GetBattlerTrainer(battler); + u32 partyIndex = gBattlerPartyIndexes[battler]; if (TestRunner_Battle_GetForcedAbility(trainer, partyIndex)) - gBattleMons[i].ability = TestRunner_Battle_GetForcedAbility(trainer, partyIndex); + gBattleMons[battler].ability = TestRunner_Battle_GetForcedAbility(trainer, partyIndex); } } #endif // TESTING @@ -3789,11 +3786,11 @@ static void TryDoEventsBeforeFirstTurn(void) gBattleStruct->eventState.beforeFirstTurn++; break; case FIRST_TURN_EVENTS_TOTEM_BOOST: - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - if (gQueuedStatBoosts[i].stats != 0 && !gProtectStructs[i].eatMirrorHerb && gProtectStructs[i].activateOpportunist == 0) + if (gQueuedStatBoosts[battler].stats != 0 && !gProtectStructs[battler].eatMirrorHerb && gProtectStructs[battler].activateOpportunist == 0) { - gBattlerAttacker = i; + gBattlerAttacker = battler; BattleScriptExecute(BattleScript_TotemVar); return; } @@ -3803,7 +3800,7 @@ static void TryDoEventsBeforeFirstTurn(void) break; case FIRST_TURN_SWITCH_IN_EVENTS: gBattleStruct->eventState.switchIn = 0; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) gBattleStruct->battlerState[battler].switchIn = TRUE; BattleScriptPushCursorAndCallback(BattleScript_FirstTurnSwitchInEvents); gBattleStruct->eventState.beforeFirstTurn++; @@ -3839,11 +3836,11 @@ static void TryDoEventsBeforeFirstTurn(void) gBattleStruct->eventState.beforeFirstTurn++; break; case FIRST_TURN_EVENTS_END: - for (i = 0; i < MAX_BATTLERS_COUNT; i++) + for (enum BattlerId battler = 0; battler < MAX_BATTLERS_COUNT; battler++) { - gBattleStruct->monToSwitchIntoId[i] = PARTY_SIZE; - gChosenActionByBattler[i] = B_ACTION_NONE; - gChosenMoveByBattler[i] = MOVE_NONE; + gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; + gChosenActionByBattler[battler] = B_ACTION_NONE; + gChosenMoveByBattler[battler] = MOVE_NONE; } TurnValuesCleanUp(FALSE); memset(&gSpecialStatuses, 0, sizeof(gSpecialStatuses)); @@ -3878,18 +3875,16 @@ static void TryDoEventsBeforeFirstTurn(void) static void HandleEndTurn_ContinueBattle(void) { - s32 i; - if (gBattleControllerExecFlags == 0) { gBattleMainFunc = BattleTurnPassed; - for (i = 0; i < BATTLE_COMMUNICATION_ENTRIES_COUNT; i++) + for (u32 i = 0; i < BATTLE_COMMUNICATION_ENTRIES_COUNT; i++) gBattleCommunication[i] = 0; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - gBattleMons[i].volatiles.flinched = FALSE; - if ((gBattleMons[i].status1 & STATUS1_SLEEP) && (gBattleMons[i].volatiles.multipleTurns)) - CancelMultiTurnMoves(i, SKY_DROP_IGNORE); + gBattleMons[battler].volatiles.flinched = FALSE; + if ((gBattleMons[battler].status1 & STATUS1_SLEEP) && (gBattleMons[battler].volatiles.multipleTurns)) + CancelMultiTurnMoves(battler, SKY_DROP_IGNORE); } gBattleStruct->eventState.endTurnBlock = 0; gBattleStruct->eventState.endTurnBattler = 0; @@ -3936,17 +3931,17 @@ void BattleTurnPassed(void) gBattleStruct->eventState.arenaTurn++; } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - gChosenActionByBattler[i] = B_ACTION_NONE; - gChosenMoveByBattler[i] = MOVE_NONE; - gBattleStruct->monToSwitchIntoId[i] = PARTY_SIZE; - gBattleMons[i].volatiles.electrified = FALSE; - gBattleMons[i].volatiles.flinched = FALSE; - gBattleMons[i].volatiles.powder = FALSE; + gChosenActionByBattler[battler] = B_ACTION_NONE; + gChosenMoveByBattler[battler] = MOVE_NONE; + gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; + gBattleMons[battler].volatiles.electrified = FALSE; + gBattleMons[battler].volatiles.flinched = FALSE; + gBattleMons[battler].volatiles.powder = FALSE; - if (gBattleStruct->battlerState[i].stompingTantrumTimer > 0) - gBattleStruct->battlerState[i].stompingTantrumTimer--; + if (gBattleStruct->battlerState[battler].stompingTantrumTimer > 0) + gBattleStruct->battlerState[battler].stompingTantrumTimer--; } for (i = 0; i < NUM_BATTLE_SIDES; i++) @@ -3969,7 +3964,7 @@ void BattleTurnPassed(void) BattleScriptExecute(BattleScript_ArenaTurnBeginning); } -u8 IsRunningFromBattleImpossible(u32 battler) +u8 IsRunningFromBattleImpossible(enum BattlerId battler) { enum HoldEffect holdEffect; u32 i; @@ -4024,7 +4019,7 @@ u8 IsRunningFromBattleImpossible(u32 battler) return BATTLE_RUN_SUCCESS; } -void SwitchTwoBattlersInParty(u32 battler, u32 battler2) +void SwitchTwoBattlersInParty(enum BattlerId battler, enum BattlerId battler2) { s32 i; u32 partyId1, partyId2; @@ -4043,7 +4038,7 @@ void SwitchTwoBattlersInParty(u32 battler, u32 battler2) } } -void SwitchPartyOrder(u32 battler) +void SwitchPartyOrder(enum BattlerId battler) { s32 i; u32 partyId1, partyId2; @@ -4087,10 +4082,10 @@ enum static void HandleTurnActionSelectionState(void) { - s32 i, battler; + s32 i; gBattleCommunication[ACTIONS_CONFIRMED_COUNT] = 0; - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { enum BattlerPosition position = GetBattlerPosition(battler); switch (gBattleCommunication[battler]) @@ -4409,7 +4404,7 @@ static void HandleTurnActionSelectionState(void) // Get the chosen move position (and thus the chosen move) and target from the returned buffer. gBattleStruct->chosenMovePositions[battler] = gBattleResources->bufferB[battler][2] & ~RET_GIMMICK; - gChosenMoveByBattler[battler] = GetChosenMoveFromPosition(battler); + gChosenMoveByBattler[battler] = GetBattlerChosenMove(battler); gBattleStruct->moveTarget[battler] = gBattleResources->bufferB[battler][3]; if (IsBattleMoveStatus(gChosenMoveByBattler[battler]) && GetBattlerAbility(battler) == ABILITY_MYCELIUM_MIGHT) gProtectStructs[battler].myceliumMight = TRUE; @@ -4423,7 +4418,7 @@ static void HandleTurnActionSelectionState(void) // Max Move check if (GetActiveGimmick(battler) == GIMMICK_DYNAMAX || IsGimmickSelected(battler, GIMMICK_DYNAMAX)) { - gBattleStruct->dynamax.baseMoves[battler] = GetChosenMoveFromPosition(battler); + gBattleStruct->dynamax.baseMoves[battler] = GetBattlerChosenMove(battler); } gBattleCommunication[battler]++; @@ -4604,10 +4599,10 @@ static void HandleTurnActionSelectionState(void) if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - if (gChosenActionByBattler[i] == B_ACTION_SWITCH) - SwitchPartyOrderInGameMulti(i, gBattleStruct->monToSwitchIntoId[i]); + if (gChosenActionByBattler[battler] == B_ACTION_SWITCH) + SwitchPartyOrderInGameMulti(battler, gBattleStruct->monToSwitchIntoId[battler]); } } } @@ -4615,7 +4610,8 @@ static void HandleTurnActionSelectionState(void) static bool8 AllAtActionConfirmed(void) { - s32 i, count; + enum BattlerId i; + s32 count; for (count = 0, i = 0; i < gBattlersCount; i++) { @@ -4629,7 +4625,7 @@ static bool8 AllAtActionConfirmed(void) return FALSE; } -static void UpdateBattlerPartyOrdersOnSwitch(u32 battler) +static void UpdateBattlerPartyOrdersOnSwitch(enum BattlerId battler) { gBattleStruct->monToSwitchIntoId[battler] = gBattleResources->bufferB[battler][1]; RecordedBattle_SetBattlerAction(battler, gBattleResources->bufferB[battler][1]); @@ -4655,7 +4651,7 @@ void SwapTurnOrder(u8 id1, u8 id2) } // For AI, so it doesn't 'cheat' by knowing player's ability -u32 GetBattlerTotalSpeedStat(u32 battler, enum Ability ability, enum HoldEffect holdEffect) +u32 GetBattlerTotalSpeedStat(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect) { u32 speed = gBattleMons[battler].speed; @@ -4722,7 +4718,7 @@ u32 GetBattlerTotalSpeedStat(u32 battler, enum Ability ability, enum HoldEffect return speed; } -s32 GetChosenMovePriority(u32 battler, enum Ability ability) +s32 GetChosenMovePriority(enum BattlerId battler, enum Ability ability) { enum Move move; @@ -4730,12 +4726,12 @@ s32 GetChosenMovePriority(u32 battler, enum Ability ability) if (gProtectStructs[battler].noValidMoves) move = MOVE_STRUGGLE; else - move = GetChosenMoveFromPosition(battler); + move = GetBattlerChosenMove(battler); return GetBattleMovePriority(battler, ability, move); } -s32 GetBattleMovePriority(u32 battler, enum Ability ability, enum Move move) +s32 GetBattleMovePriority(enum BattlerId battler, enum Ability ability, enum Move move) { s32 priority = 0; @@ -4911,7 +4907,7 @@ s32 GetWhichBattlerFaster(struct BattleCalcValues *calcValues, bool32 ignoreChos static void SetActionsAndBattlersTurnOrder(void) { s32 turnOrderId = 0; - s32 i, j, battler; + enum BattlerId battler, battler2; if (gBattleTypeFlags & BATTLE_TYPE_SAFARI) { @@ -4939,12 +4935,12 @@ static void SetActionsAndBattlersTurnOrder(void) { if (gChosenActionByBattler[0] == B_ACTION_RUN) { - battler = 0; + battler = B_BATTLER_0; turnOrderId = 5; } if (gChosenActionByBattler[2] == B_ACTION_RUN) { - battler = 2; + battler = B_BATTLER_2; turnOrderId = 5; } } @@ -4954,12 +4950,12 @@ static void SetActionsAndBattlersTurnOrder(void) gActionsByTurnOrder[0] = gChosenActionByBattler[battler]; gBattlerByTurnOrder[0] = battler; turnOrderId = 1; - for (i = 0; i < gBattlersCount; i++) + for (battler2 = 0; battler2 < gBattlersCount; battler2++) { - if (i != battler) + if (battler2 != battler) { - gActionsByTurnOrder[turnOrderId] = gChosenActionByBattler[i]; - gBattlerByTurnOrder[turnOrderId] = i; + gActionsByTurnOrder[turnOrderId] = gChosenActionByBattler[battler2]; + gBattlerByTurnOrder[turnOrderId] = battler2; turnOrderId++; } } @@ -4994,27 +4990,27 @@ static void SetActionsAndBattlersTurnOrder(void) } } struct BattleCalcValues calcValues = {0}; - for (i = 0; i < gBattlersCount; i++) + for (battler = 0; battler < gBattlersCount; battler++) { - calcValues.abilities[i] = GetBattlerAbility(i); - calcValues.holdEffects[i] = GetBattlerHoldEffect(i); + calcValues.abilities[battler] = GetBattlerAbility(battler); + calcValues.holdEffects[battler] = GetBattlerHoldEffect(battler); } - for (i = 0; i < gBattlersCount - 1; i++) + for (battler = 0; battler < gBattlersCount - 1; battler++) { - for (j = i + 1; j < gBattlersCount; j++) + for (battler2 = battler + 1; battler2 < gBattlersCount; battler2++) { - calcValues.battlerAtk = gBattlerByTurnOrder[i]; - calcValues.battlerDef = gBattlerByTurnOrder[j]; + calcValues.battlerAtk = gBattlerByTurnOrder[battler]; + calcValues.battlerDef = gBattlerByTurnOrder[battler2]; TryChangingTurnOrderEffects(&calcValues, quickClawRandom, quickDrawRandom); - if (gActionsByTurnOrder[i] != B_ACTION_USE_ITEM - && gActionsByTurnOrder[j] != B_ACTION_USE_ITEM - && gActionsByTurnOrder[i] != B_ACTION_SWITCH - && gActionsByTurnOrder[j] != B_ACTION_SWITCH - && gActionsByTurnOrder[i] != B_ACTION_THROW_BALL - && gActionsByTurnOrder[j] != B_ACTION_THROW_BALL) + if (gActionsByTurnOrder[battler] != B_ACTION_USE_ITEM + && gActionsByTurnOrder[battler2] != B_ACTION_USE_ITEM + && gActionsByTurnOrder[battler] != B_ACTION_SWITCH + && gActionsByTurnOrder[battler2] != B_ACTION_SWITCH + && gActionsByTurnOrder[battler] != B_ACTION_THROW_BALL + && gActionsByTurnOrder[battler2] != B_ACTION_THROW_BALL) { if (GetWhichBattlerFaster(&calcValues, FALSE) == -1) - SwapTurnOrder(i, j); + SwapTurnOrder(battler, battler2); } } } @@ -5026,9 +5022,7 @@ static void SetActionsAndBattlersTurnOrder(void) static void TurnValuesCleanUp(bool8 var0) { - s32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (var0) { @@ -5076,12 +5070,11 @@ static void TurnValuesCleanUp(bool8 var0) static void PopulateArrayWithBattlers(u8 *battlers) { - u32 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) battlers[i] = i; } -static bool32 TryActivateGimmick(u32 battler) +static bool32 TryActivateGimmick(enum BattlerId battler) { if ((gBattleStruct->gimmick.toActivate & (1u << battler)) && !(gProtectStructs[battler].noValidMoves)) { @@ -5100,15 +5093,14 @@ static bool32 TryDoGimmicksBeforeMoves(void) { if (!(gHitMarker & HITMARKER_RUN) && gBattleStruct->gimmick.toActivate) { - u32 i; - u8 order[MAX_BATTLERS_COUNT]; + enum BattlerId battlers[MAX_BATTLERS_COUNT]; - PopulateArrayWithBattlers(order); - SortBattlersBySpeed(order, FALSE); - for (i = 0; i < gBattlersCount; i++) + PopulateArrayWithBattlers(battlers); + SortBattlersBySpeed(battlers, FALSE); + for (enum BattlerId i = 0; i < gBattlersCount; i++) { // Search through each battler and activate their gimmick if they have one prepared. - if (TryActivateGimmick(order[i])) + if (TryActivateGimmick(battlers[i])) return TRUE; } } @@ -5122,20 +5114,20 @@ static bool32 TryDoMoveEffectsBeforeMoves(void) { if (!(gHitMarker & HITMARKER_RUN)) { - u32 i; - u8 battlers[MAX_BATTLERS_COUNT]; + enum BattlerId battlers[MAX_BATTLERS_COUNT]; PopulateArrayWithBattlers(battlers); SortBattlersBySpeed(battlers, FALSE); - for (i = 0; i < gBattlersCount; i++) + for (u32 i = 0; i < gBattlersCount; i++) { - if (!gBattleStruct->battlerState[battlers[i]].focusPunchBattlers - && !(gBattleMons[battlers[i]].status1 & STATUS1_SLEEP) - && !(gBattleMons[battlers[i]].volatiles.truantCounter) - && !(gProtectStructs[battlers[i]].noValidMoves)) + enum BattlerId battler = battlers[i]; + if (!gBattleStruct->battlerState[battler].focusPunchBattlers + && !(gBattleMons[battler].status1 & STATUS1_SLEEP) + && !(gBattleMons[battler].volatiles.truantCounter) + && !(gProtectStructs[battler].noValidMoves)) { - gBattleStruct->battlerState[battlers[i]].focusPunchBattlers = TRUE; - gBattlerAttacker = battlers[i]; + gBattleStruct->battlerState[battler].focusPunchBattlers = TRUE; + gBattlerAttacker = battler; switch (GetMoveEffect(gChosenMoveByBattler[gBattlerAttacker])) { case EFFECT_FOCUS_PUNCH: @@ -5160,7 +5152,7 @@ static bool32 TryDoMoveEffectsBeforeMoves(void) // In gen7, priority and speed are recalculated during the turn in which a pokemon mega evolves static void TryChangeTurnOrder(void) { - u32 i, j; + enum BattlerId i, j; struct BattleCalcValues calcValues = {0}; for (i = 0; i < gBattlersCount; i++) @@ -5187,8 +5179,8 @@ static void TryChangeTurnOrder(void) static void TryChangingTurnOrderEffects(struct BattleCalcValues *calcValues, u32 *quickClawRandom, u32 *quickDrawRandom) { - u32 battler1 = calcValues->battlerAtk; - u32 battler2 = calcValues->battlerDef; + enum BattlerId battler1 = calcValues->battlerAtk; + enum BattlerId battler2 = calcValues->battlerDef; enum Ability ability1 = calcValues->abilities[calcValues->battlerAtk]; enum Ability ability2 = calcValues->abilities[calcValues->battlerDef]; enum HoldEffect holdEffectBattler1 = calcValues->holdEffects[calcValues->battlerAtk]; @@ -5217,7 +5209,7 @@ static void TryChangingTurnOrderEffects(struct BattleCalcValues *calcValues, u32 static void CheckChangingTurnOrderEffects(void) { - u32 i, battler; + enum BattlerId i, battler; if (!(gHitMarker & HITMARKER_RUN)) { @@ -5464,8 +5456,6 @@ static void HandleEndTurn_MonFled(void) static void HandleEndTurn_FinishBattle(void) { - u32 i, battler; - if (gCurrentActionFuncId == B_ACTION_TRY_FINISH || gCurrentActionFuncId == B_ACTION_FINISHED) { if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK @@ -5476,7 +5466,7 @@ static void HandleEndTurn_FinishBattle(void) | BATTLE_TYPE_WALLY_TUTORIAL | BATTLE_TYPE_FRONTIER))) { - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (IsOnPlayerSide(battler)) { @@ -5534,7 +5524,7 @@ static void HandleEndTurn_FinishBattle(void) if (B_TRAINERS_KNOCK_OFF_ITEMS == TRUE || B_RESTORE_HELD_BATTLE_ITEMS >= GEN_9) TryRestoreHeldItems(); - for (i = 0; i < PARTY_SIZE; i++) + for (u32 i = 0; i < PARTY_SIZE; i++) { bool32 changedForm = TryRevertPartyMonFormChange(i); @@ -5548,13 +5538,13 @@ static void HandleEndTurn_FinishBattle(void) // Clear battle mon species to avoid a bug on the next battle that causes // healthboxes loading incorrectly due to it trying to create a Mega Indicator // if the previous battler would've had it. - for (i = 0; i < MAX_BATTLERS_COUNT; i++) + for (enum BattlerId i = 0; i < MAX_BATTLERS_COUNT; i++) { gBattleMons[i].species = SPECIES_NONE; } // Set Battle Controllers to BATTLE_CONTROLLER_NONE - for (i = 0; i < MAX_BATTLERS_COUNT; i++) + for (enum BattlerId i = 0; i < MAX_BATTLERS_COUNT; i++) { gBattlerBattleController[i] = BATTLE_CONTROLLER_NONE; } @@ -5719,7 +5709,7 @@ void RunBattleScriptCommands(void) gBattleScriptingCommandsTable[gBattlescriptCurrInstr[0]](); } -enum Type TrySetAteType(enum Move move, u32 battlerAtk, enum Ability attackerAbility) +enum Type TrySetAteType(enum Move move, enum BattlerId battlerAtk, enum Ability attackerAbility) { enum Type ateType = TYPE_NONE; @@ -5767,7 +5757,7 @@ enum Type TrySetAteType(enum Move move, u32 battlerAtk, enum Ability attackerAbi } // Returns TYPE_NONE if type doesn't change. -enum Type GetDynamicMoveType(struct Pokemon *mon, enum Move move, u32 battler, enum MonState state) +enum Type GetDynamicMoveType(struct Pokemon *mon, enum Move move, enum BattlerId battler, enum MonState state) { enum Type moveType = GetMoveType(move); enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -6005,7 +5995,7 @@ enum Type GetDynamicMoveType(struct Pokemon *mon, enum Move move, u32 battler, e return TYPE_NONE; } -void SetTypeBeforeUsingMove(enum Move move, u32 battler) +void SetTypeBeforeUsingMove(enum Move move, enum BattlerId battler) { enum Type moveType; u32 heldItem = gBattleMons[battler].item; @@ -6043,7 +6033,7 @@ void SetTypeBeforeUsingMove(enum Move move, u32 battler) // Queues stat boosts for a given battler for totem battles void ScriptSetTotemBoost(struct ScriptContext *ctx) { - u32 battler = VarGet(ScriptReadHalfword(ctx)); + enum BattlerId battler = VarGet(ScriptReadHalfword(ctx)); u32 stat; u32 i; diff --git a/src/battle_message.c b/src/battle_message.c index 40a321f9f8..7b7244c305 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -2058,7 +2058,7 @@ static const struct BattleWindowText *const sBattleTextOnWindowsInfo[] = static const u8 sRecordedBattleTextSpeeds[] = {8, 4, 1, 0}; -void BufferStringBattle(enum StringID stringID, u32 battler) +void BufferStringBattle(enum StringID stringID, enum BattlerId battler) { s32 i; const u8 *stringPtr = NULL; @@ -2593,7 +2593,7 @@ static const u8 *TryGetStatusString(u8 *src) return NULL; } -static void GetBattlerNick(u32 battler, u8 *dst) +static void GetBattlerNick(enum BattlerId battler, u8 *dst) { struct Pokemon *illusionMon = GetIllusionMonPtr(battler); struct Pokemon *mon = GetBattlerMon(battler); @@ -2605,7 +2605,7 @@ static void GetBattlerNick(u32 battler, u8 *dst) } #define HANDLE_NICKNAME_STRING_CASE(battler) \ - if (!IsOnPlayerSide(battler)) \ + if (!IsOnPlayerSide(battler)) \ { \ if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) \ toCpy = sText_FoePkmnPrefix; \ @@ -2638,7 +2638,7 @@ static void GetBattlerNick(u32 battler, u8 *dst) GetBattlerNick(battler, text); \ toCpy = text; -static const u8 *BattleStringGetOpponentNameByTrainerId(u16 trainerId, u8 *text, u8 multiplayerId, u8 battler) +static const u8 *BattleStringGetOpponentNameByTrainerId(u16 trainerId, u8 *text, u8 multiplayerId, enum BattlerId battler) { const u8 *toCpy = NULL; @@ -2690,7 +2690,7 @@ static const u8 *BattleStringGetOpponentNameByTrainerId(u16 trainerId, u8 *text, return toCpy; } -static const u8 *BattleStringGetOpponentName(u8 *text, u8 multiplayerId, u8 battler) +static const u8 *BattleStringGetOpponentName(u8 *text, u8 multiplayerId, enum BattlerId battler) { const u8 *toCpy = NULL; @@ -2712,7 +2712,7 @@ static const u8 *BattleStringGetOpponentName(u8 *text, u8 multiplayerId, u8 batt return toCpy; } -static const u8 *BattleStringGetPlayerName(u8 *text, u8 battler) +static const u8 *BattleStringGetPlayerName(u8 *text, enum BattlerId battler) { const u8 *toCpy = NULL; @@ -2751,7 +2751,7 @@ static const u8 *BattleStringGetPlayerName(u8 *text, u8 battler) return toCpy; } -static const u8 *BattleStringGetTrainerName(u8 *text, u8 multiplayerId, u8 battler) +static const u8 *BattleStringGetTrainerName(u8 *text, u8 multiplayerId, enum BattlerId battler) { if (IsOnPlayerSide(battler)) return BattleStringGetPlayerName(text, battler); @@ -3372,7 +3372,7 @@ u32 BattleStringExpandPlaceholders(const u8 *src, u8 *dst, u32 dstSize) return dstID; } -static void IllusionNickHack(u32 battler, u32 partyId, u8 *dst) +static void IllusionNickHack(enum BattlerId battler, u32 partyId, u8 *dst) { u32 id = PARTY_SIZE; // we know it's gEnemyParty @@ -3611,7 +3611,7 @@ void BattlePutTextOnWindow(const u8 *text, u8 windowId) } } -void SetPpNumbersPaletteInMoveSelection(u32 battler) +void SetPpNumbersPaletteInMoveSelection(enum BattlerId battler) { struct ChooseMoveStruct *chooseMoveStruct = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); const u16 *palPtr = gPPTextPalette; diff --git a/src/battle_move_resolution.c b/src/battle_move_resolution.c index 92f805f0e9..0784de26ae 100644 --- a/src/battle_move_resolution.c +++ b/src/battle_move_resolution.c @@ -16,8 +16,8 @@ static void ValidateBattlers(void); static enum Move GetOriginallyUsedMove(enum Move chosenMove); static void SetSameMoveTurnValues(enum BattleMoveEffects moveEffect); static void TryClearChargeVolatile(enum Type moveType); -static inline bool32 IsBattlerUsingBeakBlast(u32 battler); -static void RequestNonVolatileChangee(u32 battlerAtk); +static inline bool32 IsBattlerUsingBeakBlast(enum BattlerId battler); +static void RequestNonVolatileChangee(enum BattlerId battlerAtk); static bool32 CanBattlerBounceBackMove(struct BattleContext *ctx); static bool32 TryMagicBounce(struct BattleContext *ctx); static bool32 TryMagicCoat(struct BattleContext *ctx); @@ -524,7 +524,7 @@ static enum CancelerResult CancelerCallSubmove(struct BattleContext *ctx) calledMove = GetAssistMove(); break; case EFFECT_NATURE_POWER: - calledMove = GetNaturePowerMove(ctx->battlerAtk); + calledMove = GetNaturePowerMove(); battleScript = BattleScript_NaturePowerAttackstring; break; case EFFECT_SLEEP_TALK: @@ -837,8 +837,8 @@ static enum CancelerResult CancelerMoveFailure(struct BattleContext *ctx) bool32 canUseWideGuard = (GetConfig(CONFIG_WIDE_GUARD) >= GEN_6 && protectMethod == PROTECT_WIDE_GUARD); bool32 canUseQuickGuard = (GetConfig(CONFIG_QUICK_GUARD) >= GEN_6 && protectMethod == PROTECT_QUICK_GUARD); - if (!canUseProtectSecondTime - && !canUseWideGuard + if (!canUseProtectSecondTime + && !canUseWideGuard && !canUseQuickGuard && protectMethod != PROTECT_CRAFTY_SHIELD) battleScript = BattleScript_ButItFailed; @@ -862,7 +862,7 @@ static enum CancelerResult CancelerMoveFailure(struct BattleContext *ctx) break; case EFFECT_SUCKER_PUNCH: if (HasBattlerActedThisTurn(ctx->battlerDef) - || (IsBattleMoveStatus(GetChosenMoveFromPosition(ctx->battlerDef)) && !gProtectStructs[ctx->battlerDef].noValidMoves)) + || (IsBattleMoveStatus(GetBattlerChosenMove(ctx->battlerDef)) && !gProtectStructs[ctx->battlerDef].noValidMoves)) battleScript = BattleScript_ButItFailed; break; case EFFECT_UPPER_HAND: @@ -954,7 +954,7 @@ static enum CancelerResult CancelerPriorityBlock(struct BattleContext *ctx) if (priority <= 0) return CANCELER_RESULT_SUCCESS; - u32 battler; + enum BattlerId battler; enum Ability ability = ABILITY_NONE; // ability of battler who is blocking bool32 isSpreadMove = IsSpreadMove(GetBattlerMoveTargetType(ctx->battlerAtk, ctx->move)); for (battler = 0; battler < gBattlersCount; battler++) @@ -1091,7 +1091,7 @@ static enum CancelerResult CancelerCharging(struct BattleContext *ctx) return result; } -static bool32 NoTargetPresent(u32 battler, enum Move move, enum MoveTarget moveTarget) +static bool32 NoTargetPresent(enum BattlerId battler, enum Move move, enum MoveTarget moveTarget) { switch (moveTarget) { @@ -1157,21 +1157,21 @@ static enum CancelerResult CancelerTookAttack(struct BattleContext *ctx) #define checkFailure FALSE #define skipFailure TRUE -static bool32 IsSingleTarget(u32 battlerAtk, u32 battlerDef) +static bool32 IsSingleTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerDef != gBattlerTarget) return skipFailure; return checkFailure; } -static bool32 IsSmartTarget(u32 battlerAtk, u32 battlerDef) +static bool32 IsSmartTarget(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerAtk == BATTLE_PARTNER(battlerDef)) return skipFailure; return checkFailure; } -static bool32 IsTargetingBothFoes(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingBothFoes(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerDef == BATTLE_PARTNER(battlerAtk) || battlerAtk == battlerDef) { @@ -1183,14 +1183,14 @@ static bool32 IsTargetingBothFoes(u32 battlerAtk, u32 battlerDef) return checkFailure; } -static bool32 IsTargetingSelf(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingSelf(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerAtk != battlerDef) return skipFailure; return skipFailure; // In Gen3 the user checks it's own failure. Unclear because no such moves exists } -static bool32 IsTargetingAlly(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingAlly(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerDef != BATTLE_PARTNER(battlerAtk)) { @@ -1200,7 +1200,7 @@ static bool32 IsTargetingAlly(u32 battlerAtk, u32 battlerDef) return checkFailure; } -static bool32 IsTargetingSelfAndAlly(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingSelfAndAlly(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerDef != BATTLE_PARTNER(battlerAtk)) { @@ -1211,7 +1211,7 @@ static bool32 IsTargetingSelfAndAlly(u32 battlerAtk, u32 battlerDef) return checkFailure; // In Gen3 the user checks it's own failure. Unclear because no such moves exists } -static bool32 IsTargetingSelfOrAlly(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingSelfOrAlly(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerDef == battlerAtk) return skipFailure; @@ -1225,24 +1225,24 @@ static bool32 IsTargetingSelfOrAlly(u32 battlerAtk, u32 battlerDef) return checkFailure; // In Gen3 the user checks it's own failure. Unclear because no such move exists } -static bool32 IsTargetingFoesAndAlly(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingFoesAndAlly(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (battlerAtk == battlerDef) return skipFailure; // Don't set result flags for user return checkFailure; } -static bool32 IsTargetingField(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingField(enum BattlerId battlerAtk, enum BattlerId battlerDef) { return skipFailure; } -static bool32 IsTargetingOpponentsField(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingOpponentsField(enum BattlerId battlerAtk, enum BattlerId battlerDef) { return checkFailure; // Bounce failure only } -static bool32 IsTargetingAllBattlers(u32 battlerAtk, u32 battlerDef) +static bool32 IsTargetingAllBattlers(enum BattlerId battlerAtk, enum BattlerId battlerDef) { if (GetConfig(CONFIG_CHECK_USER_FAILURE) >= GEN_5 && battlerAtk == battlerDef) return skipFailure; @@ -1250,7 +1250,7 @@ static bool32 IsTargetingAllBattlers(u32 battlerAtk, u32 battlerDef) } // ShouldCheckFailureOnTarget -static bool32 (*const sShouldCheckTargetMoveFailure[])(u32 battlerAtk, u32 battlerDef) = +static bool32 (*const sShouldCheckTargetMoveFailure[])(enum BattlerId battlerAtk, enum BattlerId battlerDef) = { [TARGET_NONE] = IsTargetingField, [TARGET_SELECTED] = IsSingleTarget, @@ -1269,7 +1269,7 @@ static bool32 (*const sShouldCheckTargetMoveFailure[])(u32 battlerAtk, u32 battl [TARGET_ALL_BATTLERS] = IsTargetingAllBattlers, }; -static bool32 ShouldCheckTargetMoveFailure(u32 battlerAtk, u32 battlerDef, enum Move move, enum MoveTarget moveTarget) +static bool32 ShouldCheckTargetMoveFailure(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum MoveTarget moveTarget) { // For Bounced moves if (IsBattlerUnaffectedByMove(battlerDef)) @@ -1395,7 +1395,7 @@ static enum CancelerResult CancelerTargetFailure(struct BattleContext *ctx) return CANCELER_RESULT_SUCCESS; } -static bool32 CantFullyProtectFromMove(u32 battlerDef) +static bool32 CantFullyProtectFromMove(enum BattlerId battlerDef) { if (MoveIgnoresProtect(gCurrentMove)) return FALSE; @@ -1409,7 +1409,7 @@ static enum CancelerResult CancelerNotFullyProtected(struct BattleContext *ctx) { while (gBattleStruct->eventState.atkCancelerBattler < gBattlersCount) { - u32 battlerDef = gBattleStruct->eventState.atkCancelerBattler++; + enum BattlerId battlerDef = gBattleStruct->eventState.atkCancelerBattler++; if (CantFullyProtectFromMove(battlerDef)) { @@ -1445,7 +1445,7 @@ static void SetPossibleNewSmartTarget(u32 move) || GetBattlerMoveTargetType(gBattlerAttacker, move) != TARGET_SMART) return; - u32 partner = BATTLE_PARTNER(gBattlerTarget); + enum BattlerId partner = BATTLE_PARTNER(gBattlerTarget); if (!IsBattlerUnaffectedByMove(partner)) gBattlerTarget = partner; } @@ -1835,7 +1835,7 @@ static enum MoveEndResult MoveEndStatusImmunityAbilities(void) { enum MoveEndResult result = MOVEEND_RESULT_CONTINUE; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (AbilityBattleEffects(ABILITYEFFECT_IMMUNITY, battler, 0, 0, TRUE)) result = MOVEEND_RESULT_RUN_SCRIPT; @@ -1940,7 +1940,7 @@ static enum MoveEndResult MoveEndSymbiosis(void) { enum MoveEndResult result = MOVEEND_RESULT_CONTINUE; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if ((gSpecialStatuses[battler].berryReduced || (GetConfig(CONFIG_SYMBIOSIS_GEMS) >= GEN_7 && gSpecialStatuses[battler].gemBoost)) @@ -1965,7 +1965,7 @@ static enum MoveEndResult MoveEndSubstitute(void) { enum MoveEndResult result = MOVEEND_RESULT_CONTINUE; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.substituteHP == 0) gBattleMons[i].volatiles.substitute = FALSE; @@ -2114,12 +2114,12 @@ static enum MoveEndResult MoveEndSkyDropConfuse(void) { enum MoveEndResult result = MOVEEND_RESULT_CONTINUE; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleStruct->skyDropTargets[battler] == SKY_DROP_RELEASED_TARGET) { // Find the battler id of the Pokemon that was held by Sky Drop - u32 targetId; + enum BattlerId targetId; for (targetId = 0; targetId < gBattlersCount; targetId++) { if (gBattleStruct->skyDropTargets[targetId] == battler) @@ -2283,7 +2283,7 @@ static enum MoveEndResult MoveEndNextTarget(void) } else if (moveTarget == TARGET_USER_AND_ALLY) { - u32 partner = BATTLE_PARTNER(gBattlerAttacker); + enum BattlerId partner = BATTLE_PARTNER(gBattlerAttacker); if (partner != gBattlerTarget && IsBattlerAlive(partner)) { gBattleStruct->moveTarget[gBattlerAttacker] = gBattlerTarget = partner; @@ -2321,7 +2321,7 @@ static enum MoveEndResult MoveEndNextTarget(void) gBattleStruct->bouncedMoveIsUsed = FALSE; gBattlerAttacker = gBattleStruct->attackerBeforeBounce; gBattleStruct->battlerState[gBattlerAttacker].targetsDone[originalBounceTarget] = TRUE; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleStruct->battlerState[originalBounceTarget].targetsDone[i] = FALSE; nextTarget = GetNextTarget(moveTarget, FALSE); if (nextTarget != MAX_BATTLERS_COUNT) @@ -2706,7 +2706,7 @@ static enum MoveEndResult MoveEndSheerForce(void) static enum MoveEndResult MoveEndShellTrap(void) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (battlerDef == gBattlerAttacker || IsBattlerAlly(battlerDef, gBattlerAttacker)) continue; @@ -2731,7 +2731,7 @@ static enum MoveEndResult MoveEndColorChange(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battler = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battler = gBattleStruct->eventState.moveEndBattler++; if (battler == gBattlerAttacker) continue; if (AbilityBattleEffects(ABILITYEFFECT_COLOR_CHANGE, battler, GetBattlerAbility(battler), 0, TRUE)) @@ -2747,7 +2747,7 @@ static enum MoveEndResult MoveEndKeeMarangaHpThresholdItemTarget(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battlerDef = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battlerDef = gBattleStruct->eventState.moveEndBattler++; if (battlerDef == gBattlerAttacker) continue; enum HoldEffect holdEffect = GetBattlerHoldEffect(battlerDef); @@ -2760,7 +2760,7 @@ static enum MoveEndResult MoveEndKeeMarangaHpThresholdItemTarget(void) return MOVEEND_RESULT_CONTINUE; } -static bool32 TryRedCard(u32 battlerAtk, u32 redCardBattler, enum Move move) +static bool32 TryRedCard(enum BattlerId battlerAtk, enum BattlerId redCardBattler, enum Move move) { if (!IsBattlerAlive(redCardBattler) || !IsBattlerTurnDamaged(redCardBattler) @@ -2783,7 +2783,7 @@ static bool32 TryRedCard(u32 battlerAtk, u32 redCardBattler, enum Move move) return TRUE; } -static bool32 TryEjectButton(u32 battlerAtk, u32 ejectButtonBattler) +static bool32 TryEjectButton(enum BattlerId battlerAtk, u32 ejectButtonBattler) { if (!IsBattlerTurnDamaged(ejectButtonBattler) || !IsBattlerAlive(ejectButtonBattler) @@ -2805,7 +2805,7 @@ static enum MoveEndResult MoveEndCardButton(void) u32 ejectButtonBattlers = 0; // Because sorting the battlers by speed takes lots of cycles, it's better to just check if any of the battlers has the Eject items. - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (gBattlerAttacker == battlerDef) continue; @@ -2823,12 +2823,12 @@ static enum MoveEndResult MoveEndCardButton(void) return MOVEEND_RESULT_CONTINUE; } - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; SortBattlersBySpeed(battlers, FALSE); - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { - u32 battler = battlers[battlerDef]; + enum BattlerId battler = battlers[battlerDef]; // Only fastest red card or eject button activates if (redCardBattlers & 1u << battler && TryRedCard(gBattlerAttacker, battler, gCurrentMove)) @@ -2838,7 +2838,7 @@ static enum MoveEndResult MoveEndCardButton(void) if (result == MOVEEND_RESULT_RUN_SCRIPT) { - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleMons[i].volatiles.tryEjectPack = FALSE; gBattleScripting.moveendState = MOVEEND_JUMP_TO_HIT_ESCAPE_PLUS_ONE; return result; @@ -2882,7 +2882,7 @@ static enum MoveEndResult MoveEndEmergencyExit(void) // Because sorting the battlers by speed takes lots of cycles, // we check if EE can be activated and count how many. - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsBattlerTurnDamaged(i) && EmergencyExitCanBeTriggered(i)) { @@ -2897,16 +2897,16 @@ static enum MoveEndResult MoveEndEmergencyExit(void) return result; } - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleMons[i].volatiles.tryEjectPack = FALSE; - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; if (numEmergencyExitBattlers > 1) SortBattlersBySpeed(battlers, FALSE); for (u32 i = 0; i < gBattlersCount; i++) { - u32 battler = battlers[i]; + enum BattlerId battler = battlers[i]; if (!(emergencyExitBattlers & 1u << battler)) continue; @@ -2924,7 +2924,7 @@ static enum MoveEndResult MoveEndEmergencyExit(void) return result; } -static inline bool32 CanEjectPackTrigger(u32 battlerAtk, u32 battlerDef, enum BattleMoveEffects moveEffect) +static inline bool32 CanEjectPackTrigger(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum BattleMoveEffects moveEffect) { if (gBattleMons[battlerDef].volatiles.tryEjectPack && GetBattlerHoldEffect(battlerDef) == HOLD_EFFECT_EJECT_PACK @@ -2944,7 +2944,7 @@ static enum MoveEndResult MoveEndEjectPack(void) u32 numEjectPackBattlers = 0; // Because sorting the battlers by speed takes lots of cycles, it's better to just check if any of the battlers has the Eject items. - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (CanEjectPackTrigger(gBattlerAttacker, i, GetMoveEffect(gCurrentMove))) { @@ -2959,16 +2959,16 @@ static enum MoveEndResult MoveEndEjectPack(void) return result; } - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; if (numEjectPackBattlers > 1) SortBattlersBySpeed(battlers, FALSE); - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleMons[i].volatiles.tryEjectPack = FALSE; for (u32 i = 0; i < gBattlersCount; i++) { - u32 battler = battlers[i]; + enum BattlerId battler = battlers[i]; if (!(ejectPackBattlers & 1u << battler)) continue; @@ -3008,7 +3008,7 @@ static enum MoveEndResult MoveEndItemsEffectsAll(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battler = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battler = gBattleStruct->eventState.moveEndBattler++; enum HoldEffect holdEffect = GetBattlerHoldEffect(battler); if (ItemBattleEffects(battler, 0, holdEffect, IsOnStatusChangeActivation) || ItemBattleEffects(battler, 0, holdEffect, IsOnHpThresholdActivation)) @@ -3024,7 +3024,7 @@ static enum MoveEndResult MoveEndWhiteHerb(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battler = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battler = gBattleStruct->eventState.moveEndBattler++; if (!IsBattlerAlive(battler)) continue; @@ -3041,7 +3041,7 @@ static enum MoveEndResult MoveEndOpportunist(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battler = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battler = gBattleStruct->eventState.moveEndBattler++; if (!IsBattlerAlive(battler)) continue; if (AbilityBattleEffects(ABILITYEFFECT_OPPORTUNIST, battler, GetBattlerAbility(battler), 0, TRUE)) @@ -3057,7 +3057,7 @@ static enum MoveEndResult MoveEndMirrorHerb(void) { while (gBattleStruct->eventState.moveEndBattler < gBattlersCount) { - u32 battler = gBattleStruct->eventState.moveEndBattler++; + enum BattlerId battler = gBattleStruct->eventState.moveEndBattler++; if (!IsBattlerAlive(battler)) continue; @@ -3080,11 +3080,11 @@ static enum MoveEndResult MoveEndPickpocket(void) && IsMoveMakingContact(gBattlerAttacker, gBattlerTarget, GetBattlerAbility(gBattlerAttacker), GetBattlerHoldEffect(gBattlerAttacker), gCurrentMove) // Pickpocket requires contact && !IsBattlerUnaffectedByMove(gBattlerTarget)) // Obviously attack needs to have worked { - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; SortBattlersBySpeed(battlers, FALSE); // Pickpocket activates for fastest mon without item for (u32 i = 0; i < gBattlersCount; i++) { - u8 battler = battlers[i]; + enum BattlerId battler = battlers[i]; // Attacker is mon who made contact, battler is mon with pickpocket if (battler != gBattlerAttacker // Cannot pickpocket yourself && GetBattlerAbility(battler) == ABILITY_PICKPOCKET // Target must have pickpocket ability @@ -3167,7 +3167,7 @@ static enum MoveEndResult MoveEndThirdMoveBlock(void) static enum MoveEndResult MoveEndChangedItems(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleStruct->changedItems[battler] != ITEM_NONE) { @@ -3229,14 +3229,14 @@ static enum MoveEndResult MoveEndClearBits(void) ExpendTypeStellarBoost(gBattlerAttacker, moveType); memset(gQueuedStatBoosts, 0, sizeof(gQueuedStatBoosts)); - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { gBattleStruct->battlerState[gBattlerAttacker].targetsDone[i] = FALSE; gBattleMons[i].volatiles.tryEjectPack = FALSE; if (gBattleStruct->battlerState[i].commanderSpecies != SPECIES_NONE && !IsBattlerAlive(i)) { - u32 partner = BATTLE_PARTNER(i); + enum BattlerId partner = BATTLE_PARTNER(i); gBattleStruct->battlerState[i].commanderSpecies = SPECIES_NONE; if (IsBattlerAlive(partner)) gBattleMons[partner].volatiles.semiInvulnerable = STATE_NONE; @@ -3256,7 +3256,8 @@ static enum MoveEndResult MoveEndDancer(void) if (IsDanceMove(gCurrentMove) && !gBattleStruct->snatchedMoveIsUsed) { - u32 battler, nextDancer = 0; + enum BattlerId battler; + u32 nextDancer = 0; bool32 hasDancerTriggered = FALSE; for (battler = 0; battler < gBattlersCount; battler++) @@ -3465,14 +3466,14 @@ static void TryClearChargeVolatile(enum Type moveType) if (moveType == TYPE_ELECTRIC && gBattleMons[gBattlerAttacker].volatiles.chargeTimer == 1) gBattleMons[gBattlerAttacker].volatiles.chargeTimer = 0; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleMons[battler].volatiles.chargeTimer == 2) // Has been set this turn by move or ability gBattleMons[battler].volatiles.chargeTimer--; } } -static inline bool32 IsBattlerUsingBeakBlast(u32 battler) +static inline bool32 IsBattlerUsingBeakBlast(enum BattlerId battler) { if (gChosenActionByBattler[battler] != B_ACTION_USE_MOVE) return FALSE; @@ -3489,7 +3490,7 @@ void MoveValuesCleanUp(void) gBattleCommunication[MISS_TYPE] = 0; } -static void RequestNonVolatileChangee(u32 battlerAtk) +static void RequestNonVolatileChangee(enum BattlerId battlerAtk) { BtlController_EmitSetMonData( battlerAtk, @@ -3599,7 +3600,7 @@ static enum Move GetAssistMove(void) return move; } -enum Move GetNaturePowerMove(u32 battler) +enum Move GetNaturePowerMove(void) { enum Move move = gBattleEnvironmentInfo[gBattleEnvironment].naturePower; if (gFieldStatuses & STATUS_FIELD_MISTY_TERRAIN) @@ -3663,7 +3664,7 @@ static enum Move GetCopycatMove(void) static enum Move GetMeFirstMove(void) { - enum Move move = GetChosenMoveFromPosition(gBattlerTarget); + enum Move move = GetBattlerChosenMove(gBattlerTarget); if (IsBattleMoveStatus(move) || IsMoveMeFirstBanned(move) @@ -3714,7 +3715,7 @@ static bool32 TryMagicCoat(struct BattleContext *ctx) static bool32 TryActivatePowderStatus(enum Move move) { - enum Move partnerMove = GetChosenMoveFromPosition(BATTLE_PARTNER(gBattlerAttacker)); + enum Move partnerMove = GetBattlerChosenMove(BATTLE_PARTNER(gBattlerAttacker)); if (!gBattleMons[gBattlerAttacker].volatiles.powder) return FALSE; if (GetBattleMoveType(move) == TYPE_FIRE && !gBattleStruct->pledgeMove) @@ -3725,4 +3726,3 @@ static bool32 TryActivatePowderStatus(enum Move move) return TRUE; return FALSE; } - diff --git a/src/battle_records.c b/src/battle_records.c index c829702c75..1aed43bc75 100644 --- a/src/battle_records.c +++ b/src/battle_records.c @@ -202,7 +202,7 @@ static void UpdateLinkBattleGameStats(s32 battleOutcome) IncrementGameStat(stat); } -static void UpdateLinkBattleRecords(struct LinkBattleRecords *records, const u8 *name, u16 trainerId, s32 battleOutcome, u8 battler) +static void UpdateLinkBattleRecords(struct LinkBattleRecords *records, const u8 *name, u16 trainerId, s32 battleOutcome, enum BattlerId battler) { s32 index; diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 9c14e8403b..46015872f2 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -92,7 +92,6 @@ // The arguments can be accessed as cmd->failInstr and cmd->move. // gBattlescriptCurrInstr = cmd->nextInstr; advances to the next instruction. #define CMD_ARGS(...) const struct __attribute__((packed)) { u8 opcode; RECURSIVELY(R_FOR_EACH(APPEND_SEMICOLON, __VA_ARGS__)) const u8 nextInstr[0]; } *const cmd UNUSED = (const void *)gBattlescriptCurrInstr -#define VARIOUS_ARGS(...) CMD_ARGS(u8 battler, u8 id, ##__VA_ARGS__) #define NATIVE_ARGS(...) CMD_ARGS(void (*func)(void), ##__VA_ARGS__) // table to avoid ugly powing on gba (courtesy of doesnt) @@ -333,7 +332,7 @@ enum GiveCaughtMonStates #define TAG_LVLUP_BANNER_MON_ICON 55130 -static u32 ChangeStatBuffs(u32 battler, s8 statValue, enum Stat statId, union StatChangeFlags flags, u32 stats, const u8 *BS_ptr); +static u32 ChangeStatBuffs(enum BattlerId battler, s8 statValue, enum Stat statId, union StatChangeFlags flags, u32 stats, const u8 *BS_ptr); static bool32 IsMonGettingExpSentOut(void); static void InitLevelUpBanner(void); static bool8 SlideInLevelUpBanner(void); @@ -351,7 +350,7 @@ static void RemoveAllTerrains(void); static bool32 CanAbilityPreventStatLoss(enum Ability abilityDef); static void AccuracyCheck(bool32 recalcDragonDarts, const u8 *nextInstr, const u8 *failInstr); static void ResetValuesForCalledMove(void); -static bool32 CanAbilityShieldActivateForBattler(u32 battler); +static bool32 CanAbilityShieldActivateForBattler(enum BattlerId battler); static void Cmd_attackcanceler(void); static void Cmd_accuracycheck(void); @@ -964,7 +963,7 @@ static const struct PickupItem sPickupTable[] = #undef _ -bool32 ProteanTryChangeType(u32 battler, enum Ability ability, enum Move move, enum Type moveType) +bool32 ProteanTryChangeType(enum BattlerId battler, enum Ability ability, enum Move move, enum Type moveType) { if ((ability == ABILITY_PROTEAN || ability == ABILITY_LIBERO) && !gBattleMons[gBattlerAttacker].volatiles.usedProteanLibero @@ -986,7 +985,7 @@ u32 NumAffectedSpreadMoveTargets(void) if (!IsDoubleSpreadMove()) return targetCount; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (battler == gBattlerAttacker) continue; @@ -998,7 +997,7 @@ u32 NumAffectedSpreadMoveTargets(void) return targetCount; } -static inline bool32 IsBattlerUsingBeakBlast(u32 battler) +static inline bool32 IsBattlerUsingBeakBlast(enum BattlerId battler) { if (gChosenActionByBattler[battler] != B_ACTION_USE_MOVE) return FALSE; @@ -1116,7 +1115,7 @@ static void Cmd_setchargingturn(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static bool32 ShouldSkipAccuracyCalcPastFirstHit(u32 battlerAtk, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, u32 moveEffect) +static bool32 ShouldSkipAccuracyCalcPastFirstHit(enum BattlerId battlerAtk, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, u32 moveEffect) { if (gSpecialStatuses[battlerAtk].parentalBondState == PARENTAL_BOND_2ND_HIT) return TRUE; @@ -1150,7 +1149,7 @@ static void AccuracyCheck(bool32 recalcDragonDarts, const u8 *nextInstr, const u enum MoveTarget moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove); bool32 calcSpreadMove = IsSpreadMove(moveTarget); - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (gBattleStruct->calculatedSpreadMoveAccuracy) break; @@ -1327,7 +1326,7 @@ static void Cmd_damagecalc(void) if (IsSpreadMove(GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove))) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerInvalidForSpreadMove(gBattlerAttacker, battlerDef)) continue; @@ -1402,7 +1401,7 @@ static void Cmd_multihitresultmessage(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static inline bool32 DoesBattlerNegateDamage(u32 battler) +static inline bool32 DoesBattlerNegateDamage(enum BattlerId battler) { u32 species = gBattleMons[battler].species; enum Ability ability = GetBattlerAbility(battler); @@ -1422,7 +1421,7 @@ static u32 UpdateEffectivenessResultFlagsForDoubleSpreadMoves(u32 resultFlags) // Only play the "best" sound for (u32 sound = 0; sound < 3; sound++) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerInvalidForSpreadMove(gBattlerAttacker, battlerDef)) continue; @@ -1450,7 +1449,7 @@ static u32 UpdateEffectivenessResultFlagsForDoubleSpreadMoves(u32 resultFlags) return resultFlags; } -static inline bool32 TryStrongWindsWeakenAttack(u32 battlerDef, enum Type moveType) +static inline bool32 TryStrongWindsWeakenAttack(enum BattlerId battlerDef, enum Type moveType) { if (gBattleWeather & B_WEATHER_STRONG_WINDS && HasWeatherEffect()) { @@ -1468,7 +1467,7 @@ static inline bool32 TryStrongWindsWeakenAttack(u32 battlerDef, enum Type moveTy return FALSE; } -static inline bool32 TryTeraShellDistortTypeMatchups(u32 battlerDef) +static inline bool32 TryTeraShellDistortTypeMatchups(enum BattlerId battlerDef) { if (gSpecialStatuses[battlerDef].teraShellAbilityDone) { @@ -1482,7 +1481,7 @@ static inline bool32 TryTeraShellDistortTypeMatchups(u32 battlerDef) // According to Gen5 Weakness berry activation happens after the attackanimation. // It doesn't have any impact on gameplay and is only a visual thing which can be adjusted later. -static inline bool32 TryActivateWeaknessBerry(u32 battlerDef) +static inline bool32 TryActivateWeaknessBerry(enum BattlerId battlerDef) { if (DoesDisguiseBlockMove(battlerDef, gCurrentMove)) { @@ -1508,7 +1507,7 @@ static bool32 ProcessPreAttackAnimationFuncs(void) { if (!gBattleStruct->printedStrongWindsWeakenedAttack) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerInvalidForSpreadMove(gBattlerAttacker, battlerDef)) continue; @@ -1517,7 +1516,7 @@ static bool32 ProcessPreAttackAnimationFuncs(void) } } - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerInvalidForSpreadMove(gBattlerAttacker, battlerDef)) continue; @@ -1547,7 +1546,7 @@ static void Cmd_attackanimation(void) if (gBattleControllerExecFlags || ProcessPreAttackAnimationFuncs()) return; - u32 moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove); u32 moveResultFlags = gBattleStruct->moveResultFlags[gBattlerTarget]; enum BattleMoveEffects effect = GetMoveEffect(gCurrentMove); @@ -1654,7 +1653,7 @@ static void DoublesHPBarReduction(void) if (gBattleStruct->doneDoublesSpreadHit) return; - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerUnaffectedByMove(battlerDef) || gBattleStruct->moveDamage[battlerDef] == 0) @@ -1673,7 +1672,7 @@ static void DoublesHPBarReduction(void) static void Cmd_healthbarupdate(void) { CMD_ARGS(u8 battler, u8 updateState); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleControllerExecFlags) return; @@ -1710,7 +1709,7 @@ static void Cmd_healthbarupdate(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static void PassiveDataHpUpdate(u32 battler, const u8 *nextInstr) +static void PassiveDataHpUpdate(enum BattlerId battler, const u8 *nextInstr) { if (gBattleStruct->passiveHpUpdate[battler] < 0) { @@ -1742,7 +1741,7 @@ static void PassiveDataHpUpdate(u32 battler, const u8 *nextInstr) gBattlescriptCurrInstr = nextInstr; } -static void MoveDamageDataHpUpdate(u32 battler, u32 scriptBattler, const u8 *nextInstr) +static void MoveDamageDataHpUpdate(enum BattlerId battler, u32 scriptBattler, const u8 *nextInstr) { if (IsBattlerUnaffectedByMove(gBattlerTarget)) { @@ -1856,7 +1855,7 @@ static void MoveDamageDataHpUpdate(u32 battler, u32 scriptBattler, const u8 *nex static void Cmd_datahpupdate(void) { CMD_ARGS(u8 battler, u8 updateState); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleControllerExecFlags) return; @@ -1969,7 +1968,7 @@ static inline bool32 ShouldPrintTwoFoesMessage(u32 moveResult) static inline bool32 ShouldRelyOnTwoFoesMessage(u32 moveResult) { - u32 oppositeTarget = BATTLE_OPPOSITE(gBattlerAttacker); + enum BattlerId oppositeTarget = BATTLE_OPPOSITE(gBattlerAttacker); return gBattlerTarget == BATTLE_PARTNER(oppositeTarget) && gBattleStruct->moveResultFlags[oppositeTarget] & moveResult && !(gBattleStruct->moveResultFlags[oppositeTarget] & MOVE_RESULT_AVOIDED_ATTACK); @@ -2208,7 +2207,7 @@ static void Cmd_printfromtable(void) } } -bool32 HasBattlerActedThisTurn(u32 battler) +bool32 HasBattlerActedThisTurn(enum BattlerId battler) { u32 i; for (i = 0; i < gCurrentTurnActionNumber; i++) @@ -2219,7 +2218,7 @@ bool32 HasBattlerActedThisTurn(u32 battler) return FALSE; } -u32 GetBattlerTurnOrderNum(u32 battler) +u32 GetBattlerTurnOrderNum(enum BattlerId battler) { u32 i; for (i = 0; i < gBattlersCount; i++) @@ -2231,7 +2230,7 @@ u32 GetBattlerTurnOrderNum(u32 battler) } // battlerStealer steals the item of itemBattler -void StealTargetItem(u8 battlerStealer, u8 itemBattler) +void StealTargetItem(enum BattlerId battlerStealer, enum BattlerId itemBattler) { gLastUsedItem = gBattleMons[itemBattler].item; gBattleMons[itemBattler].item = ITEM_NONE; @@ -2265,7 +2264,7 @@ void StealTargetItem(u8 battlerStealer, u8 itemBattler) TrySaveExchangedItem(itemBattler, gLastUsedItem); } -static inline bool32 TrySetReflect(u32 battler) +static inline bool32 TrySetReflect(enum BattlerId battler) { enum BattleSide side = GetBattlerSide(battler); if (!(gSideStatuses[side] & SIDE_STATUS_REFLECT)) @@ -2286,7 +2285,7 @@ static inline bool32 TrySetReflect(u32 battler) return FALSE; } -static inline bool32 TrySetLightScreen(u32 battler) +static inline bool32 TrySetLightScreen(enum BattlerId battler) { enum BattleSide side = GetBattlerSide(battler); if (!(gSideStatuses[side] & SIDE_STATUS_LIGHTSCREEN)) @@ -2307,7 +2306,7 @@ static inline bool32 TrySetLightScreen(u32 battler) return FALSE; } -static void SetNonVolatileStatus(u32 effectBattler, enum MoveEffect effect, const u8 *battleScript, enum StatusTrigger trigger) +static void SetNonVolatileStatus(enum BattlerId effectBattler, enum MoveEffect effect, const u8 *battleScript, enum StatusTrigger trigger) { gEffectBattler = effectBattler; @@ -2384,7 +2383,7 @@ static void SetNonVolatileStatus(u32 effectBattler, enum MoveEffect effect, cons } // To avoid confusion the arguments are naned battler/effectBattler since they can be different from gBattlerAttacker/gBattlerTarget -void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect, const u8 *battleScript, enum SetMoveEffectFlags effectFlags) +void SetMoveEffect(enum BattlerId battlerAtk, enum BattlerId effectBattler, enum MoveEffect moveEffect, const u8 *battleScript, enum SetMoveEffectFlags effectFlags) { enum Ability abilities[MAX_BATTLERS_COUNT] = {ABILITY_NONE}; abilities[battlerAtk] = GetBattlerAbility(battlerAtk); @@ -2538,7 +2537,7 @@ void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect if (IsOnPlayerSide(gBattlerAttacker) && gSpecialStatuses[gBattlerAttacker].parentalBondState!= PARENTAL_BOND_2ND_HIT) { u16 payday = gPaydayMoney; - u16 moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove); + enum MoveTarget moveTarget = GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove); gPaydayMoney += (gBattleMons[gBattlerAttacker].level * 5); if (payday > gPaydayMoney) gPaydayMoney = 0xFFFF; @@ -2803,7 +2802,7 @@ void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect && !IsSemiInvulnerable(BATTLE_PARTNER(gBattlerTarget), CHECK_ALL) && GetBattlerAbility(BATTLE_PARTNER(gBattlerTarget)) != ABILITY_MAGIC_GUARD) { - u32 partnerTarget = BATTLE_PARTNER(gBattlerTarget); + enum BattlerId partnerTarget = BATTLE_PARTNER(gBattlerTarget); gBattleScripting.battler = partnerTarget; SetPassiveDamageAmount(partnerTarget, gBattleMons[partnerTarget].maxHP / 16); BattleScriptPush(battleScript); @@ -2981,7 +2980,7 @@ void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect break; case MOVE_EFFECT_PSYCHIC_NOISE: { - u32 battler = IsAbilityOnSide(gEffectBattler, ABILITY_AROMA_VEIL); + enum BattlerId battler = IsAbilityOnSide(gEffectBattler, ABILITY_AROMA_VEIL); if (battler) { @@ -3056,8 +3055,8 @@ void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect } break; case MOVE_EFFECT_HAZE: - for (i = 0; i < gBattlersCount; i++) - TryResetBattlerStatChanges(i); + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) + TryResetBattlerStatChanges(battler); BattleScriptPush(battleScript); gBattlescriptCurrInstr = BattleScript_MoveEffectHaze; break; @@ -3341,7 +3340,7 @@ void SetMoveEffect(u32 battlerAtk, u32 effectBattler, enum MoveEffect moveEffect case MOVE_EFFECT_SANDBLAST_SIDE: case MOVE_EFFECT_FIRE_SPIN_SIDE: // Affects both opponents, but doesn't print strings so we can handle it here. - for (u32 battler = 0; battler < MAX_BATTLERS_COUNT; ++battler) + for (enum BattlerId battler = 0; battler < MAX_BATTLERS_COUNT; ++battler) { if (!IsBattlerAlly(battler, gBattlerTarget)) continue; @@ -3690,8 +3689,8 @@ static void Cmd_seteffectprimary(void) { CMD_ARGS(u8 battler, u8 effectBattler); - u32 battler = GetBattlerForBattleScript(cmd->battler); - u32 effectBattler = GetBattlerForBattleScript(cmd->effectBattler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId effectBattler = GetBattlerForBattleScript(cmd->effectBattler); SetMoveEffect(battler, effectBattler, gBattleScripting.moveEffect, cmd->nextInstr, EFFECT_PRIMARY); } @@ -3699,8 +3698,8 @@ static void Cmd_seteffectsecondary(void) { CMD_ARGS(u8 battler, u8 effectBattler); - u32 battler = GetBattlerForBattleScript(cmd->battler); - u32 effectBattler = GetBattlerForBattleScript(cmd->effectBattler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId effectBattler = GetBattlerForBattleScript(cmd->effectBattler); SetMoveEffect(battler, effectBattler, gBattleScripting.moveEffect, cmd->nextInstr, EFFECT_PRIMARY); } @@ -3708,7 +3707,7 @@ static void Cmd_clearvolatile(void) { CMD_ARGS(u8 battler, u8 _volatile); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); SetMonVolatile(battler, cmd->_volatile, 0); if (cmd->_volatile == VOLATILE_MULTIPLETURNS) @@ -3720,7 +3719,7 @@ static void Cmd_clearvolatile(void) static void Cmd_tryfaintmon(void) { CMD_ARGS(u8 battler, bool8 isSpikes, const u8 *instr); - u32 battler; + enum BattlerId battler; battler = GetBattlerForBattleScript(cmd->battler); if (cmd->isSpikes != 0) @@ -3788,7 +3787,7 @@ static void Cmd_dofaintanimation(void) if (gBattleControllerExecFlags != 0) return; - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetActiveGimmick(battler) == GIMMICK_DYNAMAX) { @@ -3811,7 +3810,7 @@ static void Cmd_cleareffectsonfaint(void) if (gBattleControllerExecFlags == 0) { - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); const u8 *clearDataResult = NULL; if (!(gBattleTypeFlags & BATTLE_TYPE_ARENA) || !IsBattlerAlive(battler)) { @@ -3832,7 +3831,7 @@ static void Cmd_jumpifstatus(void) { CMD_ARGS(u8 battler, u32 flags, const u8 *jumpInstr); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 flags = cmd->flags; const u8 *jumpInstr = cmd->jumpInstr; @@ -3846,7 +3845,7 @@ static void Cmd_jumpifvolatile(void) { CMD_ARGS(u8 battler, u8 _volatile, const u8 *jumpInstr); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); const u8 *jumpInstr = cmd->jumpInstr; if (GetBattlerVolatile(battler, cmd->_volatile) != 0 && IsBattlerAlive(battler)) @@ -3859,7 +3858,7 @@ static void Cmd_jumpifability(void) { CMD_ARGS(u8 battler, enum Ability ability, const u8 *jumpInstr); - u32 battler; + enum BattlerId battler; bool32 hasAbility = FALSE; enum Ability ability = cmd->ability; @@ -3918,7 +3917,7 @@ static void Cmd_jumpifstat(void) CMD_ARGS(u8 battler, u8 comparison, u8 stat, u8 value, const u8 *jumpInstr); bool32 ret = 0; - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u8 stat = cmd->stat; u8 value = cmd->value; u8 comparison = cmd->comparison; @@ -3936,7 +3935,7 @@ static void Cmd_jumpifstatignorecontrary(void) CMD_ARGS(u8 battler, u8 comparison, u8 stat, u8 value, const u8 *jumpInstr); bool32 ret = 0; - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u8 stat = cmd->stat; u8 value = cmd->value; u8 comparison = cmd->comparison; @@ -3953,7 +3952,7 @@ static void Cmd_jumpbasedontype(void) { CMD_ARGS(u8 battler, u8 type, u8 jumpIfType, const u8 *jumpInstr); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u8 type = cmd->type; const u8 *jumpInstr = cmd->jumpInstr; @@ -4330,7 +4329,7 @@ static void Cmd_getexp(void) } } -static u32 CountAliveMonsForBattlerSide(u32 battler) +static u32 CountAliveMonsForBattlerSide(enum BattlerId battler) { u32 aliveMons = 0; struct Pokemon *party = GetBattlerParty(battler); @@ -4346,7 +4345,7 @@ static u32 CountAliveMonsForBattlerSide(u32 battler) return aliveMons; } -bool32 NoAliveMonsForBattlerSide(u32 battler) +bool32 NoAliveMonsForBattlerSide(enum BattlerId battler) { return CountAliveMonsForBattlerSide(battler) == 0; } @@ -4439,7 +4438,8 @@ static void Cmd_checkteamslost(void) // In non-multi battles, jump to pointer if 1 spot is missing on both sides if (gBattleOutcome == 0 && (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK | BATTLE_TYPE_TRAINER))) { - s32 i, emptyPlayerSpots, emptyOpponentSpots; + enum BattlerId i; + s32 emptyPlayerSpots, emptyOpponentSpots; for (emptyPlayerSpots = 0, i = 0; i < gBattlersCount; i += 2) { @@ -4465,8 +4465,8 @@ static void Cmd_checkteamslost(void) { u32 occupiedPlayerSpots = (gBattlersCount / 2) - emptyPlayerSpots; u32 occupiedOpponentSpots = (gBattlersCount / 2) - emptyOpponentSpots; - u32 alivePlayerPartyMons = CountAliveMonsForBattlerSide(B_POSITION_PLAYER_LEFT) - occupiedPlayerSpots; - u32 aliveOpponentPartyMons = CountAliveMonsForBattlerSide(B_POSITION_OPPONENT_LEFT) - occupiedOpponentSpots; + u32 alivePlayerPartyMons = CountAliveMonsForBattlerSide(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)) - occupiedPlayerSpots; + u32 aliveOpponentPartyMons = CountAliveMonsForBattlerSide(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)) - occupiedOpponentSpots; u32 emptySlotsTotal = emptyPlayerSpots + emptyOpponentSpots; u32 alivePartyMonsTotal = alivePlayerPartyMons + aliveOpponentPartyMons; @@ -4943,7 +4943,7 @@ static void Cmd_endselectionscript(void) gBattleStruct->battlerState[gBattlerAttacker].selectionScriptFinished = TRUE; } -static void PlayAnimation(u32 battler, u8 animId, const u16 *argPtr, const u8 *nextInstr) +static void PlayAnimation(enum BattlerId battler, u8 animId, const u16 *argPtr, const u8 *nextInstr) { if (B_TERRAIN_BG_CHANGE == FALSE && animId == B_ANIM_RESTORE_BG) { @@ -4999,7 +4999,7 @@ static void Cmd_playanimation(void) { CMD_ARGS(u8 battler, u8 animId, const u16 *argPtr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); PlayAnimation(battler, cmd->animId, cmd->argPtr, cmd->nextInstr); } @@ -5008,14 +5008,14 @@ static void Cmd_playanimation_var(void) { CMD_ARGS(u8 battler, const u8 *animIdPtr, const u16 *argPtr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); PlayAnimation(battler, *(cmd->animIdPtr), cmd->argPtr, cmd->nextInstr); } static void Cmd_jumpfifsemiinvulnerable(void) { CMD_ARGS(u8 battler, u8 state, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleMons[battler].volatiles.semiInvulnerable == cmd->state) gBattlescriptCurrInstr = cmd->jumpInstr; @@ -5027,14 +5027,14 @@ static void Cmd_trainerslidein(void) { CMD_ARGS(u8 position); - u32 battler = GetBattlerForBattleScript(cmd->position); + enum BattlerId battler = GetBattlerForBattleScript(cmd->position); BtlController_EmitTrainerSlide(battler, B_COMM_TO_CONTROLLER); MarkBattlerForControllerExec(battler); gBattlescriptCurrInstr = cmd->nextInstr; } -static inline bool32 IsProtectivePadsProtected(u32 battler, enum HoldEffect holdEffect) +static inline bool32 IsProtectivePadsProtected(enum BattlerId battler, enum HoldEffect holdEffect) { if (holdEffect != HOLD_EFFECT_PROTECTIVE_PADS) return FALSE; @@ -5095,7 +5095,7 @@ static bool32 IsValidSwitchIn(enum BattleSide side, u32 index) if (!IsValidForBattle(&party[index])) return FALSE; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (GetBattlerSide(i) == side && gBattlerPartyIndexes[i] == index && IsBattlerAlive(i)) return FALSE; @@ -5120,7 +5120,7 @@ static void Cmd_getswitchedmondata(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleControllerExecFlags) return; @@ -5143,7 +5143,7 @@ static void Cmd_switchindataupdate(void) CMD_ARGS(u8 battler); struct BattlePokemon oldData; - u32 battler, i; + enum BattlerId battler, i; u8 *monData; if (gBattleControllerExecFlags) @@ -5211,7 +5211,7 @@ static void Cmd_switchindataupdate(void) static void Cmd_switchinanim(void) { - u32 battler; + enum BattlerId battler; CMD_ARGS(u8 battler, bool8 dontClearTransform, bool8 dontClearSubstitute); @@ -5233,9 +5233,10 @@ static void Cmd_switchinanim(void) BattleArena_InitPoints(); } -bool32 CanBattlerSwitch(u32 battler) +bool32 CanBattlerSwitch(enum BattlerId battler) { - s32 i, lastMonId, battlerIn1, battlerIn2; + s32 i, lastMonId; + enum BattlerId battlerIn1, battlerIn2; bool32 ret = FALSE; struct Pokemon *party; @@ -5322,7 +5323,7 @@ bool32 CanBattlerSwitch(u32 battler) party = gEnemyParty; lastMonId = 0; - if (battler == B_POSITION_OPPONENT_RIGHT) + if (GetBattlerPosition(battler) == B_POSITION_OPPONENT_RIGHT) lastMonId = PARTY_SIZE / 2; for (i = lastMonId; i < lastMonId + (PARTY_SIZE / 2); i++) @@ -5380,7 +5381,7 @@ static void Cmd_jumpifcantswitch(void) { CMD_ARGS(u8 battler:7, u8 ignoreEscapePrevention:1, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (!cmd->ignoreEscapePrevention && !CanBattlerEscape(battler) && GetBattlerHoldEffect(battler) != HOLD_EFFECT_SHED_SHELL) { gBattlescriptCurrInstr = cmd->jumpInstr; @@ -5397,7 +5398,7 @@ 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(u32 battler, u8 slotId) +static void ChooseMonToSendOut(enum BattlerId battler, u8 slotId) { gBattleStruct->battlerPartyIndexes[battler] = gBattlerPartyIndexes[battler]; gBattleStruct->monToSwitchIntoId[battler] = PARTY_SIZE; @@ -5413,7 +5414,7 @@ static void Cmd_openpartyscreen(void) u32 flags = 0; u8 hitmarkerFaintBits = 0; - u32 i, battler = 0; + enum BattlerId battler = 0; const u8 *failInstr = cmd->failInstr; if (cmd->battler == BS_FAINTED_MULTIPLE_1) @@ -5449,7 +5450,7 @@ static void Cmd_openpartyscreen(void) bool32 hasReplacement; hitmarkerFaintBits = gHitMarker >> 28; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (((1u << i) & hitmarkerFaintBits)) { @@ -5487,7 +5488,7 @@ static void Cmd_openpartyscreen(void) } } - for (i = 0; i < NUM_BATTLE_SIDES; i++) + for (enum BattlerId i = 0; i < MAX_BATTLERS_COUNT / 2; i++) { if (!(gSpecialStatuses[i].faintedHasReplacement)) { @@ -5514,7 +5515,7 @@ static void Cmd_openpartyscreen(void) if (IsDoubleBattle()) { hitmarkerFaintBits = gHitMarker >> 28; - for (i = 0; i < NUM_BATTLE_SIDES; i++) + for (enum BattlerId i = 0; i < MAX_BATTLERS_COUNT / 2; i++) { if ((1 << BATTLE_PARTNER(i)) & hitmarkerFaintBits && (1 << i) & hitmarkerFaintBits) { @@ -5591,7 +5592,7 @@ static void Cmd_openpartyscreen(void) if (gBattleTypeFlags & BATTLE_TYPE_MULTI) { - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (i != battler) { @@ -5602,7 +5603,7 @@ static void Cmd_openpartyscreen(void) } else { - u32 battlerOpposite = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler))); + enum BattlerId battlerOpposite = GetBattlerAtPosition(BATTLE_OPPOSITE(GetBattlerPosition(battler))); if (gAbsentBattlerFlags & (1u << battlerOpposite)) battlerOpposite ^= BIT_FLANK; @@ -5621,7 +5622,7 @@ static void Cmd_switchhandleorder(void) { CMD_ARGS(u8 battler, u8 state); - u32 battler, i; + enum BattlerId battler, i; if (gBattleControllerExecFlags) return; @@ -5685,7 +5686,7 @@ static void Cmd_switchhandleorder(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static void UpdateSentMonFlags(u32 battler) +static void UpdateSentMonFlags(enum BattlerId battler) { UpdateSentPokesToOpponentValue(battler); gHitMarker &= ~HITMARKER_FAINTED(battler); @@ -5711,7 +5712,7 @@ static void UpdateSentMonFlags(u32 battler) static void Cmd_switchineffects(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); UpdateSentMonFlags(battler); @@ -5766,7 +5767,7 @@ static void Cmd_playfaintcry(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); BtlController_EmitFaintingCry(battler, B_COMM_TO_CONTROLLER); MarkBattlerForControllerExec(battler); @@ -5777,7 +5778,7 @@ static void Cmd_endlinkbattle(void) { CMD_ARGS(); - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); BtlController_EmitEndLinkBattle(battler, B_COMM_TO_CONTROLLER, gBattleOutcome); MarkBattlerForControllerExec(battler); @@ -5788,7 +5789,7 @@ static void Cmd_returntoball(void) { CMD_ARGS(u8 battler, bool8 changingForm); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); BtlController_EmitReturnMonToBall(battler, B_COMM_TO_CONTROLLER, TRUE); MarkBattlerForControllerExec(battler); @@ -5842,7 +5843,7 @@ static void Cmd_handlelearnnewmove(void) } else { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); if (gBattlerPartyIndexes[battler] == monId && !(gBattleMons[battler].volatiles.transformed)) @@ -5938,7 +5939,7 @@ static void Cmd_yesnoboxlearnmove(void) enum Move move = GetMonData(&gPlayerParty[gBattleStruct->expGetterMonId], MON_DATA_MOVE1 + movePosition); if (CannotForgetMove(move)) { - PrepareStringBattle(STRINGID_HMMOVESCANTBEFORGOTTEN, B_POSITION_PLAYER_LEFT); + PrepareStringBattle(STRINGID_HMMOVESCANTBEFORGOTTEN, GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)); gBattleScripting.learnMoveState = 6; } else @@ -6035,7 +6036,7 @@ static void Cmd_hitanimation(void) if (!IsDoubleSpreadMove()) { - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (!IsBattlerUnaffectedByMove(battler)) { @@ -6050,8 +6051,7 @@ static void Cmd_hitanimation(void) } else if (!gBattleStruct->doneDoublesSpreadHit) { - u32 battlerDef; - for (battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (IsBattlerInvalidForSpreadMove(gBattlerAttacker, battlerDef)) continue; @@ -6148,7 +6148,7 @@ static void Cmd_updatebattlermoves(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); switch (gBattleCommunication[0]) { @@ -6196,7 +6196,7 @@ static void Cmd_drawpartystatussummary(void) { CMD_ARGS(u8 battler); - u32 battler, i; + enum BattlerId battler, i; struct Pokemon *party; struct HpAndStatus hpStatuses[PARTY_SIZE]; @@ -6231,7 +6231,7 @@ static void Cmd_hidepartystatussummary(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); BtlController_EmitHidePartyStatusSummary(battler, B_COMM_TO_CONTROLLER); MarkBattlerForControllerExec(battler); @@ -6271,8 +6271,8 @@ static void Cmd_statusanimation(void) if (gBattleControllerExecFlags == 0) { - u32 battler = GetBattlerForBattleScript(cmd->battler), - statusFlag = (cmd->isVolatile || cmd->status) ? cmd->status : gBattleMons[battler].status1; + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + u32 statusFlag = (cmd->isVolatile || cmd->status) ? cmd->status : gBattleMons[battler].status1; if (!IsSemiInvulnerable(battler, CHECK_ALL) && gBattleMons[battler].volatiles.substituteHP == 0 && !(gHitMarker & (HITMARKER_NO_ANIMATIONS | HITMARKER_DISABLE_ANIMATION))) @@ -6311,7 +6311,7 @@ static u32 GetPossibleNextTarget(void) for (u32 i = 0; i < MAX_BATTLERS_COUNT; i++) { - u32 battler = targetOrder[i]; + enum BattlerId battler = targetOrder[i]; if (!IsBattlerAlive(battler)) continue; @@ -6414,7 +6414,7 @@ static void Cmd_setgravity(void) } } -static bool32 TryCheekPouch(u32 battler, enum Item itemId, const u8 *nextInstr) +static bool32 TryCheekPouch(enum BattlerId battler, enum Item itemId, const u8 *nextInstr) { if (GetItemPocket(itemId) == POCKET_BERRIES && GetBattlerAbility(battler) == ABILITY_CHEEK_POUCH @@ -6435,7 +6435,7 @@ static void Cmd_removeitem(void) { CMD_ARGS(u8 battler); - u32 battler; + enum BattlerId battler; enum Item itemId = 0; if (gBattleScripting.overrideBerryRequirements) @@ -6775,7 +6775,7 @@ static void Cmd_setatktoplayer0(void) static void Cmd_makevisible(void) { CMD_ARGS(u8 battler); - u32 battler; + enum BattlerId battler; if (gBattleControllerExecFlags) return; @@ -6791,7 +6791,7 @@ static void Cmd_recordability(void) { CMD_ARGS(u8 battler); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); RecordAbilityBattle(battler, gBattleMons[battler].ability); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -6825,8 +6825,8 @@ static void Cmd_hpthresholds(void) if (!(IsDoubleBattle())) { - u32 battler = GetBattlerForBattleScript(cmd->battler); - u32 opposingBattler = BATTLE_OPPOSITE(battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId opposingBattler = BATTLE_OPPOSITE(battler); s32 result = gBattleMons[opposingBattler].hp * 100 / gBattleMons[opposingBattler].maxHP; if (result == 0) @@ -6851,8 +6851,8 @@ static void Cmd_hpthresholds2(void) if (!(IsDoubleBattle())) { - u32 battler = GetBattlerForBattleScript(cmd->battler); - u32 opposingBattler = BATTLE_OPPOSITE(battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId opposingBattler = BATTLE_OPPOSITE(battler); u32 hpSwitchout = gBattleStruct->battlerState[opposingBattler].hpOnSwitchout; s32 result = (hpSwitchout - gBattleMons[opposingBattler].hp) * 100 / hpSwitchout; @@ -6878,7 +6878,7 @@ static void Cmd_useitemonopponent(void) gBattlescriptCurrInstr = cmd->nextInstr; } -bool32 CanUseLastResort(u8 battler) +bool32 CanUseLastResort(enum BattlerId battler) { u32 moveIndex; for (moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -6988,7 +6988,7 @@ static bool32 DefogClearHazards(u32 saveBattler, enum BattleSide side, bool32 cl return FALSE; } -static bool32 TryDefogClear(u32 battlerAtk, bool32 clear) +static bool32 TryDefogClear(enum BattlerId battlerAtk, bool32 clear) { s32 i; u8 saveBattler = gBattlerAttacker; @@ -7038,7 +7038,7 @@ static bool32 TryDefogClear(u32 battlerAtk, bool32 clear) return FALSE; } -static bool32 TryTidyUpClear(u32 battlerAtk, bool32 clear) +static bool32 TryTidyUpClear(enum BattlerId battlerAtk, bool32 clear) { u32 i; u32 saveBattler = gBattlerAttacker; @@ -7070,7 +7070,7 @@ static bool32 TryTidyUpClear(u32 battlerAtk, bool32 clear) return FALSE; } -u32 IsFlowerVeilProtected(u32 battler) +u32 IsFlowerVeilProtected(enum BattlerId battler) { if (IS_BATTLER_OF_TYPE(battler, TYPE_GRASS)) return IsAbilityOnSide(battler, ABILITY_FLOWER_VEIL); @@ -7078,7 +7078,7 @@ u32 IsFlowerVeilProtected(u32 battler) return 0; } -u32 IsLeafGuardProtected(u32 battler, enum Ability ability) +u32 IsLeafGuardProtected(enum BattlerId battler, enum Ability ability) { if (IsBattlerWeatherAffected(battler, B_WEATHER_SUN)) return ability == ABILITY_LEAF_GUARD; @@ -7086,13 +7086,13 @@ u32 IsLeafGuardProtected(u32 battler, enum Ability ability) return 0; } -bool32 IsShieldsDownProtected(u32 battler, enum Ability ability) +bool32 IsShieldsDownProtected(enum BattlerId battler, enum Ability ability) { return (ability == ABILITY_SHIELDS_DOWN && GetFormIdFromFormSpeciesId(gBattleMons[battler].species) < GetFormIdFromFormSpeciesId(SPECIES_MINIOR_CORE_RED)); // Minior is not in core form } -u32 IsAbilityStatusProtected(u32 battler, enum Ability ability) +u32 IsAbilityStatusProtected(enum BattlerId battler, enum Ability ability) { return IsLeafGuardProtected(battler, ability) || IsShieldsDownProtected(battler, ability) @@ -7166,7 +7166,7 @@ void BS_CourtChangeSwapSideStatuses(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static void HandleScriptMegaPrimalBurst(u32 caseId, u32 battler, u32 type) +static void HandleScriptMegaPrimalBurst(u32 caseId, enum BattlerId battler, u32 type) { struct Pokemon *mon = GetBattlerMon(battler); @@ -7419,9 +7419,9 @@ static void Cmd_unused_0x83(void) { } -bool8 UproarWakeUpCheck(u8 battler) +bool8 UproarWakeUpCheck(enum BattlerId battler) { - s32 i; + enum BattlerId i; bool32 hasSoundproof = (B_UPROAR_IGNORE_SOUNDPROOF < GEN_5 && GetBattlerAbility(battler) == ABILITY_SOUNDPROOF); for (i = 0; i < gBattlersCount; i++) @@ -7617,7 +7617,7 @@ static u16 ReverseStatChangeMoveEffect(u16 moveEffect) } } -static void TryPlayStatChangeAnimation(u32 battler, enum Ability ability, u32 stats, s32 statValue, u32 statId, bool32 certain) +static void TryPlayStatChangeAnimation(enum BattlerId battler, enum Ability ability, u32 stats, s32 statValue, u32 statId, bool32 certain) { enum Stat currStat = 0; u32 changeableStatsCount = 1; // current stat is counted automatically @@ -7705,7 +7705,7 @@ static void TryPlayStatChangeAnimation(u32 battler, enum Ability ability, u32 st } } -static u32 ChangeStatBuffs(u32 battler, s8 statValue, enum Stat statId, union StatChangeFlags flags, u32 stats, const u8 *BS_ptr) +static u32 ChangeStatBuffs(enum BattlerId battler, s8 statValue, enum Stat statId, union StatChangeFlags flags, u32 stats, const u8 *BS_ptr) { u32 index, battlerAbility; enum HoldEffect battlerHoldEffect; @@ -7917,7 +7917,7 @@ static u32 ChangeStatBuffs(u32 battler, s8 statValue, enum Stat statId, union St if (statIncrease) { // Check Mirror Herb / Opportunist - for (index = 0; index < gBattlersCount; index++) + for (enum BattlerId index = 0; index < gBattlersCount; index++) { if (IsBattlerAlly(index, battler)) continue; // Only triggers on opposing side @@ -7989,7 +7989,7 @@ static void Cmd_statbuffchange(void) gBattlescriptCurrInstr = failInstr; } -bool32 TryResetBattlerStatChanges(u8 battler) +bool32 TryResetBattlerStatChanges(enum BattlerId battler) { u32 j; bool32 ret = FALSE; @@ -8012,9 +8012,7 @@ static void Cmd_normalisebuffs(void) { CMD_ARGS(); - s32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) TryResetBattlerStatChanges(i); gBattlescriptCurrInstr = cmd->nextInstr; @@ -8423,7 +8421,7 @@ static void Cmd_copybidedmg(void) static void Cmd_animatewildpokemonafterfailedpokeball(void) { CMD_ARGS(u8 battler); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); AnimateMonAfterPokeBallFail(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -8456,7 +8454,7 @@ static void Cmd_tryinfatuating(void) static void Cmd_updatestatusicon(void) { CMD_ARGS(u8 battler); - u32 battler; + enum BattlerId battler; if (gBattleControllerExecFlags) return; @@ -8522,7 +8520,7 @@ static void Cmd_setmist(void) static void Cmd_setfocusenergy(void) { CMD_ARGS(u8 battler); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum BattleMoveEffects effect = GetMoveEffect(gCurrentMove); if ((effect == EFFECT_DRAGON_CHEER && (!(IsDoubleBattle()) || (gAbsentBattlerFlags & (1u << battler)))) @@ -8783,7 +8781,7 @@ static void Cmd_trysetencore(void) // If the target's selected move is not the same as the move being Encored into, // the target will select a random opposing target // Redirection such as Follow Me is already covered in HandleAction_UseMove of battle_util.c - if (gBattleMons[gBattlerTarget].volatiles.encoredMove != GetChosenMoveFromPosition(gBattlerTarget)) + if (gBattleMons[gBattlerTarget].volatiles.encoredMove != GetBattlerChosenMove(gBattlerTarget)) gBattleStruct->moveTarget[gBattlerTarget] = SetRandomTarget(gBattlerTarget); // Encore always lasts 3 turns, but we need to account for a scenario where Encore changes the move during the same turn. @@ -8957,7 +8955,7 @@ static void Cmd_unused_0xA9(void) static inline bool32 IsDanamaxMonPresent(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (battler == gBattlerAttacker) continue; @@ -9072,7 +9070,7 @@ static void Cmd_healpartystatus(void) u32 i = 0; u32 zero = 0; u32 toHeal = 0; - u32 partner = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); + enum BattlerId partner = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); struct Pokemon *party = GetBattlerParty(gBattlerAttacker); bool32 isSoundMove = IsSoundMove(gCurrentMove); @@ -9182,7 +9180,7 @@ static void Cmd_trysetspikes(void) { CMD_ARGS(const u8 *failInstr); - u8 targetSide = BATTLE_OPPOSITE(GetBattlerSide(gBattlerAttacker)); + enum BattleSide targetSide = GetBattlerSide(BATTLE_OPPOSITE(gBattlerAttacker)); if (gSideTimers[targetSide].spikesAmount == 3) { @@ -9209,10 +9207,9 @@ static void Cmd_trysetperishsong(void) { CMD_ARGS(const u8 *failInstr); - s32 i = 0; s32 notAffectedCount = 0; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.perishSong || IsBattlerUnaffectedByMove(i) @@ -9409,7 +9406,7 @@ static void Cmd_jumpifnopursuitswitchdmg(void) static void Cmd_tryactivateitem(void) { CMD_ARGS(u8 battler, u8 flag); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattlescriptCurrInstr = cmd->nextInstr; @@ -9948,7 +9945,7 @@ static void Cmd_tryswapitems(void) } } -static bool32 CanAbilityShieldActivateForBattler(u32 battler) +static bool32 CanAbilityShieldActivateForBattler(enum BattlerId battler) { if (GetBattlerHoldEffectIgnoreAbility(battler) != HOLD_EFFECT_ABILITY_SHIELD) return FALSE; @@ -9964,8 +9961,8 @@ static void Cmd_trycopyability(void) { CMD_ARGS(u8 battler, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId partner = BATTLE_PARTNER(battler); enum Ability defAbility = gBattleMons[gBattlerTarget].ability; bool32 shouldConsiderPartner = IsBattlerAlive(partner) && GetMoveEffect(gCurrentMove) == EFFECT_DOODLE; @@ -10176,7 +10173,7 @@ static void Cmd_tryimprison(void) } else { - u8 battler; + enum BattlerId battler; for (battler = 0; battler < gBattlersCount; battler++) { @@ -10228,7 +10225,7 @@ static void Cmd_trysetvolatile(void) { CMD_ARGS(u8 battler, u8 _volatile, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetBattlerVolatile(battler, cmd->_volatile) != 0) { @@ -10295,7 +10292,7 @@ static void Cmd_switchoutabilities(void) { CMD_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleMons[battler].volatiles.neutralizingGas) { gBattleMons[battler].volatiles.neutralizingGas = FALSE; @@ -10344,7 +10341,7 @@ static void Cmd_jumpifhasnohp(void) { CMD_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (!IsBattlerAlive(battler)) gBattlescriptCurrInstr = cmd->jumpInstr; @@ -10499,7 +10496,7 @@ static void Cmd_settypebasedhalvers(void) gBattlescriptCurrInstr = cmd->failInstr; } -bool32 DoesSubstituteBlockMove(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 DoesSubstituteBlockMove(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (!gBattleMons[battlerDef].volatiles.substitute) return FALSE; @@ -10511,7 +10508,7 @@ bool32 DoesSubstituteBlockMove(u32 battlerAtk, u32 battlerDef, enum Move move) return TRUE; } -bool32 DoesDisguiseBlockMove(u32 battler, enum Move move) +bool32 DoesDisguiseBlockMove(enum BattlerId battler, enum Move move) { if (!IsMimikyuDisguised(battler) || gBattleMons[battler].volatiles.transformed @@ -10559,7 +10556,7 @@ static void Cmd_tryrecycleitem(void) } } -bool32 CanCamouflage(u8 battler) +bool32 CanCamouflage(enum BattlerId battler) { if (IS_BATTLER_OF_TYPE(battler, gBattleEnvironmentInfo[gBattleEnvironment].camouflageType)) return FALSE; @@ -10608,7 +10605,7 @@ static void Cmd_pursuitdoubles(void) { CMD_ARGS(const u8 *failInstr); - u32 battler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); + enum BattlerId battler = GetBattlerAtPosition(BATTLE_PARTNER(GetBattlerPosition(gBattlerAttacker))); if (IsDoubleBattle() && !(gAbsentBattlerFlags & (1u << battler)) @@ -11474,7 +11471,7 @@ static void Cmd_sortbattlers(void) CMD_ARGS(); if (!gBattleStruct->battlersSorted) { - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattlersBySpeed[i] = i; SortBattlersBySpeed(gBattlersBySpeed, FALSE); @@ -11506,7 +11503,7 @@ static void Cmd_trainerslideout(void) { CMD_ARGS(u8 position); - u32 battler = GetBattlerForBattleScript(cmd->position); + enum BattlerId battler = GetBattlerForBattleScript(cmd->position); BtlController_EmitTrainerSlideBack(battler, B_COMM_TO_CONTROLLER); MarkBattlerForControllerExec(battler); @@ -11675,7 +11672,7 @@ static void Cmd_callnative(void) // Callnative Funcs -void SaveBattlerTarget(u32 battler) +void SaveBattlerTarget(enum BattlerId battler) { assertf(gBattleStruct->savedTargetCount < ARRAY_COUNT(gBattleStruct->savedBattlerTarget), "Too many savedBattlerTargets") { @@ -11685,7 +11682,7 @@ void SaveBattlerTarget(u32 battler) gBattleStruct->savedBattlerTarget[gBattleStruct->savedTargetCount++] = battler; } -void SaveBattlerAttacker(u32 battler) +void SaveBattlerAttacker(enum BattlerId battler) { assertf(gBattleStruct->savedAttackerCount < ARRAY_COUNT(gBattleStruct->savedBattlerAttacker), "Too many savedBattlerAttackers") { @@ -11742,7 +11739,7 @@ void BS_JumpIfMoreThanHalfHP(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleMons[battler].hp > (gBattleMons[battler].maxHP + 1) / 2) gBattlescriptCurrInstr = cmd->jumpInstr; else @@ -11753,7 +11750,7 @@ void BS_DoStockpileStatChangesWearOff(void) { NATIVE_ARGS(u8 battler, const u8 *statChangeInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleMons[battler].volatiles.stockpileDef != 0) { SET_STATCHANGER(STAT_DEF, abs(gBattleMons[battler].volatiles.stockpileDef), TRUE); @@ -11850,9 +11847,9 @@ void BS_GetBattlerSide(void) void BS_TrySymbiosis(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); //called by Bestow, Fling, and Bug Bite, which don't work with Cmd_removeitem. - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId partner = BATTLE_PARTNER(battler); if (TryTriggerSymbiosis(battler, partner)) { BestowItem(partner, battler); @@ -11916,7 +11913,7 @@ static void TryUpdateRoundTurnOrder(void) } } -u8 GetFirstFaintedPartyIndex(u8 battler) +u8 GetFirstFaintedPartyIndex(enum BattlerId battler) { u32 i; u32 start = 0; @@ -11988,7 +11985,7 @@ void BS_ItemRestoreHP(void) { NATIVE_ARGS(const u8 *alreadyMaxHpInstr, const u8 *restoreBattlerInstr); u16 healAmount; - u32 battler = MAX_BATTLERS_COUNT; + enum BattlerId battler = MAX_BATTLERS_COUNT; u32 healParam = GetItemEffect(gLastUsedItem)[6]; struct Pokemon *party = GetBattlerParty(gBattlerAttacker); u16 hp = GetMonData(&party[gBattleStruct->itemPartyIndex[gBattlerAttacker]], MON_DATA_HP); @@ -12044,7 +12041,7 @@ void BS_ItemRestoreHP(void) hp += healAmount; SetMonData(&party[gBattleStruct->itemPartyIndex[gBattlerAttacker]], MON_DATA_HP, &hp); - u32 partner = BATTLE_PARTNER(gBattlerAttacker); + enum BattlerId partner = BATTLE_PARTNER(gBattlerAttacker); // Absent battlers on the field need to be replaced if (IsDoubleBattle() && (gAbsentBattlerFlags & (1u << partner))) { @@ -12126,7 +12123,7 @@ void BS_ItemRestorePP(void) NATIVE_ARGS(); const u8 *effect = GetItemEffect(gLastUsedItem); u32 i, pp, maxPP, moveId, loopEnd; - u32 battler = MAX_BATTLERS_COUNT; + enum BattlerId battler = MAX_BATTLERS_COUNT; struct Pokemon *mon = (IsOnPlayerSide(gBattlerAttacker)) ? &gPlayerParty[gBattleStruct->itemPartyIndex[gBattlerAttacker]] : &gEnemyParty[gBattleStruct->itemPartyIndex[gBattlerAttacker]]; // Check whether to apply to all moves. @@ -12192,7 +12189,7 @@ void BS_HandleMegaEvolution(void) { NATIVE_ARGS(u8 battler, u8 caseId); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); HandleScriptMegaPrimalBurst(cmd->caseId, battler, HANDLE_TYPE_MEGA_EVOLUTION); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -12201,7 +12198,7 @@ void BS_HandlePrimalReversion(void) { NATIVE_ARGS(u8 battler, u8 caseId); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); HandleScriptMegaPrimalBurst(cmd->caseId, battler, HANDLE_TYPE_PRIMAL_REVERSION); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -12210,7 +12207,7 @@ void BS_HandleUltraBurst(void) { NATIVE_ARGS(u8 battler, u8 caseId); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); HandleScriptMegaPrimalBurst(cmd->caseId, battler, HANDLE_TYPE_ULTRA_BURST); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -12219,7 +12216,7 @@ void BS_JumpIfShellTrap(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u8 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gProtectStructs[battler].shellTrap) gBattlescriptCurrInstr = cmd->jumpInstr; else @@ -12282,7 +12279,7 @@ void BS_SetTerrain(void) void BS_JumpIfTerrainAffected(void) { NATIVE_ARGS(u8 battler, u32 flags, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (IsBattlerTerrainAffected(battler, GetBattlerAbility(battler), GetBattlerHoldEffect(battler), gFieldStatuses, cmd->flags)) gBattlescriptCurrInstr = cmd->jumpInstr; @@ -12361,8 +12358,8 @@ void BS_SetPledge(void) { NATIVE_ARGS(const u8 *jumpInstr); - u32 partner = BATTLE_PARTNER(gBattlerAttacker); - u32 partnerMove = GetChosenMoveFromPosition(partner); + enum BattlerId partner = BATTLE_PARTNER(gBattlerAttacker); + enum Move partnerMove = GetBattlerChosenMove(partner); u32 i = 0; u32 k = 0; @@ -12441,7 +12438,7 @@ void BS_SetPledgeStatus(void) { NATIVE_ARGS(u8 battler, u32 sideStatus); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum BattleSide side = GetBattlerSide(battler); gBattleStruct->pledgeMove = FALSE; @@ -12717,7 +12714,7 @@ void BS_TryActivateGulpMissile(void) void BS_TryQuash(void) { NATIVE_ARGS(const u8 *failInstr); - u32 i, j; + enum BattlerId i, j; // It's true if foe is faster, has a bigger priority, or switches if (HasBattlerActedThisTurn(gBattlerTarget)) @@ -12757,7 +12754,7 @@ void BS_CopyFoesStatIncrease(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); u32 stat = 0; - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gQueuedStatBoosts[battler].stats == 0) { @@ -12863,7 +12860,7 @@ void BS_CanTarShotWork(void) void BS_JumpIfBlockedBySoundproof(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (IsSoundMove(gCurrentMove) && GetBattlerAbility(battler) == ABILITY_SOUNDPROOF) { gLastUsedAbility = ABILITY_SOUNDPROOF; @@ -12895,14 +12892,14 @@ void BS_JumpIfNoBerry(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetItemPocket(gBattleMons[battler].item) == POCKET_BERRIES) gBattlescriptCurrInstr = cmd->nextInstr; else gBattlescriptCurrInstr = cmd->jumpInstr; } -static bool32 IsTeatimeAffected(u32 battler) +static bool32 IsTeatimeAffected(enum BattlerId battler) { if (GetItemPocket(gBattleMons[battler].item) != POCKET_BERRIES) return FALSE; // Only berries @@ -12914,9 +12911,9 @@ static bool32 IsTeatimeAffected(u32 battler) void BS_CheckTeaTimeTargets(void) { NATIVE_ARGS(const u8 *failInstr); - u32 count = 0, i; + u32 count = 0; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsTeatimeAffected(i)) count++; @@ -12931,7 +12928,7 @@ void BS_TryWindRiderPower(void) { NATIVE_ARGS(u8 battler, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum Ability ability = GetBattlerAbility(battler); if (IsBattlerAlly(battler, gBattlerAttacker) && (ability == ABILITY_WIND_RIDER || ability == ABILITY_WIND_POWER)) @@ -12951,7 +12948,7 @@ void BS_ActivateWeatherChangeAbilities(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattlescriptCurrInstr = cmd->nextInstr; AbilityBattleEffects(ABILITYEFFECT_ON_WEATHER, battler, GetBattlerAbility(battler), MOVE_NONE, TRUE); } @@ -12960,7 +12957,7 @@ void BS_ActivateTerrainChangeAbilities(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattlescriptCurrInstr = cmd->nextInstr; AbilityBattleEffects(ABILITYEFFECT_ON_TERRAIN, battler, GetBattlerAbility(battler), MOVE_NONE, TRUE); } @@ -12969,7 +12966,7 @@ void BS_ResetTerrainAbilityFlags(void) { NATIVE_ARGS(); // reset terrain ability checks - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleMons[i].volatiles.terrainAbilityDone = 0; gBattlescriptCurrInstr = cmd->nextInstr; @@ -12979,7 +12976,7 @@ void BS_StoreHealingWish(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetMoveEffect(gCurrentMove) == EFFECT_LUNAR_DANCE) gBattleStruct->battlerState[battler].storedLunarDance = TRUE; else @@ -13013,7 +13010,7 @@ void BS_TryRevivalBlessing(void) if (IsDoubleBattle() && gBattlerPartyIndexes[BATTLE_PARTNER(gBattlerAttacker)] == gSelectedMonPartyId) { - u32 i = BATTLE_PARTNER(gBattlerAttacker); + enum BattlerId i = BATTLE_PARTNER(gBattlerAttacker); gAbsentBattlerFlags &= ~(1u << i); gBattleStruct->monToSwitchIntoId[i] = gSelectedMonPartyId; gBattleScripting.battler = i; @@ -13046,7 +13043,7 @@ void BS_JumpIfCommanderActive(void) static void UpdatePokeFlutePartyStatus(struct Pokemon* party, u8 position) { s32 i; - u8 battler; + enum BattlerId battler; u32 monToCheck, status; u16 species, abilityNum; monToCheck = 0; @@ -13076,8 +13073,7 @@ void BS_CheckPokeFlute(void) NATIVE_ARGS(); gBattleCommunication[MULTISTRING_CHOOSER] = 0; - s32 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (GetBattlerAbility(i) != ABILITY_SOUNDPROOF) { @@ -13439,7 +13435,7 @@ void BS_JumpIfIntimidateAbilityPrevented(void) void BS_JumpIfCanGigantamax(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetMonData(GetBattlerMon(battler), MON_DATA_GIGANTAMAX_FACTOR) && GetGMaxTargetSpecies(gBattleMons[battler].species) != SPECIES_NONE) @@ -13519,7 +13515,7 @@ void BS_TryBoosterEnergy(void) for (u32 orderNum = 0; orderNum < gBattlersCount; orderNum++) { - u32 battler = gBattlerByTurnOrder[orderNum]; + enum BattlerId battler = gBattlerByTurnOrder[orderNum]; enum HoldEffect holdEffect = GetBattlerHoldEffect(battler); if (holdEffect != HOLD_EFFECT_BOOSTER_ENERGY) continue; @@ -13539,7 +13535,7 @@ void BS_TryBoosterEnergy(void) void BS_JumpIfAbilityCantBeReactivated(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 ability = gBattleMons[battler].ability; switch (ability) @@ -13562,7 +13558,7 @@ void BS_JumpIfAbilityCantBeReactivated(void) void BS_TryActivateAbilityShield(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum Ability ability = GetBattlerAbility(battler); gBattlescriptCurrInstr = cmd->nextInstr; @@ -13610,7 +13606,7 @@ void BS_JumpIfAbsent(void) void BS_JumpIfHoldEffect(void) { NATIVE_ARGS(u8 battler, u8 holdEffect, const u8 *jumpInstr, u8 equal); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if ((GetBattlerHoldEffect(battler) == cmd->holdEffect) == cmd->equal) { if (cmd->equal) @@ -13628,7 +13624,7 @@ void BS_JumpIfHoldEffect(void) void BS_JumpIfNoAlly(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 partner = BATTLE_PARTNER(GetBattlerForBattleScript(cmd->battler)); + enum BattlerId partner = BATTLE_PARTNER(GetBattlerForBattleScript(cmd->battler)); if (!IsBattlerAlive(partner)) gBattlescriptCurrInstr = cmd->jumpInstr; else @@ -13730,7 +13726,7 @@ void BS_TryFriskMessage(void) void BS_SetTracedAbility(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattleMons[battler].ability = gBattleMons[battler].volatiles.overwrittenAbility = gBattleStruct->tracedAbility[battler]; gBattlescriptCurrInstr = cmd->nextInstr; } @@ -13738,7 +13734,7 @@ void BS_SetTracedAbility(void) void BS_TryIllusionOff(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (TryClearIllusion(battler, GetBattlerAbility(battler))) return; gBattlescriptCurrInstr = cmd->nextInstr; @@ -13747,7 +13743,7 @@ void BS_TryIllusionOff(void) void BS_UpdateNick(void) { NATIVE_ARGS(); - u32 battler = gBattleScripting.battler; + enum BattlerId battler = gBattleScripting.battler; UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], GetBattlerMon(battler), HEALTHBOX_NICK); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -13846,7 +13842,7 @@ void BS_UpdateChoiceMoveOnLvlUp(void) NATIVE_ARGS(); if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId || gBattlerPartyIndexes[2] == gBattleStruct->expGetterMonId) { - u32 battler; + enum BattlerId battler; if (gBattlerPartyIndexes[0] == gBattleStruct->expGetterMonId) battler = 0; else @@ -13869,8 +13865,8 @@ void BS_ResetPlayerFainted(void) NATIVE_ARGS(); if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_DOUBLE)) && gBattleTypeFlags & BATTLE_TYPE_TRAINER - && IsBattlerAlive(B_POSITION_PLAYER_LEFT) - && IsBattlerAlive(B_POSITION_OPPONENT_LEFT)) + && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)) + && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))) { gHitMarker &= ~HITMARKER_PLAYER_FAINTED; } @@ -13881,7 +13877,7 @@ void BS_PalaceFlavorText(void) { NATIVE_ARGS(); // Try and print end-of-turn Battle Palace flavor text (e.g. "A glint appears in mon's eyes") - u32 battler; + enum BattlerId battler; gBattleCommunication[0] = FALSE; // whether or not msg should be printed gBattleScripting.battler = battler = gBattleCommunication[1]; if (!(gBattleStruct->palaceFlags & (1u << battler)) @@ -13910,7 +13906,7 @@ void BS_ArenaJudgmentWindow(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static void SetArenMonLostValues(u32 battler, enum BattleSide side) +static void SetArenMonLostValues(enum BattlerId battler, enum BattleSide side) { gBattleMons[battler].hp = 0; gHitMarker |= HITMARKER_FAINTED(battler); @@ -14054,7 +14050,7 @@ void BS_PalaceTryEscapeStatus(void) void BS_SetTeleportOutcome(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); // Don't end the battle if one of the wild mons teleported from the wild double battle // and its partner is still alive. @@ -14096,7 +14092,7 @@ void BS_StatTextBuffer(void) void BS_SwitchinAbilities(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 ability = GetBattlerAbility(battler); gBattlescriptCurrInstr = cmd->nextInstr; AbilityBattleEffects(ABILITYEFFECT_TERA_SHIFT, battler, ability, MOVE_NONE, TRUE); @@ -14121,7 +14117,7 @@ void BS_InstantHpDrop(void) void BS_ClearStatus(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattleMons[battler].status1 = 0; BtlController_EmitSetMonData( battler, @@ -14137,7 +14133,7 @@ void BS_ClearStatus(void) void BS_RestoreMovePp(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 moveIndex; u32 data[MAX_MON_MOVES + 1]; for (moveIndex = 0; moveIndex < MAX_MON_MOVES; moveIndex++) @@ -14154,7 +14150,7 @@ void BS_RestoreMovePp(void) void BS_TryActivateReceiver(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattlerAbility = BATTLE_PARTNER(battler); u32 partnerAbility = GetBattlerAbility(gBattlerAbility); if (IsBattlerAlive(gBattlerAbility) @@ -14318,7 +14314,7 @@ void BS_TrySoak(void) void BS_HandleFormChange(void) { NATIVE_ARGS(u8 battler, u8 case_); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); struct Pokemon *mon = GetBattlerMon(battler); if (cmd->case_ == 0) // Change species. @@ -14469,7 +14465,7 @@ void BS_TryPsychoShift(void) void BS_CureStatus(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleMons[battler].status1 & STATUS1_SLEEP) TryDeactivateSleepClause(GetBattlerSide(battler), gBattlerPartyIndexes[battler]); @@ -14524,7 +14520,7 @@ void BS_TryBestow(void) void BS_HandleTrainerSlideMsg(void) { NATIVE_ARGS(u8 battler, u8 case_); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (cmd->case_ == PRINT_SLIDE_MESSAGE) { BtlController_EmitPrintString(battler, B_COMM_TO_CONTROLLER, STRINGID_TRAINERSLIDE); @@ -14537,7 +14533,7 @@ void BS_HandleTrainerSlideMsg(void) SetBattlerShadowSpriteCallback(battler, gBattleMons[battler].species); BattleLoadMonSpriteGfx(GetBattlerMon(battler), battler); } - u32 partner = BATTLE_PARTNER(battler); + enum BattlerId partner = BATTLE_PARTNER(battler); if (IsBattlerAlive(partner)) { SetBattlerShadowSpriteCallback(partner, gBattleMons[partner].species); @@ -14550,7 +14546,7 @@ void BS_HandleTrainerSlideMsg(void) void BS_TryTrainerSlideMsgFirstOff(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 shouldDoTrainerSlide = 0; if ((shouldDoTrainerSlide = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_PLAYER_LANDS_FIRST_DOWN))) { @@ -14581,7 +14577,7 @@ void BS_TryTrainerSlideMsgLastOn(void) { NATIVE_ARGS(u8 battler); u32 shouldDoTrainerSlide = 0; - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if ((shouldDoTrainerSlide = ShouldDoTrainerSlide(battler, TRAINER_SLIDE_LAST_SWITCHIN))) { gBattleScripting.battler = battler; @@ -14652,7 +14648,7 @@ void BS_TryThirdType(void) void BS_DestroyAbilityPopup(void) { NATIVE_ARGS(); - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) DestroyAbilityPopUp(battler); gBattlescriptCurrInstr = cmd->nextInstr; } @@ -14660,7 +14656,7 @@ void BS_DestroyAbilityPopup(void) void BS_GetTotemBoost(void) { NATIVE_ARGS(const u8 *jumpInstr); - u32 battler = gBattlerAttacker; + enum BattlerId battler = gBattlerAttacker; if (gQueuedStatBoosts[battler].stats == 0) { gBattlescriptCurrInstr = cmd->nextInstr; // stats done, exit @@ -14698,7 +14694,7 @@ void BS_GetTotemBoost(void) void BS_ActivateItemEffects(void) { NATIVE_ARGS(); - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (!IsBattlerAlive(battler)) continue; @@ -14712,7 +14708,7 @@ void BS_ActivateItemEffects(void) void BS_TryRoomService(void) { NATIVE_ARGS(u8 battler, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum HoldEffect holdEffect = GetBattlerHoldEffect(battler); if (holdEffect == HOLD_EFFECT_ROOM_SERVICE && ItemBattleEffects(battler, 0, holdEffect, IsOnEffectActivation)) return; @@ -14722,7 +14718,7 @@ void BS_TryRoomService(void) void BS_TryTerrainSeed(void) { NATIVE_ARGS(u8 battler, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); enum HoldEffect holdEffect = GetBattlerHoldEffect(battler); if (holdEffect == HOLD_EFFECT_TERRAIN_SEED && ItemBattleEffects(battler, 0, holdEffect, IsOnEffectActivation)) return; @@ -14732,7 +14728,7 @@ void BS_TryTerrainSeed(void) void BS_MakeInvisible(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (gBattleControllerExecFlags) return; @@ -14745,10 +14741,10 @@ void BS_MakeInvisible(void) void BS_JumpIfTeamHealthy(void) { NATIVE_ARGS(const u8 *jumpInstr); - u32 battler = gBattlerAttacker; + enum BattlerId battler = gBattlerAttacker; if ((IsDoubleBattle()) && IsBattlerAlive(BATTLE_PARTNER(battler))) { - u8 partner = BATTLE_PARTNER(battler); + enum BattlerId 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; @@ -14767,7 +14763,7 @@ void BS_JumpIfTeamHealthy(void) void BS_TryHealQuarterHealth(void) { NATIVE_ARGS(u8 battler, const u8 *failInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); SetHealAmount(battler, GetNonDynamaxMaxHP(battler) / 4); if (gBattleMons[battler].hp == gBattleMons[battler].maxHP) gBattlescriptCurrInstr = cmd->failInstr; // fail @@ -14876,7 +14872,7 @@ void BS_TryToClearPrimalWeather(void) NATIVE_ARGS(); bool32 shouldNotClear = FALSE; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { enum Ability ability = GetBattlerAbility(i); if (((ability == ABILITY_DESOLATE_LAND && gBattleWeather & B_WEATHER_SUN_PRIMAL) @@ -14924,7 +14920,7 @@ void BS_TryEndNeutralizingGas(void) gBattlescriptCurrInstr = cmd->nextInstr; } -static bool32 IsRototillerAffected(u32 battler, u32 move) +static bool32 IsRototillerAffected(enum BattlerId battler, u32 move) { if (IsBattlerUnaffectedByMove(battler)) return FALSE; @@ -14940,7 +14936,7 @@ void BS_GetRototillerTargets(void) NATIVE_ARGS(const u8 *failInstr); u32 count = 0; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (IsRototillerAffected(battler, gCurrentMove)) count++; @@ -14958,7 +14954,7 @@ void BS_GetRototillerTargets(void) void BS_ConsumeBerry(void) { NATIVE_ARGS(u8 battler, bool8 fromBattler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (cmd->fromBattler) gLastUsedItem = gBattleMons[battler].item; @@ -15010,7 +15006,7 @@ void BS_JumpIfSpecies(void) void BS_JumpIfAbilityPreventsRest(void) { NATIVE_ARGS(u8 battler, const u8 *jumpInstr); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); u32 ability = GetBattlerAbility(battler); if (GetConfig(CONFIG_LEAF_GUARD_PREVENTS_REST) >= GEN_5 && IsLeafGuardProtected(battler, ability)) gBattlescriptCurrInstr = cmd->jumpInstr; @@ -15108,7 +15104,7 @@ void BS_TryActivateAbilityWithAbilityShield(void) { NATIVE_ARGS(u8 battler, bool8 switchedItems); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); gBattlescriptCurrInstr = cmd->nextInstr; @@ -15144,7 +15140,7 @@ void BS_TryActivateAbilityWithAbilityShield(void) void BS_UpdateDynamax(void) { NATIVE_ARGS(); - u32 battler = gBattleScripting.battler; + enum BattlerId battler = gBattleScripting.battler; struct Pokemon *mon = GetBattlerMon(battler); if (!IsGigantamaxed(battler)) // RecalcBattlerStats will get called on form change. @@ -15167,7 +15163,7 @@ void BS_JumpIfDynamaxed(void) void BS_UndoDynamax(void) { NATIVE_ARGS(u8 battler); - u32 battler = GetBattlerForBattleScript(cmd->battler); + enum BattlerId battler = GetBattlerForBattleScript(cmd->battler); if (GetActiveGimmick(battler) == GIMMICK_DYNAMAX) { diff --git a/src/battle_switch_in.c b/src/battle_switch_in.c index 681007b552..5247e6594d 100644 --- a/src/battle_switch_in.c +++ b/src/battle_switch_in.c @@ -10,12 +10,12 @@ #include "constants/moves.h" static bool32 FirstEventBlockEvents(struct BattleCalcValues *calcValues); -static bool32 TryHazardsOnSwitchIn(u32 battler, enum Ability ability, enum HoldEffect holdEffect, enum Hazards hazardType); +static bool32 TryHazardsOnSwitchIn(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, enum Hazards hazardType); static bool32 SecondEventBlockEvents(struct BattleCalcValues *calcValues); bool32 DoSwitchInEvents(void) { - u32 battler; + enum BattlerId battler; struct BattleCalcValues calcValues = {0}; for (battler = 0; battler < gBattlersCount; battler++) @@ -29,7 +29,7 @@ bool32 DoSwitchInEvents(void) switch (gBattleStruct->eventState.switchIn) { case SWITCH_IN_EVENTS_ORDER_BY_SPEED: - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattlersBySpeed[i] = i; SortBattlersBySpeed(gBattlersBySpeed, FALSE); gBattleStruct->battlersSorted = TRUE; @@ -120,7 +120,7 @@ bool32 DoSwitchInEvents(void) case SWITCH_IN_EVENTS_WHITE_HERB: while (gBattleStruct->switchInBattlerCounter < gBattlersCount) { - u32 battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; + enum BattlerId battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; if (ItemBattleEffects(battler, 0, calcValues.holdEffects[battler], IsWhiteHerbActivation)) return TRUE; } @@ -130,7 +130,7 @@ bool32 DoSwitchInEvents(void) case SWITCH_IN_EVENTS_OPPORTUNIST: while (gBattleStruct->switchInBattlerCounter < gBattlersCount) { - u32 battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; + enum BattlerId battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; if (AbilityBattleEffects(ABILITYEFFECT_OPPORTUNIST, battler, calcValues.abilities[battler], 0, TRUE)) return TRUE; } @@ -140,7 +140,7 @@ bool32 DoSwitchInEvents(void) case SWITCH_IN_EVENTS_MIRROR_HERB: while (gBattleStruct->switchInBattlerCounter < gBattlersCount) { - u32 battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; + enum BattlerId battler = gBattlersBySpeed[gBattleStruct->switchInBattlerCounter++]; if (ItemBattleEffects(battler, 0, GetBattlerHoldEffect(battler), IsMirrorHerbActivation)) return TRUE; } @@ -171,7 +171,7 @@ bool32 DoSwitchInEvents(void) return FALSE; } -static bool32 CanBattlerBeHealed(u32 battler) +static bool32 CanBattlerBeHealed(enum BattlerId battler) { if (GetConfig(CONFIG_HEALING_WISH_SWITCH) < GEN_8) return TRUE; @@ -194,7 +194,7 @@ static bool32 CanBattlerBeHealed(u32 battler) static bool32 FirstEventBlockEvents(struct BattleCalcValues *calcValues) { bool32 effect = FALSE; - u32 battler = calcValues->battlerAtk; + enum BattlerId battler = calcValues->battlerAtk; switch (gBattleStruct->eventState.battlerSwitchIn) { @@ -282,14 +282,14 @@ static bool32 FirstEventBlockEvents(struct BattleCalcValues *calcValues) return effect; } -static void SetDmgHazardsBattlescript(u8 battler, u8 multistringId) +static void SetDmgHazardsBattlescript(enum BattlerId battler, u8 multistringId) { gBattleScripting.battler = battler; gBattleCommunication[MULTISTRING_CHOOSER] = multistringId; BattleScriptCall(BattleScript_DmgHazardsOnBattler); } -static bool32 TryHazardsOnSwitchIn(u32 battler, enum Ability ability, enum HoldEffect holdEffect, enum Hazards hazardType) +static bool32 TryHazardsOnSwitchIn(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, enum Hazards hazardType) { bool32 effect = FALSE; enum BattleSide side = GetBattlerSide(battler); @@ -389,7 +389,7 @@ static bool32 TryHazardsOnSwitchIn(u32 battler, enum Ability ability, enum HoldE static bool32 SecondEventBlockEvents(struct BattleCalcValues *calcValues) { bool32 effect = FALSE; - u32 battler = calcValues->battlerAtk; + enum BattlerId battler = calcValues->battlerAtk; switch (gBattleStruct->eventState.battlerSwitchIn) { diff --git a/src/battle_terastal.c b/src/battle_terastal.c index fa0612c0d4..400f7f59e7 100644 --- a/src/battle_terastal.c +++ b/src/battle_terastal.c @@ -17,7 +17,7 @@ #include "constants/rgb.h" // Sets flags and variables upon a battler's Terastallization. -void ActivateTera(u32 battler) +void ActivateTera(enum BattlerId battler) { // Set appropriate flags. SetActiveGimmick(battler, GIMMICK_TERA); @@ -44,7 +44,7 @@ void ActivateTera(u32 battler) } // Applies palette blend and enables UI indicator after animation has played -void ApplyBattlerVisualsForTeraAnim(u32 battler) +void ApplyBattlerVisualsForTeraAnim(enum BattlerId battler) { struct Pokemon *party = GetBattlerParty(battler); u32 index = gBattlerPartyIndexes[battler]; @@ -59,7 +59,7 @@ void ApplyBattlerVisualsForTeraAnim(u32 battler) } // Returns whether a battler can Terastallize. -bool32 CanTerastallize(u32 battler) +bool32 CanTerastallize(enum BattlerId battler) { enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); @@ -108,20 +108,20 @@ bool32 CanTerastallize(u32 battler) } // Returns a battler's Tera type. -enum Type GetBattlerTeraType(u32 battler) +enum Type GetBattlerTeraType(enum BattlerId battler) { return GetMonData(GetBattlerMon(battler), MON_DATA_TERA_TYPE); } // Uses up a type's Stellar boost. -void ExpendTypeStellarBoost(u32 battler, enum Type type) +void ExpendTypeStellarBoost(enum BattlerId battler, enum Type type) { if (type < 32 && gBattleMons[battler].species != SPECIES_TERAPAGOS_STELLAR) // avoid OOB access gBattleStruct->stellarBoostFlags[GetBattlerSide(battler)] |= 1u << type; } // Checks whether a type's Stellar boost has been expended. -bool32 IsTypeStellarBoosted(u32 battler, enum Type type) +bool32 IsTypeStellarBoosted(enum BattlerId battler, enum Type type) { if (type < 32) // avoid OOB access return !(gBattleStruct->stellarBoostFlags[GetBattlerSide(battler)] & (1u << type)); diff --git a/src/battle_tv.c b/src/battle_tv.c index 8df7ff48bf..c0673b6e7b 100644 --- a/src/battle_tv.c +++ b/src/battle_tv.c @@ -1394,7 +1394,7 @@ void BattleTv_ClearExplosionFaintCause(void) } } -u8 GetBattlerMoveSlotId(u8 battler, enum Move move) +u8 GetBattlerMoveSlotId(enum BattlerId battler, enum Move move) { s32 i; struct Pokemon *mon = GetBattlerMon(battler); diff --git a/src/battle_util.c b/src/battle_util.c index d9abfec976..7614b01133 100644 --- a/src/battle_util.c +++ b/src/battle_util.c @@ -53,19 +53,19 @@ #include "constants/weather.h" #include "constants/pokemon.h" -static bool32 TryRemoveScreens(u32 battler); -static bool32 IsUnnerveAbilityOnOpposingSide(u32 battler); +static bool32 TryRemoveScreens(enum BattlerId battler); +static bool32 IsUnnerveAbilityOnOpposingSide(enum BattlerId battler); static u32 GetFlingPowerFromItemId(enum Item itemId); -static bool32 IsNonVolatileStatusBlocked(u32 battlerDef, enum Ability abilityDef, bool32 abilityAffected, const u8 *battleScript, enum ResultOption option); -static bool32 CanSleepDueToSleepClause(u32 battlerAtk, u32 battlerDef, enum ResultOption option); -static bool32 IsOpposingSideEmpty(u32 battler); -static void ResetParadoxWeatherStat(u32 battler); -static void ResetParadoxTerrainStat(u32 battler); -static bool32 CanBattlerFormChange(u32 battler, enum FormChanges method); +static bool32 IsNonVolatileStatusBlocked(enum BattlerId battlerDef, enum Ability abilityDef, bool32 abilityAffected, const u8 *battleScript, enum ResultOption option); +static bool32 CanSleepDueToSleepClause(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum ResultOption option); +static bool32 IsOpposingSideEmpty(enum BattlerId battler); +static void ResetParadoxWeatherStat(enum BattlerId battler); +static void ResetParadoxTerrainStat(enum BattlerId battler); +static bool32 CanBattlerFormChange(enum BattlerId battler, enum FormChanges method); static bool32 IsPowderMoveBlocked(struct BattleContext *ctx); -const u8 *AbsorbedByDrainHpAbility(u32 battlerDef); -const u8 *AbsorbedByStatIncreaseAbility(u32 battlerDef, enum Ability abilityDef, enum Stat statId, u32 statAmount); -const u8 *AbsorbedByFlashFire(u32 battlerDef); +const u8 *AbsorbedByDrainHpAbility(enum BattlerId battlerDef); +const u8 *AbsorbedByStatIncreaseAbility(enum BattlerId battlerDef, enum Ability abilityDef, enum Stat statId, u32 statAmount); +const u8 *AbsorbedByFlashFire(enum BattlerId battlerDef); ARM_FUNC NOINLINE static uq4_12_t PercentToUQ4_12(u32 percent); ARM_FUNC NOINLINE static uq4_12_t PercentToUQ4_12_Floored(u32 percent); @@ -249,7 +249,7 @@ bool32 EndOrContinueWeather(void) if (gBattleStruct->weatherDuration > 0 && --gBattleStruct->weatherDuration == 0) { gBattleWeather = B_WEATHER_NONE; - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { gBattleMons[battler].volatiles.weatherAbilityDone = FALSE; ResetParadoxWeatherStat(battler); @@ -301,7 +301,7 @@ static s32 CalcBeatUpDamage(struct BattleContext *ctx) return dmg; } -enum DamageCategory GetReflectDamageMoveDamageCategory(u32 battler, enum Move move) +enum DamageCategory GetReflectDamageMoveDamageCategory(enum BattlerId battler, enum Move move) { u32 damageCategories = GetMoveReflectDamage_DamageCategories(move); @@ -317,7 +317,7 @@ enum DamageCategory GetReflectDamageMoveDamageCategory(u32 battler, enum Move mo return DAMAGE_CATEGORY_PHYSICAL; } -static bool32 ShouldTeraShellDistortTypeMatchups(enum Move move, u32 battlerDef, enum Ability abilityDef) +static bool32 ShouldTeraShellDistortTypeMatchups(enum Move move, enum BattlerId battlerDef, enum Ability abilityDef) { if (!gSpecialStatuses[battlerDef].distortedTypeMatchups && gBattleMons[battlerDef].species == SPECIES_TERAPAGOS_TERASTAL @@ -329,7 +329,7 @@ static bool32 ShouldTeraShellDistortTypeMatchups(enum Move move, u32 battlerDef, return FALSE; } -bool32 IsUnnerveBlocked(u32 battler, enum Item itemId) +bool32 IsUnnerveBlocked(enum BattlerId battler, enum Item itemId) { if (GetItemPocket(itemId) != POCKET_BERRIES) return FALSE; @@ -343,9 +343,9 @@ bool32 IsUnnerveBlocked(u32 battler, enum Item itemId) return FALSE; } -static bool32 IsUnnerveAbilityOnOpposingSide(u32 battler) +static bool32 IsUnnerveAbilityOnOpposingSide(enum BattlerId battler) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (battler == battlerDef || IsBattlerAlly(battler, battlerDef)) continue; @@ -368,7 +368,7 @@ static bool32 IsUnnerveAbilityOnOpposingSide(u32 battler) return FALSE; } -static inline bool32 IsDragonDartsSecondHit(u32 battlerAtk, enum Move move) +static inline bool32 IsDragonDartsSecondHit(enum BattlerId battlerAtk, enum Move move) { if (GetBattlerMoveTargetType(battlerAtk, move) != TARGET_SMART) return FALSE; @@ -379,7 +379,7 @@ static inline bool32 IsDragonDartsSecondHit(u32 battlerAtk, enum Move move) return FALSE; } -bool32 IsAffectedByFollowMe(u32 battlerAtk, enum BattleSide defSide, enum Move move) +bool32 IsAffectedByFollowMe(enum BattlerId battlerAtk, enum BattleSide defSide, enum Move move) { enum Ability ability = GetBattlerAbility(battlerAtk); enum BattleMoveEffects effect = GetMoveEffect(move); @@ -440,7 +440,7 @@ static bool32 HandleMoveTargetRedirection(void) { // Find first battler that redirects the move (in turn order) enum Ability abilityAtk = GetBattlerAbility(gBattlerAttacker); - u32 battler; + enum BattlerId battler; for (battler = 0; battler < gBattlersCount; battler++) { ability = GetBattlerAbility(battler); @@ -534,7 +534,8 @@ static bool32 WasOriginalTargetAlly(enum MoveTarget target) // Functions void HandleAction_UseMove(void) { - u32 i, moveTarget; + u32 i; + enum MoveTarget moveTarget; gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber]; if (gAbsentBattlerFlags & 1u << gBattlerAttacker @@ -710,7 +711,7 @@ void HandleAction_UseItem(void) gCurrentActionFuncId = B_ACTION_EXEC_SCRIPT; } -bool32 TryRunFromBattle(u32 battler) +bool32 TryRunFromBattle(enum BattlerId battler) { bool32 effect = FALSE; u8 holdEffect; @@ -769,7 +770,7 @@ bool32 TryRunFromBattle(u32 battler) } else { - u8 runningFromBattler = BATTLE_OPPOSITE(battler); + enum BattlerId runningFromBattler = BATTLE_OPPOSITE(battler); if (!IsBattlerAlive(runningFromBattler)) runningFromBattler |= BIT_FLANK; @@ -805,14 +806,12 @@ bool32 TryRunFromBattle(u32 battler) void HandleAction_Run(void) { - s32 i; - gBattlerAttacker = gBattlerByTurnOrder[gCurrentTurnActionNumber]; if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK)) { gCurrentTurnActionNumber = gBattlersCount; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsOnPlayerSide(i)) { @@ -1013,10 +1012,10 @@ void HandleAction_ActionFinished(void) // taken action. It's been previously increased, which we want in order to not recalculate the turn of the mon that just finished its action struct BattleCalcValues calcValues = {0}; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { - calcValues.abilities[i] = GetBattlerAbility(i); - calcValues.holdEffects[i] = GetBattlerHoldEffect(i); + calcValues.abilities[battler] = GetBattlerAbility(battler); + calcValues.holdEffects[battler] = GetBattlerHoldEffect(battler); } for (i = gCurrentTurnActionNumber; i < gBattlersCount - 1; i++) { @@ -1063,9 +1062,9 @@ static inline uq4_12_t PercentToUQ4_12AddOne(u32 percent) return uq4_12_add(UQ_4_12(1.0), PercentToUQ4_12(percent)); } -u8 GetBattlerForBattleScript(u8 caseId) +enum BattlerId GetBattlerForBattleScript(u8 caseId) { - u8 ret = 0; + enum BattlerId ret = 0; switch (caseId) { case BS_TARGET: @@ -1119,7 +1118,7 @@ u8 GetBattlerForBattleScript(u8 caseId) static void UNUSED MarkAllBattlersForControllerExec(void) { - int i; + enum BattlerId i; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { @@ -1133,7 +1132,7 @@ static void UNUSED MarkAllBattlersForControllerExec(void) } } -bool32 IsBattlerMarkedForControllerExec(u32 battler) +bool32 IsBattlerMarkedForControllerExec(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK) return IsBattleControllerMessageSynchronizedOverLink(battler); @@ -1141,7 +1140,7 @@ bool32 IsBattlerMarkedForControllerExec(u32 battler) return IsBattleControllerActiveOnLocal(battler); } -void MarkBattlerForControllerExec(u32 battler) +void MarkBattlerForControllerExec(enum BattlerId battler) { if (gBattleTypeFlags & BATTLE_TYPE_LINK) MarkBattleControllerMessageOutboundOverLink(battler); @@ -1149,7 +1148,7 @@ void MarkBattlerForControllerExec(u32 battler) MarkBattleControllerActiveOnLocal(battler); } -void MarkBattlerReceivedLinkData(u32 battler) +void MarkBattlerReceivedLinkData(enum BattlerId battler) { s32 i; @@ -1159,7 +1158,7 @@ void MarkBattlerReceivedLinkData(u32 battler) MarkBattleControllerMessageSynchronizedOverLink(battler); } -const u8 *CheckSkyDropState(u32 battler, enum SkyDropState skyDropState) +const u8 *CheckSkyDropState(enum BattlerId battler, enum SkyDropState skyDropState) { const u8 *result = NULL; @@ -1219,7 +1218,7 @@ const u8 *CheckSkyDropState(u32 battler, enum SkyDropState skyDropState) return result; } -const u8 *CancelMultiTurnMoves(u32 battler, enum SkyDropState skyDropState) +const u8 *CancelMultiTurnMoves(enum BattlerId battler, enum SkyDropState skyDropState) { const u8 *result = NULL; gBattleMons[battler].volatiles.uproarTurns = 0; @@ -1251,7 +1250,7 @@ const u8 *CancelMultiTurnMoves(u32 battler, enum SkyDropState skyDropState) // Returns TRUE if no other battler after this one in turn order will use a move -bool32 IsLastMonToMove(u32 battler) +bool32 IsLastMonToMove(enum BattlerId battler) { u32 i; u32 battlerTurnOrderNum = GetBattlerTurnOrderNum(battler); @@ -1261,7 +1260,7 @@ bool32 IsLastMonToMove(u32 battler) for (i = battlerTurnOrderNum + 1; i < gBattlersCount; i++) { - u32 otherBattler = gBattlerByTurnOrder[i]; + enum BattlerId otherBattler = gBattlerByTurnOrder[i]; if (!IsBattlerAlive(otherBattler)) continue; if (gActionsByTurnOrder[i] == B_ACTION_USE_MOVE) @@ -1270,7 +1269,7 @@ bool32 IsLastMonToMove(u32 battler) return TRUE; } -bool32 ShouldDefiantCompetitiveActivate(u32 battler, enum Ability ability) +bool32 ShouldDefiantCompetitiveActivate(enum BattlerId battler, enum Ability ability) { enum BattleSide side = GetBattlerSide(battler); if (ability != ABILITY_DEFIANT && ability != ABILITY_COMPETITIVE) @@ -1285,7 +1284,7 @@ bool32 ShouldDefiantCompetitiveActivate(u32 battler, enum Ability ability) return gSideTimers[side].stickyWebBattlerSide != side; } -void PrepareStringBattle(enum StringID stringId, u32 battler) +void PrepareStringBattle(enum StringID stringId, enum BattlerId battler) { u16 battlerAbility = GetBattlerAbility(battler); u16 targetAbility = GetBattlerAbility(gBattlerTarget); @@ -1368,7 +1367,7 @@ void ResetSentPokesToOpponentValue(void) gSentPokesToOpponent[(i & BIT_FLANK) >> 1] = bits; } -void OpponentSwitchInResetSentPokesToOpponentValue(u32 battler) +void OpponentSwitchInResetSentPokesToOpponentValue(enum BattlerId battler) { s32 i = 0; u32 bits = 0; @@ -1387,7 +1386,7 @@ void OpponentSwitchInResetSentPokesToOpponentValue(u32 battler) } } -void UpdateSentPokesToOpponentValue(u32 battler) +void UpdateSentPokesToOpponentValue(enum BattlerId battler) { if (!IsOnPlayerSide(battler)) { @@ -1448,7 +1447,7 @@ bool32 IsGravityPreventingMove(enum Move move) return IsMoveGravityBanned(move); } -bool32 IsHealBlockPreventingMove(u32 battler, enum Move move) +bool32 IsHealBlockPreventingMove(enum BattlerId battler, enum Move move) { if (!gBattleMons[battler].volatiles.healBlock) return FALSE; @@ -1456,7 +1455,7 @@ bool32 IsHealBlockPreventingMove(u32 battler, enum Move move) return IsHealingMove(move); } -bool32 IsBelchPreventingMove(u32 battler, enum Move move) +bool32 IsBelchPreventingMove(enum BattlerId battler, enum Move move) { if (GetMoveEffect(move) != EFFECT_BELCH) return FALSE; @@ -1467,7 +1466,7 @@ bool32 IsBelchPreventingMove(u32 battler, enum Move move) // Dynamax bypasses all selection prevention except Taunt and Assault Vest. #define DYNAMAX_BYPASS_CHECK (!IsGimmickSelected(battler, GIMMICK_DYNAMAX) && GetActiveGimmick(battler) != GIMMICK_DYNAMAX) -u32 TrySetCantSelectMoveBattleScript(u32 battler) +u32 TrySetCantSelectMoveBattleScript(enum BattlerId battler) { u32 limitations = 0; u8 moveId = gBattleResources->bufferB[battler][2] & ~RET_GIMMICK; @@ -1730,7 +1729,7 @@ u32 TrySetCantSelectMoveBattleScript(u32 battler) return limitations; } -u32 CheckMoveLimitations(u32 battler, u8 unusableMoves, u16 check) +u32 CheckMoveLimitations(enum BattlerId battler, u8 unusableMoves, u16 check) { enum Move move; enum BattleMoveEffects moveEffect; @@ -1800,7 +1799,7 @@ u32 CheckMoveLimitations(u32 battler, u8 unusableMoves, u16 check) } #define ALL_MOVES_MASK ((1 << MAX_MON_MOVES) - 1) -bool32 AreAllMovesUnusable(u32 battler) +bool32 AreAllMovesUnusable(enum BattlerId battler) { u32 unusable = CheckMoveLimitations(battler, 0, MOVE_LIMITATIONS_ALL); @@ -1817,7 +1816,7 @@ bool32 AreAllMovesUnusable(u32 battler) return (unusable == ALL_MOVES_MASK); } -u8 GetImprisonedMovesCount(u32 battler, enum Move move) +u8 GetImprisonedMovesCount(enum BattlerId battler, enum Move move) { s32 i; u8 imprisonedMoves = 0; @@ -1841,7 +1840,7 @@ u8 GetImprisonedMovesCount(u32 battler, enum Move move) return imprisonedMoves; } -u32 GetBattlerAffectionHearts(u32 battler) +u32 GetBattlerAffectionHearts(enum BattlerId battler) { struct Pokemon *mon = GetBattlerMon(battler); u16 species = GetMonData(mon, MON_DATA_SPECIES); @@ -1873,7 +1872,7 @@ bool32 MoodyCantLowerStat(u32 stat) void TryToRevertMimicryAndFlags(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { gBattleMons[battler].volatiles.terrainAbilityDone = FALSE; ResetParadoxTerrainStat(battler); @@ -1886,9 +1885,9 @@ bool32 BattleArenaTurnEnd(void) { if ((gBattleTypeFlags & BATTLE_TYPE_ARENA) && gBattleStruct->eventState.arenaTurn == 2 - && IsBattlerAlive(B_POSITION_PLAYER_LEFT) && IsBattlerAlive(B_POSITION_OPPONENT_LEFT)) + && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)) && IsBattlerAlive(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))) { - for (u32 battler = 0; battler < 2; battler++) + for (enum BattlerId battler = 0; battler < 2; battler++) CancelMultiTurnMoves(battler, SKY_DROP_IGNORE); gBattlescriptCurrInstr = BattleScript_ArenaDoJudgment; @@ -1899,7 +1898,7 @@ bool32 BattleArenaTurnEnd(void) } // Ingrain, Leech Seed, Strength Sap and Aqua Ring -s32 GetDrainedBigRootHp(u32 battler, s32 hp) +s32 GetDrainedBigRootHp(enum BattlerId battler, s32 hp) { if (GetBattlerHoldEffect(battler) == HOLD_EFFECT_BIG_ROOT) hp = (hp * 1300) / 1000; @@ -1910,7 +1909,7 @@ s32 GetDrainedBigRootHp(u32 battler, s32 hp) } // Should always be the last check. Otherwise the ability might be wrongly recorded. -bool32 IsAbilityAndRecord(u32 battler, enum Ability battlerAbility, enum Ability abilityToCheck) +bool32 IsAbilityAndRecord(enum BattlerId battler, enum Ability battlerAbility, enum Ability abilityToCheck) { if (battlerAbility != abilityToCheck) return FALSE; @@ -1926,13 +1925,12 @@ bool32 HandleFaintedMonActions(void) do { - s32 i; switch (gBattleStruct->eventState.faintedAction) { case FAINTED_ACTIONS_NO_MONS_TO_SWITCH: gBattleStruct->eventState.faintedActionBattler = 0; gBattleStruct->eventState.faintedAction++; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gAbsentBattlerFlags & (1u << i) && !HasNoMonsToSwitch(i, PARTY_SIZE, PARTY_SIZE)) gAbsentBattlerFlags &= ~(1u << i); @@ -2011,15 +2009,14 @@ bool32 HandleFaintedMonActions(void) void TryClearRageAndFuryCutter(void) { - s32 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (!MoveHasAdditionalEffect(gChosenMoveByBattler[i], MOVE_EFFECT_RAGE)) gBattleMons[i].volatiles.rage = FALSE; } } -bool32 HasNoMonsToSwitch(u32 battler, u8 partyIdBattlerOn1, u8 partyIdBattlerOn2) +bool32 HasNoMonsToSwitch(enum BattlerId battler, u8 partyIdBattlerOn1, u8 partyIdBattlerOn2) { u32 i, playerId, flankId; struct Pokemon *party; @@ -2177,7 +2174,7 @@ bool32 HasNoMonsToSwitch(u32 battler, u8 partyIdBattlerOn1, u8 partyIdBattlerOn2 } } -bool32 TryChangeBattleWeather(u32 battler, u32 battleWeatherId, enum Ability ability) +bool32 TryChangeBattleWeather(enum BattlerId battler, u32 battleWeatherId, enum Ability ability) { if (gBattleWeather & sBattleWeatherInfo[battleWeatherId].flag) return FALSE; @@ -2217,7 +2214,7 @@ bool32 TryChangeBattleWeather(u32 battler, u32 battleWeatherId, enum Ability abi gBattleCommunication[MULTISTRING_CHOOSER] = sBattleWeatherInfo[battleWeatherId].moveStartMessage; } - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { gBattleMons[i].volatiles.weatherAbilityDone = FALSE; ResetParadoxWeatherStat(i); @@ -2226,7 +2223,7 @@ bool32 TryChangeBattleWeather(u32 battler, u32 battleWeatherId, enum Ability abi return TRUE; } -bool32 TryChangeBattleTerrain(u32 battler, u32 statusFlag) +bool32 TryChangeBattleTerrain(enum BattlerId battler, u32 statusFlag) { if (gBattleStruct->isSkyBattle) return FALSE; @@ -2235,7 +2232,7 @@ bool32 TryChangeBattleTerrain(u32 battler, u32 statusFlag) { gFieldStatuses &= ~STATUS_FIELD_TERRAIN_ANY; gFieldStatuses |= statusFlag; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { gBattleMons[i].volatiles.terrainAbilityDone = FALSE; ResetParadoxTerrainStat(i); @@ -2251,10 +2248,10 @@ bool32 TryChangeBattleTerrain(u32 battler, u32 statusFlag) return FALSE; } -static void ForewarnChooseMove(u32 battler) +static void ForewarnChooseMove(enum BattlerId battler) { struct Forewarn { - u8 battler; + enum BattlerId battler; u8 power; u16 moveId; }; @@ -2310,7 +2307,7 @@ static void ForewarnChooseMove(u32 battler) Free(data); } -bool32 ChangeTypeBasedOnTerrain(u32 battler) +bool32 ChangeTypeBasedOnTerrain(enum BattlerId battler) { enum Type battlerType; @@ -2335,29 +2332,29 @@ static inline u8 GetSideFaintCounter(enum BattleSide side) return (side == B_SIDE_PLAYER) ? gBattleResults.playerFaintCounter : gBattleResults.opponentFaintCounter; } -static inline u8 GetBattlerSideFaintCounter(u32 battler) +static inline u8 GetBattlerSideFaintCounter(enum BattlerId battler) { return GetSideFaintCounter(GetBattlerSide(battler)); } // Supreme Overlord adds a x0.1 damage boost for each fainted ally. -static inline uq4_12_t GetSupremeOverlordModifier(u32 battler) +static inline uq4_12_t GetSupremeOverlordModifier(enum BattlerId battler) { return UQ_4_12(1.0) + (PercentToUQ4_12(gBattleStruct->supremeOverlordCounter[battler] * 10)); } -bool32 HadMoreThanHalfHpNowDoesnt(u32 battler) +bool32 HadMoreThanHalfHpNowDoesnt(enum BattlerId battler) { // Had more than half of hp before, now has less return gBattleStruct->battlerState[battler].wasAboveHalfHp && gBattleMons[battler].hp <= gBattleMons[battler].maxHP / 2; } -u32 NumFaintedBattlersByAttacker(u32 battlerAtk) +u32 NumFaintedBattlersByAttacker(enum BattlerId battlerAtk) { - u32 battler, numMonsFainted = 0; + u32 numMonsFainted = 0; - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (battler == battlerAtk) continue; @@ -2377,7 +2374,7 @@ u32 NumFaintedBattlersByAttacker(u32 battlerAtk) #define ANIM_STAT_SPEED 5 #define ANIM_STAT_ACC 6 #define ANIM_STAT_EVASION 7 -void ChooseStatBoostAnimation(u32 battler) +void ChooseStatBoostAnimation(enum BattlerId battler) { u32 stat; bool32 statBuffMoreThan1 = FALSE; @@ -2551,7 +2548,7 @@ bool32 CanAbilityAbsorbMove(struct BattleContext *ctx) return TRUE; } -const u8 *AbsorbedByDrainHpAbility(u32 battlerDef) +const u8 *AbsorbedByDrainHpAbility(enum BattlerId battlerDef) { if (IsBattlerAtMaxHp(battlerDef) || (B_HEAL_BLOCKING >= GEN_5 && gBattleMons[battlerDef].volatiles.healBlock)) { @@ -2564,7 +2561,7 @@ const u8 *AbsorbedByDrainHpAbility(u32 battlerDef) } } -const u8 *AbsorbedByStatIncreaseAbility(u32 battlerDef, enum Ability abilityDef, enum Stat statId, u32 statAmount) +const u8 *AbsorbedByStatIncreaseAbility(enum BattlerId battlerDef, enum Ability abilityDef, enum Stat statId, u32 statAmount) { if (!CompareStat(battlerDef, statId, MAX_STAT_STAGE, CMP_LESS_THAN, abilityDef)) { @@ -2577,7 +2574,7 @@ const u8 *AbsorbedByStatIncreaseAbility(u32 battlerDef, enum Ability abilityDef, } } -const u8 *AbsorbedByFlashFire(u32 battlerDef) +const u8 *AbsorbedByFlashFire(enum BattlerId battlerDef) { if (!gBattleMons[battlerDef].volatiles.flashFireBoosted) { @@ -2594,7 +2591,7 @@ const u8 *AbsorbedByFlashFire(u32 battlerDef) static u32 GetFirstBattlerOnSide(enum BattleSide side) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (GetBattlerSide(battler) == side && !IsBattlerAlive(battler)) return battler; @@ -2624,7 +2621,7 @@ static inline bool32 SetStartingSideStatus(u32 flag, enum BattleSide side, u32 m { if (!(gSideStatuses[side] & flag)) { - gBattlerAttacker = gBattlerTarget = side; + gBattlerAttacker = gBattlerTarget = (enum BattlerId)side; gBattleCommunication[MULTISTRING_CHOOSER] = message; gSideStatuses[side] |= flag; gBattleScripting.animArg1 = anim; @@ -3092,7 +3089,7 @@ bool32 TryFieldEffects(enum FieldEffectCases caseId) return effect; } -u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ability, enum Move move, bool32 shouldAbilityTrigger) +u32 AbilityBattleEffects(enum AbilityEffect caseID, enum BattlerId battler, enum Ability ability, enum Move move, bool32 shouldAbilityTrigger) { u32 effect = 0; enum Type moveType = 0; @@ -3124,9 +3121,9 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab { case ABILITY_TRACE: { - u32 chosenTarget; - u32 target1; - u32 target2; + enum BattlerId chosenTarget; + enum BattlerId target1; + enum BattlerId target2; if (GetBattlerHoldEffectIgnoreAbility(battler) == HOLD_EFFECT_ABILITY_SHIELD) break; @@ -3163,7 +3160,7 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab case ABILITY_IMPOSTER: if (gBattleStruct->battlerState[battler].switchIn) { - u32 diagonalBattler = BATTLE_OPPOSITE(battler); + enum BattlerId diagonalBattler = BATTLE_OPPOSITE(battler); if (IsDoubleBattle()) diagonalBattler = BATTLE_PARTNER(diagonalBattler); @@ -3298,7 +3295,7 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab if (shouldAbilityTrigger) { enum Stat statId; - u32 opposingBattler; + enum BattlerId opposingBattler; u32 opposingDef = 0, opposingSpDef = 0; opposingBattler = BATTLE_OPPOSITE(battler); @@ -4531,7 +4528,7 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab u32 numMagicianTargets = 0; u32 magicianTargets = 0; - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (gBattleMons[battlerDef].item != ITEM_NONE && battlerDef != battler @@ -4552,13 +4549,13 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab break; } - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; if (numMagicianTargets > 1) SortBattlersBySpeed(battlers, FALSE); for (u32 i = 0; i < gBattlersCount; i++) { - u32 targetBattler = battlers[i]; + enum BattlerId targetBattler = battlers[i]; if (!(magicianTargets & 1u << targetBattler)) continue; @@ -4869,7 +4866,7 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab case ABILITY_FLOWER_GIFT: case ABILITY_ICE_FACE: { - u32 battlerWeatherAffected = IsBattlerWeatherAffected(battler, gBattleWeather); + bool32 battlerWeatherAffected = IsBattlerWeatherAffected(battler, gBattleWeather); if (battlerWeatherAffected && !CanBattlerFormChange(battler, FORM_CHANGE_BATTLE_WEATHER)) { // If Hail/Snow activates when in Eiscue is in base, prevent reversion when Eiscue Noice gets broken @@ -4951,7 +4948,7 @@ u32 AbilityBattleEffects(enum AbilityEffect caseID, u32 battler, enum Ability ab return effect; } -bool32 TryPrimalReversion(u32 battler) +bool32 TryPrimalReversion(enum BattlerId battler) { if (GetBattlerHoldEffectIgnoreNegation(battler) == HOLD_EFFECT_PRIMAL_ORB && GetBattleFormChangeTargetSpecies(battler, FORM_CHANGE_BATTLE_PRIMAL_REVERSION) != gBattleMons[battler].species) @@ -4965,9 +4962,7 @@ bool32 TryPrimalReversion(u32 battler) bool32 IsNeutralizingGasOnField(void) { - u32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.neutralizingGas && !gBattleMons[i].volatiles.gastroAcid) return TRUE; @@ -4976,7 +4971,7 @@ bool32 IsNeutralizingGasOnField(void) return FALSE; } -bool32 IsMoldBreakerTypeAbility(u32 battler, enum Ability ability) +bool32 IsMoldBreakerTypeAbility(enum BattlerId battler, enum Ability ability) { if (gBattleMons[battler].volatiles.gastroAcid) return FALSE; @@ -4993,29 +4988,29 @@ bool32 IsMoldBreakerTypeAbility(u32 battler, enum Ability ability) return FALSE; } -static inline bool32 CanBreakThroughAbility(u32 battlerAtk, u32 battlerDef, bool32 hasAbilityShield, bool32 ignoreMoldBreaker) +static inline bool32 CanBreakThroughAbility(enum BattlerId battlerAtk, enum BattlerId battlerDef, bool32 hasAbilityShield, bool32 ignoreMoldBreaker) { if (hasAbilityShield || ignoreMoldBreaker || battlerDef == battlerAtk) return FALSE; return gBattleStruct->moldBreakerActive && gAbilitiesInfo[gBattleMons[battlerDef].ability].breakable; } -enum Ability GetBattlerAbilityNoAbilityShield(u32 battler) +enum Ability GetBattlerAbilityNoAbilityShield(enum BattlerId battler) { return GetBattlerAbilityInternal(battler, FALSE, TRUE); } -enum Ability GetBattlerAbilityIgnoreMoldBreaker(u32 battler) +enum Ability GetBattlerAbilityIgnoreMoldBreaker(enum BattlerId battler) { return GetBattlerAbilityInternal(battler, TRUE, FALSE); } -enum Ability GetBattlerAbility(u32 battler) +enum Ability GetBattlerAbility(enum BattlerId battler) { return GetBattlerAbilityInternal(battler, FALSE, FALSE); } -enum Ability GetBattlerAbilityInternal(u32 battler, bool32 ignoreMoldBreaker, bool32 noAbilityShield) +enum Ability GetBattlerAbilityInternal(enum BattlerId battler, bool32 ignoreMoldBreaker, bool32 noAbilityShield) { bool32 hasAbilityShield = !noAbilityShield && GetBattlerHoldEffectIgnoreAbility(battler) == HOLD_EFFECT_ABILITY_SHIELD; bool32 abilityCantBeSuppressed = gAbilitiesInfo[gBattleMons[battler].ability].cantBeSuppressed; @@ -5048,7 +5043,7 @@ enum Ability GetBattlerAbilityInternal(u32 battler, bool32 ignoreMoldBreaker, bo return gBattleMons[battler].ability; } -u32 IsAbilityOnSide(u32 battler, enum Ability ability) +u32 IsAbilityOnSide(enum BattlerId battler, enum Ability ability) { if (IsBattlerAlive(battler) && GetBattlerAbility(battler) == ability) return battler + 1; @@ -5058,16 +5053,14 @@ u32 IsAbilityOnSide(u32 battler, enum Ability ability) return 0; } -u32 IsAbilityOnOpposingSide(u32 battler, enum Ability ability) +u32 IsAbilityOnOpposingSide(enum BattlerId battler, enum Ability ability) { return IsAbilityOnSide(BATTLE_OPPOSITE(battler), ability); } u32 IsAbilityOnField(enum Ability ability) { - u32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsBattlerAlive(i) && GetBattlerAbility(i) == ability) return i + 1; @@ -5076,11 +5069,9 @@ u32 IsAbilityOnField(enum Ability ability) return 0; } -u32 IsAbilityOnFieldExcept(u32 battler, enum Ability ability) +u32 IsAbilityOnFieldExcept(enum BattlerId battler, enum Ability ability) { - u32 i; - - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (i != battler && IsBattlerAlive(i) && GetBattlerAbility(i) == ability) return i + 1; @@ -5089,13 +5080,13 @@ u32 IsAbilityOnFieldExcept(u32 battler, enum Ability ability) return 0; } -u32 IsAbilityPreventingEscape(u32 battler) +u32 IsAbilityPreventingEscape(enum BattlerId battler) { if (GetConfig(CONFIG_GHOSTS_ESCAPE) >= GEN_6 && IS_BATTLER_OF_TYPE(battler, TYPE_GHOST)) return 0; bool32 isBattlerGrounded = IsBattlerGrounded(battler, GetBattlerAbility(battler), GetBattlerHoldEffect(battler)); - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (battler == battlerDef || IsBattlerAlly(battler, battlerDef)) continue; @@ -5115,7 +5106,7 @@ u32 IsAbilityPreventingEscape(u32 battler) return 0; } -bool32 CanBattlerEscape(u32 battler) // no ability check +bool32 CanBattlerEscape(enum BattlerId battler) // no ability check { if (gBattleStruct->battlerState[battler].commanderSpecies != SPECIES_NONE) return FALSE; @@ -5135,32 +5126,32 @@ bool32 CanBattlerEscape(u32 battler) // no ability check return TRUE; } -bool32 IsPsychicTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) +bool32 IsPsychicTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) { return IsBattlerTerrainAffected(battler, ability, holdEffect, fieldStatuses, STATUS_FIELD_PSYCHIC_TERRAIN); } -bool32 IsMistyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) +bool32 IsMistyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) { return IsBattlerTerrainAffected(battler, ability, holdEffect, fieldStatuses, STATUS_FIELD_MISTY_TERRAIN); } -bool32 IsGrassyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) +bool32 IsGrassyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) { return IsBattlerTerrainAffected(battler, ability, holdEffect, fieldStatuses, STATUS_FIELD_GRASSY_TERRAIN); } -bool32 IsElectricTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) +bool32 IsElectricTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) { return IsBattlerTerrainAffected(battler, ability, holdEffect, fieldStatuses, STATUS_FIELD_ELECTRIC_TERRAIN); } -bool32 IsAnyTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) +bool32 IsAnyTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatuses) { return IsBattlerTerrainAffected(battler, ability, holdEffect, fieldStatuses, STATUS_FIELD_TERRAIN_ANY); } -bool32 IsBattlerTerrainAffected(u32 battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatus, u32 terrainFlag) +bool32 IsBattlerTerrainAffected(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, u32 fieldStatus, u32 terrainFlag) { if (!(fieldStatus & terrainFlag)) return FALSE; @@ -5170,7 +5161,7 @@ bool32 IsBattlerTerrainAffected(u32 battler, enum Ability ability, enum HoldEffe return IsBattlerGrounded(battler, ability, holdEffect); } -enum Stat GetHighestStatId(u32 battler) +enum Stat GetHighestStatId(enum BattlerId battler) { enum Stat highestId = STAT_ATK; bool32 wonderRoom = (gFieldStatuses & STATUS_FIELD_WONDER_ROOM) != 0; @@ -5213,7 +5204,7 @@ enum Stat GetHighestStatId(u32 battler) return highestId; } -static u32 GetStatValueWithStages(u32 battler, enum Stat stat) +static u32 GetStatValueWithStages(enum BattlerId battler, enum Stat stat) { u32 statValue; @@ -5244,7 +5235,7 @@ static u32 GetStatValueWithStages(u32 battler, enum Stat stat) return statValue; } -enum Stat GetParadoxHighestStatId(u32 battler) +enum Stat GetParadoxHighestStatId(enum BattlerId battler) { enum Stat highestId = STAT_ATK; u32 highestStat = GetStatValueWithStages(battler, STAT_ATK); @@ -5269,21 +5260,21 @@ enum Stat GetParadoxHighestStatId(u32 battler) return highestId; } -static void ResetParadoxWeatherStat(u32 battler) +static void ResetParadoxWeatherStat(enum BattlerId battler) { if (gBattleMons[battler].ability == ABILITY_PROTOSYNTHESIS && !gBattleMons[battler].volatiles.boosterEnergyActivated) gBattleMons[battler].volatiles.paradoxBoostedStat = 0; } -static void ResetParadoxTerrainStat(u32 battler) +static void ResetParadoxTerrainStat(enum BattlerId battler) { if (gBattleMons[battler].ability == ABILITY_QUARK_DRIVE && !gBattleMons[battler].volatiles.boosterEnergyActivated) gBattleMons[battler].volatiles.paradoxBoostedStat = 0; } -enum Stat GetParadoxBoostedStatId(u32 battler) +enum Stat GetParadoxBoostedStatId(enum BattlerId battler) { if (gBattleMons[battler].volatiles.paradoxBoostedStat == 0) gBattleMons[battler].volatiles.paradoxBoostedStat = GetParadoxHighestStatId(battler); @@ -5291,7 +5282,7 @@ enum Stat GetParadoxBoostedStatId(u32 battler) return gBattleMons[battler].volatiles.paradoxBoostedStat; } -bool32 CanBeSlept(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef, enum SleepClauseBlock isBlockedBySleepClause) +bool32 CanBeSlept(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef, enum SleepClauseBlock isBlockedBySleepClause) { if (IsSleepClauseActiveForSide(GetBattlerSide(battlerDef)) && isBlockedBySleepClause != NOT_BLOCKED_BY_SLEEP_CLAUSE) return FALSE; @@ -5313,7 +5304,7 @@ bool32 CanBeSlept(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef, enum return effect; } -bool32 CanBePoisoned(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef) +bool32 CanBePoisoned(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef) { if (CanSetNonVolatileStatus( battlerAtk, @@ -5327,7 +5318,7 @@ bool32 CanBePoisoned(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, en } // TODO: check order of battlerAtk and battlerDef -bool32 CanBeBurned(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 CanBeBurned(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (CanSetNonVolatileStatus( battlerAtk, @@ -5340,7 +5331,7 @@ bool32 CanBeBurned(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return FALSE; } -bool32 CanBeParalyzed(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 CanBeParalyzed(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (CanSetNonVolatileStatus( battlerAtk, @@ -5353,7 +5344,7 @@ bool32 CanBeParalyzed(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return FALSE; } -bool32 CanBeFrozen(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 CanBeFrozen(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (CanSetNonVolatileStatus( battlerAtk, @@ -5366,7 +5357,7 @@ bool32 CanBeFrozen(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return FALSE; } // Unused, technically also redundant because it is just a copy of CanBeFrozen -bool32 CanGetFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) +bool32 CanGetFrostbite(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityDef) { if (CanSetNonVolatileStatus( battlerAtk, @@ -5379,7 +5370,7 @@ bool32 CanGetFrostbite(u32 battlerAtk, u32 battlerDef, enum Ability abilityDef) return FALSE; } -bool32 CanSetNonVolatileStatus(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum MoveEffect effect, enum ResultOption option) +bool32 CanSetNonVolatileStatus(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum MoveEffect effect, enum ResultOption option) { const u8 *battleScript = NULL; u32 sideBattler = 0; @@ -5546,7 +5537,7 @@ bool32 CanSetNonVolatileStatus(u32 battlerAtk, u32 battlerDef, enum Ability abil return TRUE; } -static bool32 IsNonVolatileStatusBlocked(u32 battlerDef, enum Ability abilityDef, bool32 abilityAffected, const u8 *battleScript, enum ResultOption option) +static bool32 IsNonVolatileStatusBlocked(enum BattlerId battlerDef, enum Ability abilityDef, bool32 abilityAffected, const u8 *battleScript, enum ResultOption option) { if (battleScript != NULL) { @@ -5571,7 +5562,7 @@ static bool32 IsNonVolatileStatusBlocked(u32 battlerDef, enum Ability abilityDef return FALSE; } -static bool32 CanSleepDueToSleepClause(u32 battlerAtk, u32 battlerDef, enum ResultOption option) +static bool32 CanSleepDueToSleepClause(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum ResultOption option) { // Can freely sleep own partner if (IsDoubleBattle() && IsSleepClauseEnabled() && IsBattlerAlly(battlerAtk, battlerDef)) @@ -5590,7 +5581,7 @@ static bool32 CanSleepDueToSleepClause(u32 battlerAtk, u32 battlerDef, enum Resu return FALSE; } -bool32 CanBeConfused(u32 battler) +bool32 CanBeConfused(enum BattlerId battler) { enum Ability ability = GetBattlerAbility(battler); if (gBattleMons[battler].volatiles.confusionTurns > 0 @@ -5601,7 +5592,7 @@ bool32 CanBeConfused(u32 battler) } // second argument is 1/X of current hp compared to max hp -bool32 HasEnoughHpToEatBerry(u32 battler, enum Ability ability, u32 hpFraction, enum Item itemId) +bool32 HasEnoughHpToEatBerry(enum BattlerId battler, enum Ability ability, u32 hpFraction, enum Item itemId) { if (!IsBattlerAlive(battler)) return FALSE; @@ -5618,7 +5609,7 @@ bool32 HasEnoughHpToEatBerry(u32 battler, enum Ability ability, u32 hpFraction, return FALSE; } -void ClearVariousBattlerFlags(u32 battler) +void ClearVariousBattlerFlags(enum BattlerId battler) { gBattleMons[battler].volatiles.furyCutterCounter = 0; gBattleMons[battler].volatiles.destinyBond = 0; @@ -5632,10 +5623,10 @@ void HandleAction_RunBattleScript(void) // identical to RunBattleScriptCommands gBattleScriptingCommandsTable[*gBattlescriptCurrInstr](); } -u32 SetRandomTarget(u32 battlerAtk) +u32 SetRandomTarget(enum BattlerId battlerAtk) { - u32 target; - static const u8 targets[2][2] = + enum BattlerId target; + static const u8 targets[NUM_BATTLE_SIDES][MAX_BATTLERS_COUNT / 2] = { [B_SIDE_PLAYER] = {B_POSITION_OPPONENT_LEFT, B_POSITION_OPPONENT_RIGHT}, [B_SIDE_OPPONENT] = {B_POSITION_PLAYER_LEFT, B_POSITION_PLAYER_RIGHT}, @@ -5833,7 +5824,7 @@ enum Obedience GetAttackerObedienceForAction(void) if (calc < obedienceLevel && CanBeSlept(gBattlerAttacker, gBattlerAttacker, GetBattlerAbility(gBattlerAttacker), NOT_BLOCKED_BY_SLEEP_CLAUSE)) { // try putting asleep - int i; + enum BattlerId i; for (i = 0; i < gBattlersCount; i++) if (gBattleMons[i].volatiles.uproarTurns) break; @@ -5848,17 +5839,17 @@ enum Obedience GetAttackerObedienceForAction(void) } } -enum HoldEffect GetBattlerHoldEffect(u32 battler) +enum HoldEffect GetBattlerHoldEffect(enum BattlerId battler) { return GetBattlerHoldEffectInternal(battler, GetBattlerAbility(battler)); } -enum HoldEffect GetBattlerHoldEffectIgnoreAbility(u32 battler) +enum HoldEffect GetBattlerHoldEffectIgnoreAbility(enum BattlerId battler) { return GetBattlerHoldEffectInternal(battler, ABILITY_NONE); } -enum HoldEffect GetBattlerHoldEffectInternal(u32 battler, enum Ability ability) +enum HoldEffect GetBattlerHoldEffectInternal(enum BattlerId battler, enum Ability ability) { if (gBattleMons[battler].volatiles.embargo) return HOLD_EFFECT_NONE; @@ -5875,7 +5866,7 @@ enum HoldEffect GetBattlerHoldEffectInternal(u32 battler, enum Ability ability) return GetItemHoldEffect(gBattleMons[battler].item); } -enum HoldEffect GetBattlerHoldEffectIgnoreNegation(u32 battler) +enum HoldEffect GetBattlerHoldEffectIgnoreNegation(enum BattlerId battler) { gPotentialItemEffectBattler = battler; if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY_E_READER) @@ -5884,7 +5875,7 @@ enum HoldEffect GetBattlerHoldEffectIgnoreNegation(u32 battler) return GetItemHoldEffect(gBattleMons[battler].item); } -u32 GetBattlerHoldEffectParam(u32 battler) +u32 GetBattlerHoldEffectParam(enum BattlerId battler) { if (gBattleMons[battler].item == ITEM_ENIGMA_BERRY_E_READER) return gEnigmaBerries[battler].holdEffectParam; @@ -5892,7 +5883,7 @@ u32 GetBattlerHoldEffectParam(u32 battler) return GetItemHoldEffectParam(gBattleMons[battler].item); } -bool32 CanBattlerAvoidContactEffects(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move) +bool32 CanBattlerAvoidContactEffects(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move) { if (holdEffectAtk == HOLD_EFFECT_PROTECTIVE_PADS) { @@ -5903,7 +5894,7 @@ bool32 CanBattlerAvoidContactEffects(u32 battlerAtk, u32 battlerDef, enum Abilit return !IsMoveMakingContact(battlerAtk, battlerDef, abilityAtk, holdEffectAtk, move); } -bool32 IsMoveMakingContact(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move) +bool32 IsMoveMakingContact(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum HoldEffect holdEffectAtk, enum Move move) { if (!(MoveMakesContact(move) || (GetMoveEffect(move) == EFFECT_SHELL_SIDE_ARM && gBattleStruct->shellSideArmCategory[battlerAtk][battlerDef] == DAMAGE_CATEGORY_PHYSICAL))) @@ -5923,7 +5914,7 @@ bool32 IsMoveMakingContact(u32 battlerAtk, u32 battlerDef, enum Ability abilityA return TRUE; } -static inline bool32 IsSideProtected(u32 battler, enum ProtectMethod method) +static inline bool32 IsSideProtected(enum BattlerId battler, enum ProtectMethod method) { return gProtectStructs[battler].protected == method || gProtectStructs[BATTLE_PARTNER(battler)].protected == method; @@ -6042,7 +6033,7 @@ enum IronBallCheck }; // Only called directly when calculating damage type effectiveness, and Iron Ball's type effectiveness mechanics -static bool32 IsBattlerGroundedInverseCheck(u32 battler, enum Ability ability, enum HoldEffect holdEffect, enum InverseBattleCheck checkInverse, bool32 isAnticipation) +static bool32 IsBattlerGroundedInverseCheck(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect, enum InverseBattleCheck checkInverse, bool32 isAnticipation) { if (holdEffect == HOLD_EFFECT_IRON_BALL) return TRUE; @@ -6065,7 +6056,7 @@ static bool32 IsBattlerGroundedInverseCheck(u32 battler, enum Ability ability, e return TRUE; } -bool32 IsBattlerGrounded(u32 battler, enum Ability ability, enum HoldEffect holdEffect) +bool32 IsBattlerGrounded(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect) { return IsBattlerGroundedInverseCheck(battler, ability, holdEffect, NOT_INVERSE_BATTLE, FALSE); } @@ -6082,7 +6073,7 @@ u32 GetMoveSlot(u16 *moves, enum Move move) return i; } -u32 GetBattlerWeight(u32 battler) +u32 GetBattlerWeight(enum BattlerId battler) { u32 i; u32 weight = GetSpeciesWeight(gBattleMons[battler].species); @@ -6116,7 +6107,7 @@ u32 GetBattlerWeight(u32 battler) return weight; } -u32 CountBattlerStatIncreases(u32 battler, bool32 countEvasionAcc) +u32 CountBattlerStatIncreases(enum BattlerId battler, bool32 countEvasionAcc) { enum Stat i; u32 count = 0; @@ -6132,7 +6123,7 @@ u32 CountBattlerStatIncreases(u32 battler, bool32 countEvasionAcc) return count; } -bool32 BattlerHasCopyableChanges(u32 battler) +bool32 BattlerHasCopyableChanges(enum BattlerId battler) { u32 i; @@ -6152,8 +6143,8 @@ bool32 BattlerHasCopyableChanges(u32 battler) u32 GetMoveTargetCount(struct BattleContext *ctx) { - u32 battlerAtk = ctx->battlerAtk; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerAtk = ctx->battlerAtk; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; switch (GetBattlerMoveTargetType(battlerAtk, move)) @@ -6275,7 +6266,7 @@ const struct TypePower gNaturalGiftTable[] = [ITEM_TO_BERRY(ITEM_MARANGA_BERRY)] = {TYPE_DARK, 100}, }; -static inline u32 CalcRolloutBasePower(u32 battlerAtk, u32 basePower) +static inline u32 CalcRolloutBasePower(enum BattlerId battlerAtk, u32 basePower) { u32 i; for (i = 0; i < gBattleMons[battlerAtk].volatiles.rolloutTimer; i++) @@ -6285,7 +6276,7 @@ static inline u32 CalcRolloutBasePower(u32 battlerAtk, u32 basePower) return basePower; } -static inline u32 CalcFuryCutterBasePower(u32 battlerAtk, u32 basePower) +static inline u32 CalcFuryCutterBasePower(enum BattlerId battlerAtk, u32 basePower) { for (u32 i = 0; i < gBattleMons[battlerAtk].volatiles.furyCutterCounter; i++) basePower *= 2; @@ -6319,7 +6310,7 @@ static inline u32 IsFieldMudSportAffected(enum Type moveType) if (B_SPORT_TURNS < GEN_6) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleMons[battler].volatiles.mudSport) return TRUE; @@ -6339,7 +6330,7 @@ static inline u32 IsFieldWaterSportAffected(enum Type moveType) if (B_SPORT_TURNS < GEN_6) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleMons[battler].volatiles.waterSport) return TRUE; @@ -6351,8 +6342,8 @@ static inline u32 IsFieldWaterSportAffected(enum Type moveType) static inline u32 CalcMoveBasePower(struct BattleContext *ctx) { - u32 battlerAtk = ctx->battlerAtk; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerAtk = ctx->battlerAtk; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; u32 i; @@ -6572,7 +6563,7 @@ static inline u32 CalcMoveBasePower(struct BattleContext *ctx) basePower = CalcBeatUpPower(); break; case EFFECT_MAX_MOVE: - basePower = GetMaxMovePower(GetChosenMoveFromPosition(battlerAtk)); + basePower = GetMaxMovePower(GetBattlerChosenMove(battlerAtk)); break; case EFFECT_RAGE_FIST: basePower += 50 * GetBattlerPartyState(battlerAtk)->timesGotHit; @@ -6605,8 +6596,8 @@ static inline u32 CalcMoveBasePowerAfterModifiers(struct BattleContext *ctx) { u32 holdEffectParamAtk; u32 basePower = CalcMoveBasePower(ctx); - u32 battlerAtk = ctx->battlerAtk; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerAtk = ctx->battlerAtk; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; enum Type moveType = ctx->moveType; enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -6902,7 +6893,7 @@ static inline u32 CalcMoveBasePowerAfterModifiers(struct BattleContext *ctx) static bool32 IsRuinStatusActive(u32 fieldEffect) { bool32 isNeutralizingGasOnField = IsNeutralizingGasOnField(); - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { // Mold Breaker doesn't ignore Ruin field status but Gastro Acid and Neutralizing Gas do if (gBattleMons[battler].volatiles.gastroAcid) @@ -6919,7 +6910,7 @@ static bool32 IsRuinStatusActive(u32 fieldEffect) return FALSE; } -static inline uq4_12_t ApplyOffensiveBadgeBoost(uq4_12_t modifier, u32 battler, enum Move move) +static inline uq4_12_t ApplyOffensiveBadgeBoost(uq4_12_t modifier, enum BattlerId battler, enum Move move) { if (ShouldGetStatBadgeBoost(B_FLAG_BADGE_BOOST_ATTACK, battler) && IsBattleMovePhysical(move)) modifier = uq4_12_multiply_half_down(modifier, GetBadgeBoostModifier()); @@ -6928,7 +6919,7 @@ static inline uq4_12_t ApplyOffensiveBadgeBoost(uq4_12_t modifier, u32 battler, return modifier; } -static inline uq4_12_t ApplyDefensiveBadgeBoost(uq4_12_t modifier, u32 battler, enum Move move) +static inline uq4_12_t ApplyDefensiveBadgeBoost(uq4_12_t modifier, enum BattlerId battler, enum Move move) { if (ShouldGetStatBadgeBoost(B_FLAG_BADGE_BOOST_DEFENSE, battler) && IsBattleMovePhysical(move)) modifier = uq4_12_multiply_half_down(modifier, GetBadgeBoostModifier()); @@ -6943,8 +6934,8 @@ static inline u32 CalcAttackStat(struct BattleContext *ctx) u32 atkStat; uq4_12_t modifier; u16 atkBaseSpeciesId; - u32 battlerAtk = ctx->battlerAtk; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerAtk = ctx->battlerAtk; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; enum Type moveType = ctx->moveType; enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -7240,7 +7231,7 @@ static inline u32 CalcDefenseStat(struct BattleContext *ctx) u8 defStage; u32 defStat, def, spDef; uq4_12_t modifier; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; enum BattleMoveEffects moveEffect = GetMoveEffect(move); @@ -7433,7 +7424,7 @@ static inline uq4_12_t GetTargetDamageModifier(struct BattleContext *ctx) return UQ_4_12(1.0); } -static inline uq4_12_t GetParentalBondModifier(u32 battlerAtk) +static inline uq4_12_t GetParentalBondModifier(enum BattlerId battlerAtk) { if (gSpecialStatuses[battlerAtk].parentalBondState != PARENTAL_BOND_2ND_HIT) return UQ_4_12(1.0); @@ -7499,7 +7490,7 @@ static inline uq4_12_t GetCriticalModifier(bool32 isCrit) return UQ_4_12(1.0); } -static inline uq4_12_t GetGlaiveRushModifier(u32 battlerDef) +static inline uq4_12_t GetGlaiveRushModifier(enum BattlerId battlerDef) { if (gBattleMons[battlerDef].volatiles.glaiveRush) return UQ_4_12(2.0); @@ -7517,28 +7508,28 @@ static inline uq4_12_t GetZMaxMoveAgainstProtectionModifier(struct BattleContext return UQ_4_12(1.0); } -static inline uq4_12_t GetMinimizeModifier(enum Move move, u32 battlerDef) +static inline uq4_12_t GetMinimizeModifier(enum Move move, enum BattlerId battlerDef) { if (MoveIncreasesPowerToMinimizedTargets(move) && gBattleMons[battlerDef].volatiles.minimize) return UQ_4_12(2.0); return UQ_4_12(1.0); } -static inline uq4_12_t GetUndergroundModifier(enum Move move, u32 battlerDef) +static inline uq4_12_t GetUndergroundModifier(enum Move move, enum BattlerId battlerDef) { if (MoveDamagesUnderground(move) && gBattleMons[battlerDef].volatiles.semiInvulnerable == STATE_UNDERGROUND) return UQ_4_12(2.0); return UQ_4_12(1.0); } -static inline uq4_12_t GetDiveModifier(enum Move move, u32 battlerDef) +static inline uq4_12_t GetDiveModifier(enum Move move, enum BattlerId battlerDef) { if (MoveDamagesUnderWater(move) && gBattleMons[battlerDef].volatiles.semiInvulnerable == STATE_UNDERWATER) return UQ_4_12(2.0); return UQ_4_12(1.0); } -static inline uq4_12_t GetAirborneModifier(enum Move move, u32 battlerDef) +static inline uq4_12_t GetAirborneModifier(enum Move move, enum BattlerId battlerDef) { if (MoveDamagesAirborneDoubleDamage(move) && gBattleMons[battlerDef].volatiles.semiInvulnerable == STATE_ON_AIR) return UQ_4_12(2.0); @@ -7576,7 +7567,7 @@ static inline uq4_12_t GetCollisionCourseElectroDriftModifier(enum Move move, uq return UQ_4_12(1.0); } -static inline uq4_12_t GetAttackerAbilitiesModifier(u32 battlerAtk, uq4_12_t typeEffectivenessModifier, bool32 isCrit, enum Ability abilityAtk) +static inline uq4_12_t GetAttackerAbilitiesModifier(enum BattlerId battlerAtk, uq4_12_t typeEffectivenessModifier, bool32 isCrit, enum Ability abilityAtk) { switch (abilityAtk) { @@ -7658,7 +7649,7 @@ static inline uq4_12_t GetDefenderAbilitiesModifier(struct BattleContext *ctx) return modifier; } -static inline uq4_12_t GetDefenderPartnerAbilitiesModifier(u32 battlerPartnerDef) +static inline uq4_12_t GetDefenderPartnerAbilitiesModifier(enum BattlerId battlerPartnerDef) { if (!IsBattlerAlive(battlerPartnerDef)) return UQ_4_12(1.0); @@ -7674,7 +7665,7 @@ static inline uq4_12_t GetDefenderPartnerAbilitiesModifier(u32 battlerPartnerDef return UQ_4_12(1.0); } -static inline uq4_12_t GetAttackerItemsModifier(u32 battlerAtk, uq4_12_t typeEffectivenessModifier, enum HoldEffect holdEffectAtk) +static inline uq4_12_t GetAttackerItemsModifier(enum BattlerId battlerAtk, uq4_12_t typeEffectivenessModifier, enum HoldEffect holdEffectAtk) { u32 metronomeTurns; uq4_12_t metronomeBoostBase; @@ -7735,7 +7726,7 @@ static inline uq4_12_t GetDefenderItemsModifier(struct BattleContext *ctx) static inline uq4_12_t GetOtherModifiers(struct BattleContext *ctx) { uq4_12_t finalModifier = UQ_4_12(1.0); - u32 battlerDefPartner = BATTLE_PARTNER(ctx->battlerDef); + enum BattlerId battlerDefPartner = BATTLE_PARTNER(ctx->battlerDef); u32 unmodifiedAttackerSpeed = gBattleMons[ctx->battlerAtk].speed; u32 unmodifiedDefenderSpeed = gBattleMons[ctx->battlerDef].speed; @@ -7926,8 +7917,8 @@ static inline s32 DoFutureSightAttackDamageCalcVars(struct BattleContext *ctx) s32 dmg; u32 userFinalAttack; u32 targetFinalDefense; - u32 battlerAtk = ctx->battlerAtk; - u32 battlerDef = ctx->battlerDef; + enum BattlerId battlerAtk = ctx->battlerAtk; + enum BattlerId battlerDef = ctx->battlerDef; enum Move move = ctx->move; enum Type moveType = ctx->moveType; @@ -7974,7 +7965,7 @@ static inline s32 DoFutureSightAttackDamageCalc(struct BattleContext *ctx) return DoFutureSightAttackDamageCalcVars(ctx); } -bool32 IsFutureSightAttackerInParty(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 IsFutureSightAttackerInParty(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (GetMoveEffect(move) != EFFECT_FUTURE_SIGHT) return FALSE; @@ -8009,7 +8000,7 @@ static inline u32 GetCriticalHitOdds(u32 critChance) return sCriticalHitOdds[critChance]; } -static inline u32 IsBattlerLeekAffected(u32 battler, enum HoldEffect holdEffect) +static inline u32 IsBattlerLeekAffected(enum BattlerId battler, enum HoldEffect holdEffect) { if (holdEffect == HOLD_EFFECT_LEEK) { @@ -8019,7 +8010,7 @@ static inline u32 IsBattlerLeekAffected(u32 battler, enum HoldEffect holdEffect) return FALSE; } -static inline u32 GetHoldEffectCritChanceIncrease(u32 battler, enum HoldEffect holdEffect) +static inline u32 GetHoldEffectCritChanceIncrease(enum BattlerId battler, enum HoldEffect holdEffect) { u32 critStageIncrease = 0; @@ -8328,7 +8319,7 @@ static inline void MulByTypeEffectiveness(struct BattleContext *ctx, uq4_12_t *m *modifier = uq4_12_multiply(*modifier, mod); } -static inline void TryNoticeIllusionInTypeEffectiveness(enum Move move, enum Type moveType, u32 battlerAtk, u32 battlerDef, uq4_12_t resultingModifier, u32 illusionSpecies) +static inline void TryNoticeIllusionInTypeEffectiveness(enum Move move, enum Type moveType, enum BattlerId battlerAtk, enum BattlerId battlerDef, uq4_12_t resultingModifier, u32 illusionSpecies) { // Check if the type effectiveness would've been different if the pokemon really had the types as the disguise. uq4_12_t presumedModifier = UQ_4_12(1.0); @@ -8598,7 +8589,7 @@ s32 GetStealthHazardDamageByTypesAndHP(enum TypeSideHazard hazardType, enum Type return dmg; } -s32 GetStealthHazardDamage(enum TypeSideHazard hazardType, u32 battler) +s32 GetStealthHazardDamage(enum TypeSideHazard hazardType, enum BattlerId battler) { enum Type types[3]; GetBattlerTypes(battler, FALSE, types); @@ -8607,7 +8598,7 @@ s32 GetStealthHazardDamage(enum TypeSideHazard hazardType, u32 battler) return GetStealthHazardDamageByTypesAndHP(hazardType, types[0], types[1], maxHp); } -bool32 IsPartnerMonFromSameTrainer(u32 battler) +bool32 IsPartnerMonFromSameTrainer(enum BattlerId battler) { if (!IsOnPlayerSide(battler)) return !(gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS); @@ -8643,13 +8634,14 @@ bool32 DoesSpeciesUseHoldItemToChangeForm(u16 species, u16 heldItemId) return FALSE; } -bool32 CanMegaEvolve(u32 battler) +bool32 CanMegaEvolve(enum BattlerId battler) { enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); + enum BattlerPosition position = GetBattlerPosition(battler); // Check if Player has a Mega Ring. if (!TESTING - && (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)) + && (position == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && position == B_POSITION_PLAYER_RIGHT)) && !CheckBagHasItem(ITEM_MEGA_RING, 1)) return FALSE; @@ -8681,13 +8673,14 @@ bool32 CanMegaEvolve(u32 battler) return FALSE; } -bool32 CanUltraBurst(u32 battler) +bool32 CanUltraBurst(enum BattlerId battler) { enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); + enum BattlerPosition position = GetBattlerPosition(battler); // Check if Player has a Z-Ring - if (!TESTING && (GetBattlerPosition(battler) == B_POSITION_PLAYER_LEFT - || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT)) + if (!TESTING && (position == B_POSITION_PLAYER_LEFT + || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && position == B_POSITION_PLAYER_RIGHT)) && !CheckBagHasItem(ITEM_Z_POWER_RING, 1)) return FALSE; @@ -8711,7 +8704,7 @@ bool32 CanUltraBurst(u32 battler) return FALSE; } -void ActivateMegaEvolution(u32 battler) +void ActivateMegaEvolution(enum BattlerId battler) { gLastUsedItem = gBattleMons[battler].item; SetActiveGimmick(battler, GIMMICK_MEGA); @@ -8721,14 +8714,14 @@ void ActivateMegaEvolution(u32 battler) BattleScriptPushCursorAndCallback(BattleScript_MegaEvolution); } -void ActivateUltraBurst(u32 battler) +void ActivateUltraBurst(enum BattlerId battler) { gLastUsedItem = gBattleMons[battler].item; SetActiveGimmick(battler, GIMMICK_ULTRA_BURST); BattleScriptPushCursorAndCallback(BattleScript_UltraBurst); } -bool32 IsBattlerMegaEvolved(u32 battler) +bool32 IsBattlerMegaEvolved(enum BattlerId battler) { // While Transform does copy stats and visuals, it shouldn't be counted as true Mega Evolution. if (gBattleMons[battler].volatiles.transformed) @@ -8736,7 +8729,7 @@ bool32 IsBattlerMegaEvolved(u32 battler) return (gSpeciesInfo[gBattleMons[battler].species].isMegaEvolution); } -bool32 IsBattlerPrimalReverted(u32 battler) +bool32 IsBattlerPrimalReverted(enum BattlerId battler) { // While Transform does copy stats and visuals, it shouldn't be counted as true Primal Revesion. if (gBattleMons[battler].volatiles.transformed) @@ -8744,7 +8737,7 @@ bool32 IsBattlerPrimalReverted(u32 battler) return (gSpeciesInfo[gBattleMons[battler].species].isPrimalReversion); } -bool32 IsBattlerUltraBursted(u32 battler) +bool32 IsBattlerUltraBursted(enum BattlerId battler) { // While Transform does copy stats and visuals, it shouldn't be counted as true Ultra Burst. if (gBattleMons[battler].volatiles.transformed) @@ -8752,7 +8745,7 @@ bool32 IsBattlerUltraBursted(u32 battler) return (gSpeciesInfo[gBattleMons[battler].species].isUltraBurst); } -bool32 IsBattlerInTeraForm(u32 battler) +bool32 IsBattlerInTeraForm(enum BattlerId battler) { // While Transform does copy stats and visuals, it shouldn't be counted as a true Tera Form. if (gBattleMons[battler].volatiles.transformed) @@ -8761,7 +8754,7 @@ bool32 IsBattlerInTeraForm(u32 battler) } // Returns SPECIES_NONE if no form change is possible -u32 GetBattleFormChangeTargetSpecies(u32 battler, enum FormChanges method) +u32 GetBattleFormChangeTargetSpecies(enum BattlerId battler, enum FormChanges method) { u32 i; u32 species = gBattleMons[battler].species; @@ -8870,7 +8863,7 @@ u32 GetBattleFormChangeTargetSpecies(u32 battler, enum FormChanges method) return targetSpecies; } -static bool32 CanBattlerFormChange(u32 battler, enum FormChanges method) +static bool32 CanBattlerFormChange(enum BattlerId battler, enum FormChanges method) { // Can't change form if transformed. if (gBattleMons[battler].volatiles.transformed @@ -8916,7 +8909,7 @@ bool32 TryRevertPartyMonFormChange(u32 partyIndex) return changedForm; } -bool32 TryBattleFormChange(u32 battler, enum FormChanges method) +bool32 TryBattleFormChange(enum BattlerId battler, enum FormChanges method) { u32 monId = gBattlerPartyIndexes[battler]; struct Pokemon *party = GetBattlerParty(battler); @@ -8981,7 +8974,7 @@ bool32 TryBattleFormChange(u32 battler, enum FormChanges method) return FALSE; } -bool32 DoBattlersShareType(u32 battler1, u32 battler2) +bool32 DoBattlersShareType(enum BattlerId battler1, enum BattlerId battler2) { s32 i; enum Type types1[3], types2[3]; @@ -9002,7 +8995,7 @@ bool32 DoBattlersShareType(u32 battler1, u32 battler2) return FALSE; } -bool32 CanBattlerGetOrLoseItem(u32 fromBattler, u32 battler, enum Item itemId) +bool32 CanBattlerGetOrLoseItem(enum BattlerId fromBattler, enum BattlerId battler, enum Item itemId) { u16 species = gBattleMons[fromBattler].species; enum HoldEffect holdEffect = GetItemHoldEffect(itemId); // Raw hold effect @@ -9022,7 +9015,7 @@ bool32 CanBattlerGetOrLoseItem(u32 fromBattler, u32 battler, enum Item itemId) return TRUE; } -u32 GetBattlerVisualSpecies(u32 battler) +u32 GetBattlerVisualSpecies(enum BattlerId battler) { u32 illusionSpecies = GetIllusionMonSpecies(battler); if (illusionSpecies != SPECIES_NONE) @@ -9030,7 +9023,7 @@ u32 GetBattlerVisualSpecies(u32 battler) return gBattleMons[battler].species; } -bool32 TryClearIllusion(u32 battler, enum Ability ability) +bool32 TryClearIllusion(enum BattlerId battler, enum Ability ability) { if (gBattleStruct->illusion[battler].state != ILLUSION_ON) return FALSE; @@ -9042,7 +9035,7 @@ bool32 TryClearIllusion(u32 battler, enum Ability ability) return TRUE; } -struct Pokemon *GetIllusionMonPtr(u32 battler) +struct Pokemon *GetIllusionMonPtr(enum BattlerId battler) { if (gBattleStruct->illusion[battler].state == ILLUSION_NOT_SET) SetIllusionMon(GetBattlerMon(battler), battler); @@ -9052,12 +9045,12 @@ struct Pokemon *GetIllusionMonPtr(u32 battler) return gBattleStruct->illusion[battler].mon; } -void ClearIllusionMon(u32 battler) +void ClearIllusionMon(enum BattlerId battler) { memset(&gBattleStruct->illusion[battler], 0, sizeof(gBattleStruct->illusion[battler])); } -u32 GetIllusionMonSpecies(u32 battler) +u32 GetIllusionMonSpecies(enum BattlerId battler) { struct Pokemon *illusionMon = GetIllusionMonPtr(battler); if (illusionMon != NULL) @@ -9065,7 +9058,7 @@ u32 GetIllusionMonSpecies(u32 battler) return SPECIES_NONE; } -u32 GetIllusionMonPartyId(struct Pokemon *party, struct Pokemon *mon, struct Pokemon *partnerMon, u32 battler) +u32 GetIllusionMonPartyId(struct Pokemon *party, struct Pokemon *mon, struct Pokemon *partnerMon, enum BattlerId battler) { s32 partyEnd=6; s32 partyStart=0; @@ -9105,7 +9098,7 @@ u32 GetIllusionMonPartyId(struct Pokemon *party, struct Pokemon *mon, struct Pok return PARTY_SIZE; } -void SetIllusionMon(struct Pokemon *mon, u32 battler) +void SetIllusionMon(struct Pokemon *mon, enum BattlerId battler) { struct Pokemon *party, *partnerMon; u32 id; @@ -9129,7 +9122,7 @@ void SetIllusionMon(struct Pokemon *mon, u32 battler) } } -enum ImmunityHealStatusOutcome TryImmunityAbilityHealStatus(u32 battler) +enum ImmunityHealStatusOutcome TryImmunityAbilityHealStatus(enum BattlerId battler) { enum ImmunityHealStatusOutcome outcome = IMMUNITY_NO_EFFECT; switch (GetBattlerAbilityIgnoreMoldBreaker(battler)) @@ -9228,7 +9221,7 @@ uq4_12_t GetBadgeBoostModifier(void) return UQ_4_12(1.1); } -bool32 ShouldGetStatBadgeBoost(u16 badgeFlag, u32 battler) +bool32 ShouldGetStatBadgeBoost(u16 badgeFlag, enum BattlerId battler) { if (GetConfig(CONFIG_BADGE_BOOST) <= GEN_3 && badgeFlag != 0) { @@ -9274,7 +9267,7 @@ enum DamageCategory GetBattleMoveCategory(enum Move move) return GetMoveCategory(move); } -void SetDynamicMoveCategory(u32 battlerAtk, u32 battlerDef, enum Move move) +void SetDynamicMoveCategory(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { switch (GetMoveEffect(move)) { @@ -9299,7 +9292,7 @@ void SetDynamicMoveCategory(u32 battlerAtk, u32 battlerDef, enum Move move) } } -static bool32 TryRemoveScreens(u32 battler) +static bool32 TryRemoveScreens(enum BattlerId battler) { bool32 removed = FALSE; u32 battlerSide = GetBattlerSide(battler); @@ -9323,7 +9316,7 @@ static bool32 TryRemoveScreens(u32 battler) } // Photon Geyser, Light That Burns the Sky, Tera Blast -enum DamageCategory GetCategoryBasedOnStats(u32 battler) +enum DamageCategory GetCategoryBasedOnStats(enum BattlerId battler) { u32 attack = gBattleMons[battler].attack; u32 spAttack = gBattleMons[battler].spAttack; @@ -9353,7 +9346,7 @@ static u32 GetFlingPowerFromItemId(enum Item itemId) return GetItemFlingPower(itemId); } -bool32 CanFling(u32 battlerAtk, u32 battlerDef) +bool32 CanFling(enum BattlerId battlerAtk, enum BattlerId battlerDef) { enum Item item = gBattleMons[battlerAtk].item; @@ -9370,14 +9363,15 @@ bool32 CanFling(u32 battlerAtk, u32 battlerDef) // Sort an array of battlers by speed // Useful for effects like pickpocket, eject button, red card, dancer -void SortBattlersBySpeed(u8 *battlers, bool32 slowToFast) +void SortBattlersBySpeed(enum BattlerId *battlers, bool32 slowToFast) { - int i, j, currSpeed, currBattler; + int i, j, currSpeed; + enum BattlerId currBattler; u16 speeds[MAX_BATTLERS_COUNT] = {0}; for (i = 0; i < gBattlersCount; i++) { - u32 battler = battlers[i]; + enum BattlerId battler = battlers[i]; speeds[i] = GetBattlerTotalSpeedStat(battler, GetBattlerAbility(battler), GetBattlerHoldEffect(battler)); } @@ -9434,7 +9428,7 @@ void TryRestoreHeldItems(void) } } -bool32 CanStealItem(u32 battlerStealing, u32 battlerItem, enum Item item) +bool32 CanStealItem(enum BattlerId battlerStealing, enum BattlerId battlerItem, enum Item item) { enum BattleSide stealerSide = GetBattlerSide(battlerStealing); @@ -9476,7 +9470,7 @@ bool32 CanStealItem(u32 battlerStealing, u32 battlerItem, enum Item item) return TRUE; } -void TrySaveExchangedItem(u32 battler, enum Item stolenItem) +void TrySaveExchangedItem(enum BattlerId battler, enum Item 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) @@ -9490,7 +9484,7 @@ void TrySaveExchangedItem(u32 battler, enum Item stolenItem) gBattleStruct->itemLost[B_SIDE_PLAYER][gBattlerPartyIndexes[battler]].stolen = TRUE; } -bool32 IsBattlerAffectedByHazards(u32 battler, enum HoldEffect holdEffect, bool32 toxicSpikes) +bool32 IsBattlerAffectedByHazards(enum BattlerId battler, enum HoldEffect holdEffect, bool32 toxicSpikes) { bool32 ret = TRUE; if (!IsBattlerAlive(battler)) @@ -9516,7 +9510,7 @@ bool32 IsSheerForceAffected(enum Move move, enum Ability ability) } // This function is the body of "jumpifstat", but can be used dynamically in a function -bool32 CompareStat(u32 battler, enum Stat statId, u32 cmpTo, u32 cmpKind, enum Ability ability) +bool32 CompareStat(enum BattlerId battler, enum Stat statId, u32 cmpTo, u32 cmpKind, enum Ability ability) { bool32 ret = FALSE; u32 statValue = gBattleMons[battler].statStages[statId]; @@ -9567,7 +9561,7 @@ bool32 CompareStat(u32 battler, enum Stat statId, u32 cmpTo, u32 cmpKind, enum A return ret; } -bool32 BlocksPrankster(enum Move move, u32 battlerPrankster, u32 battlerDef, bool32 checkTarget) +bool32 BlocksPrankster(enum Move move, enum BattlerId battlerPrankster, enum BattlerId battlerDef, bool32 checkTarget) { if (GetConfig(CONFIG_PRANKSTER_DARK_TYPES) < GEN_7) return FALSE; @@ -9587,18 +9581,19 @@ bool32 BlocksPrankster(enum Move move, u32 battlerPrankster, u32 battlerDef, boo return TRUE; } -bool32 CantPickupItem(u32 battler) +// Not enum BattlerId to allow using it with RandomUniformExcept +bool32 CantPickupItem(u32 _battler) { + enum BattlerId battler = _battler; // Used by RandomUniformExcept() for RNG_PICKUP if (battler == gBattlerAttacker && (GetConfig(CONFIG_PICKUP_WILD) < GEN_9 || gBattleTypeFlags & (BATTLE_TYPE_TRAINER | BATTLE_TYPE_LINK))) return TRUE; return !(IsBattlerAlive(battler) && GetBattlerPartyState(battler)->usedHeldItem && gBattleStruct->battlerState[battler].canPickupItem); } -bool32 PickupHasValidTarget(u32 battler) +bool32 PickupHasValidTarget(enum BattlerId battler) { - u32 i; - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (!CantPickupItem(i)) return TRUE; @@ -9606,7 +9601,7 @@ bool32 PickupHasValidTarget(u32 battler) return FALSE; } -bool32 IsBattlerWeatherAffected(u32 battler, u32 weatherFlags) +bool32 IsBattlerWeatherAffected(enum BattlerId battler, u32 weatherFlags) { if (gBattleWeather & weatherFlags && HasWeatherEffect()) { @@ -9619,14 +9614,14 @@ bool32 IsBattlerWeatherAffected(u32 battler, u32 weatherFlags) return FALSE; } -static u32 CanBattlerHitBothFoesInTerrain(u32 battler, enum Move move, enum BattleMoveEffects effect) +static u32 CanBattlerHitBothFoesInTerrain(enum BattlerId battler, enum Move move, enum BattleMoveEffects effect) { return effect == EFFECT_TERRAIN_BOOST && GetMoveTerrainBoost_HitsBothFoes(move) && IsBattlerTerrainAffected(battler, GetBattlerAbility(battler), GetBattlerHoldEffect(battler), gFieldStatuses, GetMoveTerrainBoost_Terrain(move)); } -enum MoveTarget GetBattlerMoveTargetType(u32 battler, enum Move move) +enum MoveTarget GetBattlerMoveTargetType(enum BattlerId battler, enum Move move) { enum BattleMoveEffects effect = GetMoveEffect(move); if (effect == EFFECT_CURSE && !IS_BATTLER_OF_TYPE(battler, TYPE_GHOST)) @@ -9639,7 +9634,7 @@ enum MoveTarget GetBattlerMoveTargetType(u32 battler, enum Move move) return GetMoveTarget(move); } -bool32 CanTargetBattler(u32 battlerAtk, u32 battlerDef, enum Move move) +bool32 CanTargetBattler(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move) { if (GetMoveEffect(move) == EFFECT_HIT_ENEMY_HEAL_ALLY && IsBattlerAlly(battlerAtk, battlerDef) @@ -9654,7 +9649,7 @@ bool32 CanTargetBattler(u32 battlerAtk, u32 battlerDef, enum Move move) u32 GetNextTarget(u32 moveTarget, bool32 excludeCurrent) { - u32 battler; + enum BattlerId battler; for (battler = 0; battler < MAX_BATTLERS_COUNT; battler++) { if (battler == gBattlerAttacker || !IsBattlerAlive(battler)) @@ -9668,7 +9663,7 @@ u32 GetNextTarget(u32 moveTarget, bool32 excludeCurrent) return battler; } -void CopyMonLevelAndBaseStatsToBattleMon(u32 battler, struct Pokemon *mon) +void CopyMonLevelAndBaseStatsToBattleMon(enum BattlerId battler, struct Pokemon *mon) { gBattleMons[battler].level = GetMonData(mon, MON_DATA_LEVEL); gBattleMons[battler].hp = GetMonData(mon, MON_DATA_HP); @@ -9680,7 +9675,7 @@ void CopyMonLevelAndBaseStatsToBattleMon(u32 battler, struct Pokemon *mon) gBattleMons[battler].spDefense = GetMonData(mon, MON_DATA_SPDEF); } -void CopyMonAbilityAndTypesToBattleMon(u32 battler, struct Pokemon *mon) +void CopyMonAbilityAndTypesToBattleMon(enum BattlerId battler, struct Pokemon *mon) { gBattleMons[battler].ability = GetMonAbility(mon); gBattleMons[battler].types[0] = GetSpeciesType(gBattleMons[battler].species, 0); @@ -9688,7 +9683,7 @@ void CopyMonAbilityAndTypesToBattleMon(u32 battler, struct Pokemon *mon) gBattleMons[battler].types[2] = TYPE_MYSTERY; } -void RecalcBattlerStats(u32 battler, struct Pokemon *mon, bool32 isDynamaxing) +void RecalcBattlerStats(enum BattlerId battler, struct Pokemon *mon, bool32 isDynamaxing) { u32 hp = GetMonData(mon, MON_DATA_HP); u32 oldMaxHp = GetMonData(mon, MON_DATA_MAX_HP); @@ -9714,19 +9709,19 @@ void RecalcBattlerStats(u32 battler, struct Pokemon *mon, bool32 isDynamaxing) CopyMonAbilityAndTypesToBattleMon(battler, mon); } -void RemoveConfusionStatus(u32 battler) +void RemoveConfusionStatus(enum BattlerId battler) { gBattleMons[battler].volatiles.confusionTurns = 0; gBattleMons[battler].volatiles.infiniteConfusion = FALSE; } -u32 GetBattlerGender(u32 battler) +u32 GetBattlerGender(enum BattlerId battler) { return GetGenderFromSpeciesAndPersonality(gBattleMons[battler].species, gBattleMons[battler].personality); } -bool32 AreBattlersOfOppositeGender(u32 battler1, u32 battler2) +bool32 AreBattlersOfOppositeGender(enum BattlerId battler1, enum BattlerId battler2) { u32 gender1 = GetBattlerGender(battler1); u32 gender2 = GetBattlerGender(battler2); @@ -9734,7 +9729,7 @@ bool32 AreBattlersOfOppositeGender(u32 battler1, u32 battler2) return (gender1 != MON_GENDERLESS && gender2 != MON_GENDERLESS && gender1 != gender2); } -bool32 AreBattlersOfSameGender(u32 battler1, u32 battler2) +bool32 AreBattlersOfSameGender(enum BattlerId battler1, enum BattlerId battler2) { u32 gender1 = GetBattlerGender(battler1); u32 gender2 = GetBattlerGender(battler2); @@ -9742,7 +9737,7 @@ bool32 AreBattlersOfSameGender(u32 battler1, u32 battler2) return (gender1 != MON_GENDERLESS && gender2 != MON_GENDERLESS && gender1 == gender2); } -u32 CalcSecondaryEffectChance(u32 battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect) +u32 CalcSecondaryEffectChance(enum BattlerId battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect) { bool8 hasSereneGrace = (battlerAbility == ABILITY_SERENE_GRACE); bool8 hasRainbow = (gSideStatuses[GetBattlerSide(battler)] & SIDE_STATUS_RAINBOW) != 0; @@ -9759,7 +9754,7 @@ u32 CalcSecondaryEffectChance(u32 battler, enum Ability battlerAbility, const st return secondaryEffectChance; } -bool32 MoveEffectIsGuaranteed(u32 battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect) +bool32 MoveEffectIsGuaranteed(enum BattlerId battler, enum Ability battlerAbility, const struct AdditionalEffect *additionalEffect) { return additionalEffect->chance == 0 || CalcSecondaryEffectChance(battler, battlerAbility, additionalEffect) >= 100; } @@ -9859,7 +9854,7 @@ bool32 CanMonParticipateInSkyBattle(struct Pokemon *mon) return FALSE; } -void GetBattlerTypes(u32 battler, bool32 ignoreTera, enum Type types[static 3]) +void GetBattlerTypes(enum BattlerId battler, bool32 ignoreTera, enum Type types[static 3]) { // Terastallization. bool32 isTera = GetActiveGimmick(battler) == GIMMICK_TERA; @@ -9889,14 +9884,14 @@ void GetBattlerTypes(u32 battler, bool32 ignoreTera, enum Type types[static 3]) } } -enum Type GetBattlerType(u32 battler, u32 typeIndex, bool32 ignoreTera) +enum Type GetBattlerType(enum BattlerId battler, u32 typeIndex, bool32 ignoreTera) { enum Type types[3]; GetBattlerTypes(battler, ignoreTera, types); return types[typeIndex]; } -void RemoveBattlerType(u32 battler, enum Type type) +void RemoveBattlerType(enum BattlerId battler, enum Type type) { u32 i; if (GetActiveGimmick(battler) == GIMMICK_TERA) // don't remove type if Terastallized @@ -9910,7 +9905,7 @@ void RemoveBattlerType(u32 battler, enum Type type) void SetShellSideArmCategory(void) { - u32 battlerAtk, battlerDef; + enum BattlerId battlerAtk, battlerDef; u32 attackerAtkStat; u32 targetDefStat; u32 attackerSpAtkStat; @@ -9967,14 +9962,14 @@ void SetShellSideArmCategory(void) } } -bool32 CanTargetPartner(u32 battlerAtk, u32 battlerDef) +bool32 CanTargetPartner(enum BattlerId battlerAtk, enum BattlerId battlerDef) { return (IsDoubleBattle() && IsBattlerAlive(BATTLE_PARTNER(battlerDef)) && battlerDef != BATTLE_PARTNER(battlerAtk)); } -bool32 IsBattlerUnaffectedByMove(u32 battler) +bool32 IsBattlerUnaffectedByMove(enum BattlerId battler) { return gBattleStruct->moveResultFlags[battler] & MOVE_RESULT_NO_EFFECT; } @@ -9994,7 +9989,7 @@ enum Type GetBattleMoveType(enum Move move) return GetMoveType(move); } -void TryActivateSleepClause(u32 battler, u32 indexInParty) +void TryActivateSleepClause(enum BattlerId battler, u32 indexInParty) { if (gBattleStruct->battlerState[battler].sleepClauseEffectExempt) { @@ -10033,7 +10028,7 @@ bool32 IsSleepClauseEnabled(void) void ClearDamageCalcResults(void) { - for (u32 battler = 0; battler < MAX_BATTLERS_COUNT; battler++) + for (enum BattlerId battler = 0; battler < MAX_BATTLERS_COUNT; battler++) { gBattleStruct->moveDamage[battler] = 0; gBattleStruct->moveResultFlags[battler] = 0; @@ -10055,7 +10050,7 @@ void ClearDamageCalcResults(void) gBattleStruct->moldBreakerActive = FALSE; } -bool32 DoesDestinyBondFail(u32 battler) +bool32 DoesDestinyBondFail(enum BattlerId battler) { return GetConfig(CONFIG_DESTINY_BOND_FAIL) >= GEN_7 && gBattleMons[battler].volatiles.destinyBond; } @@ -10077,12 +10072,12 @@ bool32 IsMoveEffectBlockedByTarget(enum Ability ability) return FALSE; } -bool32 SetTargetToNextPursuiter(u32 battlerDef) +bool32 SetTargetToNextPursuiter(enum BattlerId battlerDef) { u32 i; for (i = gCurrentTurnActionNumber + 1; i < gBattlersCount; i++) { - u32 battler = gBattlerByTurnOrder[i]; + enum BattlerId battler = gBattlerByTurnOrder[i]; if (gChosenActionByBattler[battler] == B_ACTION_USE_MOVE && GetMoveEffect(gChosenMoveByBattler[battler]) == EFFECT_PURSUIT && IsBattlerAlive(battlerDef) @@ -10102,7 +10097,7 @@ bool32 SetTargetToNextPursuiter(u32 battlerDef) bool32 IsPursuitTargetSet(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (gBattleStruct->battlerState[battler].pursuitTarget) return TRUE; @@ -10112,12 +10107,12 @@ bool32 IsPursuitTargetSet(void) void ClearPursuitValues(void) { - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleStruct->battlerState[i].pursuitTarget = FALSE; gBattleStruct->pursuitStoredSwitch = PARTY_SIZE; } -void ClearPursuitValuesIfSet(u32 battler) +void ClearPursuitValuesIfSet(enum BattlerId battler) { if (gBattleStruct->battlerState[battler].pursuitTarget) ClearPursuitValues(); @@ -10125,7 +10120,7 @@ void ClearPursuitValuesIfSet(u32 battler) bool32 HasWeatherEffect(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (!IsBattlerAlive(battler)) continue; @@ -10185,7 +10180,7 @@ bool32 TrySwitchInEjectPack(enum EjectPackTiming timing) u32 ejectPackBattlers = 0; u32 numEjectPackBattlers = 0; - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (gBattleMons[i].volatiles.tryEjectPack && GetBattlerHoldEffect(i) == HOLD_EFFECT_EJECT_PACK @@ -10200,16 +10195,16 @@ bool32 TrySwitchInEjectPack(enum EjectPackTiming timing) if (numEjectPackBattlers == 0) return FALSE; - u8 battlers[4] = {0, 1, 2, 3}; + enum BattlerId battlers[MAX_BATTLERS_COUNT] = {0, 1, 2, 3}; if (numEjectPackBattlers > 1) SortBattlersBySpeed(battlers, FALSE); - for (u32 i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) gBattleMons[i].volatiles.tryEjectPack = FALSE; for (u32 i = 0; i < gBattlersCount; i++) { - u32 battler = battlers[i]; + enum BattlerId battler = battlers[i]; if (!(ejectPackBattlers & 1u << battler)) continue; @@ -10227,7 +10222,7 @@ bool32 TrySwitchInEjectPack(enum EjectPackTiming timing) return FALSE; } -bool32 EmergencyExitCanBeTriggered(u32 battler) +bool32 EmergencyExitCanBeTriggered(enum BattlerId battler) { enum Ability ability = GetBattlerAbility(battler); @@ -10244,7 +10239,7 @@ bool32 EmergencyExitCanBeTriggered(u32 battler) return FALSE; } -bool32 TryTriggerSymbiosis(u32 battler, u32 ally) +bool32 TryTriggerSymbiosis(enum BattlerId battler, u32 ally) { return GetBattlerAbility(ally) == ABILITY_SYMBIOSIS && gBattleMons[battler].item == ITEM_NONE @@ -10256,7 +10251,7 @@ bool32 TryTriggerSymbiosis(u32 battler, u32 ally) } // Called by Cmd_removeitem. itemId represents the item that was removed, not being given. -bool32 TrySymbiosis(u32 battler, enum Item itemId, bool32 moveEnd) +bool32 TrySymbiosis(enum BattlerId battler, enum Item itemId, bool32 moveEnd) { if (!gBattleStruct->itemLost[B_SIDE_PLAYER][gBattlerPartyIndexes[battler]].stolen && gBattleStruct->changedItems[battler] == ITEM_NONE @@ -10282,7 +10277,7 @@ bool32 TrySymbiosis(u32 battler, enum Item itemId, bool32 moveEnd) } // Used by Bestow and Symbiosis to take an item from one battler and give to another. -void BestowItem(u32 battlerAtk, u32 battlerDef) +void BestowItem(enum BattlerId battlerAtk, enum BattlerId battlerDef) { gLastUsedItem = gBattleMons[battlerAtk].item; @@ -10302,7 +10297,7 @@ void BestowItem(u32 battlerAtk, u32 battlerDef) // Gets the value of a volatile status flag for a certain battler // Primarily used for the debug menu and scripts. Outside of it explicit references are preferred // Uses Arm because there is a compiler bug when it tries to compile in thumb -ARM_FUNC u32 GetBattlerVolatile(u32 battler, enum Volatile _volatile) +ARM_FUNC u32 GetBattlerVolatile(enum BattlerId battler, enum Volatile _volatile) { switch (_volatile) { @@ -10320,7 +10315,7 @@ ARM_FUNC u32 GetBattlerVolatile(u32 battler, enum Volatile _volatile) // Sets the value of a volatile status flag for a certain battler // Primarily used for the debug menu and scripts. Outside of it explicit references are preferred -void SetMonVolatile(u32 battler, enum Volatile _volatile, u32 newValue) +void SetMonVolatile(enum BattlerId battler, enum Volatile _volatile, u32 newValue) { switch (_volatile) { @@ -10335,7 +10330,7 @@ void SetMonVolatile(u32 battler, enum Volatile _volatile, u32 newValue) } } -bool32 ItemHealMonVolatile(u32 battler, enum Item itemId) +bool32 ItemHealMonVolatile(enum BattlerId battler, enum Item itemId) { bool32 statusChanged = FALSE; const u8 *effect = GetItemEffect(itemId); @@ -10437,12 +10432,12 @@ void RemoveHazardFromField(enum BattleSide side, enum Hazards hazardType) } } -static bool32 CanMoveSkipAccuracyCheck(u32 battlerAtk, u32 move) +static bool32 CanMoveSkipAccuracyCheck(enum BattlerId battlerAtk, u32 move) { return MoveAlwaysHitsOnSameType(move) && IS_BATTLER_OF_TYPE(battlerAtk, GetMoveType(move)); } -bool32 CanMoveSkipAccuracyCalc(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move, enum ResultOption option) +bool32 CanMoveSkipAccuracyCalc(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move, enum ResultOption option) { bool32 effect = FALSE; enum Ability ability = ABILITY_NONE; @@ -10512,7 +10507,7 @@ bool32 CanMoveSkipAccuracyCalc(u32 battlerAtk, u32 battlerDef, enum Ability abil return effect; } -u32 GetTotalAccuracy(u32 battlerAtk, u32 battlerDef, enum Move move, enum Ability atkAbility, enum Ability defAbility, enum HoldEffect atkHoldEffect, enum HoldEffect defHoldEffect) +u32 GetTotalAccuracy(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Move move, enum Ability atkAbility, enum Ability defAbility, enum HoldEffect atkHoldEffect, enum HoldEffect defHoldEffect) { u32 calc, moveAcc; s8 buff, accStage, evasionStage; @@ -10588,7 +10583,7 @@ u32 GetTotalAccuracy(u32 battlerAtk, u32 battlerDef, enum Move move, enum Abilit } // Attacker's ally's ability - u32 atkAlly = BATTLE_PARTNER(battlerAtk); + enum BattlerId atkAlly = BATTLE_PARTNER(battlerAtk); switch (GetBattlerAbility(atkAlly)) { case ABILITY_VICTORY_STAR: @@ -10726,14 +10721,14 @@ bool32 DoesMoveMissTarget(struct BattleCalcValues *cv) return !RandomPercentage(RNG_ACCURACY, accuracy); } -bool32 IsSemiInvulnerable(u32 battler, enum SemiInvulnerableExclusion excludeCommander) +bool32 IsSemiInvulnerable(enum BattlerId battler, enum SemiInvulnerableExclusion excludeCommander) { if (gBattleMons[battler].volatiles.semiInvulnerable == STATE_COMMANDER) return excludeCommander != EXCLUDE_COMMANDER; return gBattleMons[battler].volatiles.semiInvulnerable != STATE_NONE; } -bool32 BreaksThroughSemiInvulnerablity(u32 battlerAtk, u32 battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move) +bool32 BreaksThroughSemiInvulnerablity(enum BattlerId battlerAtk, enum BattlerId battlerDef, enum Ability abilityAtk, enum Ability abilityDef, enum Move move) { enum SemiInvulnerableState state = gBattleMons[battlerDef].volatiles.semiInvulnerable; @@ -10768,7 +10763,7 @@ bool32 BreaksThroughSemiInvulnerablity(u32 battlerAtk, u32 battlerDef, enum Abil return FALSE; } -bool32 HasPartnerTrainer(u32 battler) +bool32 HasPartnerTrainer(enum BattlerId battler) { if ((GetBattlerSide(battler) == B_SIDE_PLAYER && gBattleTypeFlags & BATTLE_TYPE_PLAYER_HAS_PARTNER) || (GetBattlerSide(battler) == B_SIDE_OPPONENT && gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)) @@ -10777,9 +10772,9 @@ bool32 HasPartnerTrainer(u32 battler) return FALSE; } -static bool32 IsOpposingSideEmpty(u32 battler) +static bool32 IsOpposingSideEmpty(enum BattlerId battler) { - u32 oppositeBattler = BATTLE_OPPOSITE(battler); + enum BattlerId oppositeBattler = BATTLE_OPPOSITE(battler); if (IsBattlerAlive(oppositeBattler)) return FALSE; @@ -10792,7 +10787,7 @@ static bool32 IsOpposingSideEmpty(u32 battler) return TRUE; } -bool32 IsAffectedByPowderMove(u32 battler, enum Ability ability, enum HoldEffect holdEffect) +bool32 IsAffectedByPowderMove(enum BattlerId battler, enum Ability ability, enum HoldEffect holdEffect) { if (GetConfig(CONFIG_POWDER_OVERCOAT) >= GEN_6 && ability == ABILITY_OVERCOAT) return FALSE; @@ -10803,7 +10798,7 @@ bool32 IsAffectedByPowderMove(u32 battler, enum Ability ability, enum HoldEffect return TRUE; } -void RemoveAbilityFlags(u32 battler) +void RemoveAbilityFlags(enum BattlerId battler) { gBattleMons[battler].volatiles.unburdenActive = FALSE; @@ -10829,15 +10824,15 @@ void RemoveAbilityFlags(u32 battler) } } -void CheckSetUnburden(u32 battler) +void CheckSetUnburden(enum BattlerId battler) { if (IsAbilityAndRecord(battler, GetBattlerAbility(battler), ABILITY_UNBURDEN)) gBattleMons[battler].volatiles.unburdenActive = TRUE; } -bool32 IsAnyTargetTurnDamaged(u32 battlerAtk) +bool32 IsAnyTargetTurnDamaged(enum BattlerId battlerAtk) { - for (u32 battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) + for (enum BattlerId battlerDef = 0; battlerDef < gBattlersCount; battlerDef++) { if (battlerDef == battlerAtk) continue; @@ -10849,7 +10844,7 @@ bool32 IsAnyTargetTurnDamaged(u32 battlerAtk) bool32 IsAnyTargetAffected(void) { - for (u32 battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { if (battler == gBattlerAttacker) continue; @@ -10867,7 +10862,7 @@ bool32 IsDoubleSpreadMove(void) && IsSpreadMove(GetBattlerMoveTargetType(gBattlerAttacker, gCurrentMove)); } -bool32 IsBattlerInvalidForSpreadMove(u32 battlerAtk, u32 battlerDef) +bool32 IsBattlerInvalidForSpreadMove(enum BattlerId battlerAtk, enum BattlerId battlerDef) { return battlerDef == battlerAtk || !IsBattlerAlive(battlerDef) @@ -10889,7 +10884,7 @@ bool32 IsAllowedToUseBag(void) } } -bool32 IsMimikyuDisguised(u32 battler) +bool32 IsMimikyuDisguised(enum BattlerId battler) { return gBattleMons[battler].species == SPECIES_MIMIKYU_DISGUISED || gBattleMons[battler].species == SPECIES_MIMIKYU_TOTEM_DISGUISED; @@ -10925,7 +10920,7 @@ bool32 IsUsableWhileAsleepEffect(enum BattleMoveEffects effect) } } -void SetWrapTurns(u32 battler, enum HoldEffect holdEffect) +void SetWrapTurns(enum BattlerId battler, enum HoldEffect holdEffect) { u32 normalWrapTurns = B_WRAP_TURNS - 2; // 5 turns if (holdEffect == HOLD_EFFECT_GRIP_CLAW) @@ -11054,7 +11049,7 @@ static const u16 sGen5ProtectSuccessRates[] = USHRT_MAX / 27 }; -bool32 CanUseMoveConsecutively(u32 battler) +bool32 CanUseMoveConsecutively(enum BattlerId battler) { u32 moveUses = gBattleMons[battler].volatiles.consecutiveMoveUses; if (moveUses >= ARRAY_COUNT(sProtectSuccessRates)) @@ -11068,7 +11063,7 @@ bool32 CanUseMoveConsecutively(u32 battler) } // Used for Protect, Endure and Ally switch -void TryResetConsecutiveUseCounter(u32 battler) +void TryResetConsecutiveUseCounter(enum BattlerId battler) { u32 lastMove = gLastResultingMoves[battler]; if (lastMove == MOVE_UNAVAILABLE) diff --git a/src/battle_util2.c b/src/battle_util2.c index 3f25271300..eac1034272 100644 --- a/src/battle_util2.c +++ b/src/battle_util2.c @@ -76,13 +76,13 @@ void FreeBattleResources(void) } } -void AdjustFriendshipOnBattleFaint(u8 battler) +void AdjustFriendshipOnBattleFaint(enum BattlerId battler) { - u8 opposingBattlerId; + enum BattlerId opposingBattlerId; if (IsDoubleBattle()) { - u8 opposingBattlerId2; + enum BattlerId opposingBattlerId2; opposingBattlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); opposingBattlerId2 = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); @@ -101,7 +101,7 @@ void AdjustFriendshipOnBattleFaint(u8 battler) AdjustFriendship(GetBattlerMon(battler), FRIENDSHIP_EVENT_FAINT_SMALL); } -void SwitchPartyOrderInGameMulti(u8 battler, u8 arg1) +void SwitchPartyOrderInGameMulti(enum BattlerId battler, u8 arg1) { if (IsOnPlayerSide(battler)) { @@ -118,7 +118,7 @@ void SwitchPartyOrderInGameMulti(u8 battler, 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 battler) +u32 BattlePalace_TryEscapeStatus(enum BattlerId battler) { u32 effect = 0; diff --git a/src/battle_z_move.c b/src/battle_z_move.c index 94c62e6f15..4762701352 100644 --- a/src/battle_z_move.c +++ b/src/battle_z_move.c @@ -44,9 +44,9 @@ #define STAT_STAGE(battler, stat) (gBattleMons[battler].statStages[stat - 1]) // Function Declarations -static void ZMoveSelectionDisplayPpNumber(u32 battler); +static void ZMoveSelectionDisplayPpNumber(enum BattlerId battler); static void ZMoveSelectionDisplayPower(enum Move move, enum Move zMove); -static void ZMoveSelectionDisplayMoveType(enum Move zMove, u32 battler); +static void ZMoveSelectionDisplayMoveType(enum Move zMove, enum BattlerId battler); // Const Data static const struct SignatureZMove sSignatureZMoves[] = @@ -110,13 +110,14 @@ bool32 IsZMove(enum Move move) return move >= FIRST_Z_MOVE && move <= LAST_Z_MOVE; } -bool32 CanUseZMove(u32 battler) +bool32 CanUseZMove(enum BattlerId battler) { enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); + enum BattlerPosition position = GetBattlerPosition(battler); // Check if Player has Z-Power Ring. - if (!TESTING && (battler == B_POSITION_PLAYER_LEFT - || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && battler == B_POSITION_PLAYER_RIGHT)) + if (!TESTING && (position == B_POSITION_PLAYER_LEFT + || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && position == B_POSITION_PLAYER_RIGHT)) && !CheckBagHasItem(ITEM_Z_POWER_RING, 1)) return FALSE; @@ -140,7 +141,7 @@ bool32 CanUseZMove(u32 battler) return TRUE; } -enum Move GetUsableZMove(u32 battler, enum Move move) +enum Move GetUsableZMove(enum BattlerId battler, enum Move move) { enum Item item = gBattleMons[battler].item; enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); @@ -158,12 +159,12 @@ enum Move GetUsableZMove(u32 battler, enum Move move) return MOVE_NONE; } -void ActivateZMove(u32 battler) +void ActivateZMove(enum BattlerId battler) { SetActiveGimmick(battler, GIMMICK_Z_MOVE); } -bool32 IsViableZMove(u32 battler, enum Move move) +bool32 IsViableZMove(enum BattlerId battler, enum Move move) { enum Item item; enum HoldEffect holdEffect = GetBattlerHoldEffectIgnoreNegation(battler); @@ -180,8 +181,9 @@ bool32 IsViableZMove(u32 battler, enum Move move) return FALSE; } + enum BattlerPosition position = GetBattlerPosition(battler); // Check if Player has Z-Power Ring. - if ((battler == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && battler == B_POSITION_PLAYER_RIGHT)) + if ((position == B_POSITION_PLAYER_LEFT || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && position == B_POSITION_PLAYER_RIGHT)) && !CheckBagHasItem(ITEM_Z_POWER_RING, 1)) { return FALSE; @@ -201,7 +203,7 @@ bool32 IsViableZMove(u32 battler, enum Move move) return FALSE; } -void AssignUsableZMoves(u32 battler, enum Move *moves) +void AssignUsableZMoves(enum BattlerId battler, enum Move *moves) { u32 i; gBattleStruct->zmove.possibleZMoves[battler] = 0; @@ -212,7 +214,7 @@ void AssignUsableZMoves(u32 battler, enum Move *moves) } } -bool32 TryChangeZTrigger(u32 battler, u32 moveIndex) +bool32 TryChangeZTrigger(enum BattlerId battler, u32 moveIndex) { bool32 viableZMove = (gBattleStruct->zmove.possibleZMoves[battler] & (1u << moveIndex)) != 0; @@ -257,7 +259,7 @@ enum Move GetTypeBasedZMove(enum Move move) return gTypesInfo[moveType].zMove; } -bool32 MoveSelectionDisplayZMove(enum Move zmove, u32 battler) +bool32 MoveSelectionDisplayZMove(enum Move zmove, enum BattlerId battler) { u32 i; struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleResources->bufferA[battler][4]); @@ -401,7 +403,7 @@ static void ZMoveSelectionDisplayPower(enum Move move, enum Move zMove) } } -static void ZMoveSelectionDisplayPpNumber(u32 battler) +static void ZMoveSelectionDisplayPpNumber(enum BattlerId battler) { u8 *txtPtr; @@ -415,7 +417,7 @@ static void ZMoveSelectionDisplayPpNumber(u32 battler) BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP_REMAINING); } -static void ZMoveSelectionDisplayMoveType(enum Move zMove, u32 battler) +static void ZMoveSelectionDisplayMoveType(enum Move zMove, enum BattlerId battler) { u8 *txtPtr, *end; enum Type zMoveType = GetBattleMoveType(zMove); diff --git a/src/contest.c b/src/contest.c index 506313a513..3264437608 100644 --- a/src/contest.c +++ b/src/contest.c @@ -5394,12 +5394,12 @@ static void CreateInvisibleBattleTargetSprite(void) static void SetBattleTargetSpritePosition(void) { - struct Sprite *sprite = &gSprites[gBattlerSpriteIds[B_POSITION_OPPONENT_RIGHT]]; + struct Sprite *sprite = &gSprites[gBattlerSpriteIds[B_BATTLER_3]]; sprite->x2 = 0; sprite->y2 = 0; - sprite->x = GetBattlerSpriteCoord(B_POSITION_OPPONENT_RIGHT, BATTLER_COORD_X); - sprite->y = GetBattlerSpriteCoord(B_POSITION_OPPONENT_RIGHT, BATTLER_COORD_Y); + sprite->x = GetBattlerSpriteCoord(B_BATTLER_3, BATTLER_COORD_X); + sprite->y = GetBattlerSpriteCoord(B_BATTLER_3, BATTLER_COORD_Y); sprite->invisible = TRUE; } @@ -5408,7 +5408,7 @@ static void SetMoveTargetPosition(enum Move move) switch (GetBattlerMoveTargetType(gBattlerAttacker, move)) { case TARGET_USER: - gBattlerTarget = B_POSITION_PLAYER_RIGHT; + gBattlerTarget = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); break; case TARGET_OPPONENT: case TARGET_SELECTED: @@ -5418,7 +5418,7 @@ static void SetMoveTargetPosition(enum Move move) case TARGET_FOES_AND_ALLY: case TARGET_USER_AND_ALLY: default: - gBattlerTarget = B_POSITION_OPPONENT_RIGHT; + gBattlerTarget = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); break; } } diff --git a/src/item_use.c b/src/item_use.c index b2fdad5896..5dc1155d07 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -1227,7 +1227,7 @@ void ItemUseInBattle_PartyMenuChooseMove(u8 taskId) ItemUseInBattle_ShowPartyMenu(taskId); } -static bool32 IteamHealsMonVolatile(u32 battler, enum Item itemId) +static bool32 IteamHealsMonVolatile(enum BattlerId battler, enum Item itemId) { const u8 *effect = GetItemEffect(itemId); if (effect[3] & ITEM3_STATUS_ALL) diff --git a/src/party_menu.c b/src/party_menu.c index e9525bfa38..0e6be73d8f 100644 --- a/src/party_menu.c +++ b/src/party_menu.c @@ -443,7 +443,7 @@ static u8 GetMaxBattleEntries(void); static u8 GetMinBattleEntries(void); static void Task_ContinueChoosingHalfParty(u8); static void BufferBattlePartyOrder(u8 *, bool8); -static void BufferBattlePartyOrderBySide(u8 *, u8, u8); +static void BufferBattlePartyOrderBySide(u8 *, u8, enum BattlerId); static void Task_InitMultiPartnerPartySlideIn(u8); static void Task_MultiPartnerPartySlideIn(u8); static void SlideMultiPartyMenuBoxSpritesOneStep(u8); @@ -7431,7 +7431,6 @@ static bool8 TrySwitchInPokemon(void) { u8 slot = GetCursorSelectionMonId(); u8 newSlot; - u8 i; // In a multi battle, slots 1, 4, and 5 are the partner's Pokémon if (IsMultiBattle() == TRUE && (slot == 1 || slot == 4 || slot == 5)) @@ -7446,7 +7445,7 @@ static bool8 TrySwitchInPokemon(void) StringExpandPlaceholders(gStringVar4, gText_PkmnHasNoEnergy); return FALSE; } - for (i = 0; i < gBattlersCount; i++) + for (enum BattlerId i = 0; i < gBattlersCount; i++) { if (IsOnPlayerSide(i) && GetPartyIdFromBattleSlot(slot) == gBattlerPartyIndexes[i]) { @@ -7545,18 +7544,18 @@ static void BufferBattlePartyOrder(u8 *partyBattleOrder, u8 flankId) partyBattleOrder[i] = (partyIds[0 + (i * 2)] << 4) | partyIds[1 + (i * 2)]; } -void BufferBattlePartyCurrentOrderBySide(u8 battler, u8 flankId) +void BufferBattlePartyCurrentOrderBySide(enum BattlerId battler, u8 flankId) { BufferBattlePartyOrderBySide(gBattleStruct->battlerPartyOrders[battler], flankId, battler); } // when IsOnPlayerSide(battlerId), this function is identical the one above -static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 battler) +static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, enum BattlerId battler) { u8 partyIndexes[PARTY_SIZE]; int i, j; - u8 leftBattler; + enum BattlerId leftBattler; if (IsOnPlayerSide(battler)) leftBattler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); else @@ -7593,7 +7592,7 @@ static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 ba } else { - u8 rightBattler; + enum BattlerId rightBattler; if (IsOnPlayerSide(battler)) rightBattler = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); else @@ -7616,7 +7615,7 @@ static void BufferBattlePartyOrderBySide(u8 *partyBattleOrder, u8 flankId, u8 ba partyBattleOrder[i] = (partyIndexes[0 + (i * 2)] << 4) | partyIndexes[1 + (i * 2)]; } -void SwitchPartyOrderLinkMulti(u8 battler, u8 slot, u8 slot2) +void SwitchPartyOrderLinkMulti(enum BattlerId battler, u8 slot, u8 slot2) { u8 partyIds[PARTY_SIZE]; u8 tempSlot = 0; diff --git a/src/pokeball.c b/src/pokeball.c index 18d39bbfbb..de3bb97fe0 100644 --- a/src/pokeball.c +++ b/src/pokeball.c @@ -18,9 +18,9 @@ #include "constants/songs.h" static void Task_DoPokeballSendOutAnim(u8 taskId); -static inline void DoPokeballSendOutSoundEffect(u32 battler); +static inline void DoPokeballSendOutSoundEffect(enum BattlerId battler); static inline void *GetOpponentMonSendOutCallback(void); -static inline bool32 IsBattlerPlayer(u32 battler); +static inline bool32 IsBattlerPlayer(enum BattlerId battler); static void SpriteCB_MonSendOut_1(struct Sprite *sprite); static void SpriteCB_MonSendOut_2(struct Sprite *sprite); static void SpriteCB_OpponentMonSendOut(struct Sprite *sprite); @@ -45,7 +45,7 @@ static void SpriteCB_TradePokeballEnd(struct Sprite *sprite); static void SpriteCB_HealthboxSlideInDelayed(struct Sprite *sprite); static void SpriteCB_HealthboxSlideIn(struct Sprite *sprite); static void SpriteCB_HitAnimHealthoxEffect(struct Sprite *sprite); -static u16 GetBattlerPokeballItemId(u8 battler); +static u16 GetBattlerPokeballItemId(enum BattlerId battler); // rom const data @@ -381,7 +381,7 @@ const struct PokeBallSprite gPokeBalls[POKEBALL_COUNT] = }, }; -u8 DoPokeballSendOutAnimation(u32 battler, s16 pan, u8 kindOfThrow) +u8 DoPokeballSendOutAnimation(enum BattlerId battler, s16 pan, u8 kindOfThrow) { u8 taskId; @@ -400,7 +400,8 @@ u8 DoPokeballSendOutAnimation(u32 battler, s16 pan, u8 kindOfThrow) static void Task_DoPokeballSendOutAnim(u8 taskId) { - u32 throwCaseId, ballId, battler, ballSpriteId; + u32 throwCaseId, ballId, ballSpriteId; + enum BattlerId battler; bool32 notSendOut = FALSE; u32 throwXoffset = (B_ENEMY_THROW_BALLS >= GEN_6 && !gTestRunnerHeadless) ? 24 : 0; s32 throwYoffset = (B_ENEMY_THROW_BALLS >= GEN_6 && !gTestRunnerHeadless) ? -16 : 24; @@ -467,7 +468,7 @@ static void Task_DoPokeballSendOutAnim(u8 taskId) PlaySE(SE_BALL_THROW); } -static inline void DoPokeballSendOutSoundEffect(u32 battler) +static inline void DoPokeballSendOutSoundEffect(enum BattlerId battler) { if (IsBattlerPlayer(battler) && B_PLAYER_THROW_BALLS_SOUND < GEN_5) return; @@ -732,7 +733,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId) u8 wantedCry = gTasks[taskId].tCryTaskWantedCry; s8 pan = gTasks[taskId].tCryTaskPan; u16 species = gTasks[taskId].tCryTaskSpecies; - u8 battler = gTasks[taskId].tCryTaskBattler; + enum BattlerId battler = gTasks[taskId].tCryTaskBattler; u8 monSpriteId = gTasks[taskId].tCryTaskMonSpriteId; struct Pokemon *mon = (void *)(u32)((gTasks[taskId].tCryTaskMonPtr1 << 16) | (u16)(gTasks[taskId].tCryTaskMonPtr2)); @@ -814,7 +815,7 @@ static void Task_PlayCryWhenReleasedFromBall(u8 taskId) static void SpriteCB_ReleaseMonFromBall(struct Sprite *sprite) { - u8 battler = sprite->sBattler; + enum BattlerId battler = sprite->sBattler; u32 ballId; StartSpriteAnim(sprite, 1); @@ -909,7 +910,7 @@ static void SpriteCB_BallThrow_StartCaptureMon(struct Sprite *sprite) static void HandleBallAnimEnd(struct Sprite *sprite) { bool8 affineAnimEnded = FALSE; - u8 battler = sprite->sBattler; + enum BattlerId battler = sprite->sBattler; if (sprite->data[7] == POKEBALL_PLAYER_SLIDEIN) { @@ -959,7 +960,7 @@ static void HandleBallAnimEnd(struct Sprite *sprite) static void SpriteCB_BallThrow_CaptureMon(struct Sprite *sprite) { - u8 battler = sprite->sBattler; + enum BattlerId battler = sprite->sBattler; sprite->data[4]++; if (sprite->data[4] == 40) @@ -982,7 +983,7 @@ static void SpriteCB_BallThrow_CaptureMon(struct Sprite *sprite) } } -static inline bool32 IsBattlerPlayer(u32 battler) +static inline bool32 IsBattlerPlayer(enum BattlerId battler) { return (battler % B_POSITION_PLAYER_RIGHT) ? FALSE : TRUE; } @@ -1326,7 +1327,7 @@ static void UNUSED DestroySpriteAndFreeResources_Ball(struct Sprite *sprite) #define sDelayTimer data[1] -void StartHealthboxSlideIn(u8 battler) +void StartHealthboxSlideIn(enum BattlerId battler) { struct Sprite *healthboxSprite = &gSprites[gHealthboxSpriteIds[battler]]; @@ -1369,7 +1370,7 @@ static void SpriteCB_HealthboxSlideIn(struct Sprite *sprite) #undef sSpeedY #undef sDelayTimer -void DoHitAnimHealthboxEffect(u8 battler) +void DoHitAnimHealthboxEffect(enum BattlerId battler) { u8 spriteId; @@ -1422,7 +1423,7 @@ void FreeBallGfx(u8 ballId) FreeSpritePaletteByTag(gPokeBalls[ballId].palette.tag); } -static u16 GetBattlerPokeballItemId(u8 battler) +static u16 GetBattlerPokeballItemId(enum BattlerId battler) { struct Pokemon *illusionMon; struct Pokemon *mon = GetBattlerMon(battler); diff --git a/src/pokemon.c b/src/pokemon.c index 95ee08693e..795fca3eee 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -1921,9 +1921,9 @@ void DeleteFirstMoveAndGiveMoveToBoxMon(struct BoxPokemon *boxMon, enum Move mov SetBoxMonData(boxMon, MON_DATA_PP_BONUSES, &ppBonuses); } -u8 CountAliveMonsInBattle(u8 caseId, u32 battler) +u8 CountAliveMonsInBattle(u8 caseId, enum BattlerId battler) { - u32 i; + enum BattlerId i; u32 retVal = 0; switch (caseId) @@ -1954,7 +1954,7 @@ u8 CountAliveMonsInBattle(u8 caseId, u32 battler) return retVal; } -u8 GetDefaultMoveTarget(u8 battlerId) +u8 GetDefaultMoveTarget(enum BattlerId battlerId) { u8 opposing = BATTLE_OPPOSITE(GetBattlerSide(battlerId)); @@ -3210,7 +3210,7 @@ u8 CalculatePartyCount(struct Pokemon *party) return partyCount; } -u8 CalculatePartyCountOfSide(u32 battler, struct Pokemon *party) +u8 CalculatePartyCountOfSide(enum BattlerId battler, struct Pokemon *party) { s32 partyCount, partySize; GetAIPartyIndexes(battler, &partyCount, &partySize); @@ -3236,7 +3236,7 @@ u8 CalculateEnemyPartyCount(void) return gEnemyPartyCount; } -u8 CalculateEnemyPartyCountInSide(u32 battler) +u8 CalculateEnemyPartyCountInSide(enum BattlerId battler) { return CalculatePartyCountOfSide(battler, gEnemyParty); } @@ -3600,7 +3600,7 @@ void PokemonToBattleMon(struct Pokemon *src, struct BattlePokemon *dst) memset(&dst->volatiles, 0, sizeof(struct Volatiles)); } -void CopyPartyMonToBattleData(u32 battler, u32 partyIndex) +void CopyPartyMonToBattleData(enum BattlerId battler, u32 partyIndex) { enum BattleSide side = GetBattlerSide(battler); struct Pokemon *party = GetSideParty(side); @@ -3653,7 +3653,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, enum Item item, u8 partyIndex, u32 temp1, temp2; s8 friendshipChange = 0; enum HoldEffect holdEffect; - u8 battler = MAX_BATTLERS_COUNT; + enum BattlerId battler = MAX_BATTLERS_COUNT; bool32 friendshipOnly = FALSE; enum Item heldItem; u8 effectFlags; @@ -4090,7 +4090,7 @@ bool8 PokemonUseItemEffects(struct Pokemon *mon, enum Item item, u8 partyIndex, return retVal; } -bool8 HealStatusConditions(struct Pokemon *mon, u32 healMask, u8 battler) +bool8 HealStatusConditions(struct Pokemon *mon, u32 healMask, enum BattlerId battler) { u32 status = GetMonData(mon, MON_DATA_STATUS, 0); @@ -4125,7 +4125,7 @@ bool8 HealStatusConditions(struct Pokemon *mon, u32 healMask, u8 battler) } } -u8 GetItemEffectParamOffset(u32 battler, enum Item itemId, u8 effectByte, u8 effectBit) +u8 GetItemEffectParamOffset(enum BattlerId battler, enum Item itemId, u8 effectByte, u8 effectBit) { const u8 *temp; const u8 *itemEffect; @@ -6748,7 +6748,7 @@ void UpdateDaysPassedSinceFormChange(u16 days) } } -enum Type CheckDynamicMoveType(struct Pokemon *mon, enum Move move, u32 battler, enum MonState state) +enum Type CheckDynamicMoveType(struct Pokemon *mon, enum Move move, enum BattlerId battler, enum MonState state) { enum Type moveType = GetDynamicMoveType(mon, move, battler, state); if (moveType != TYPE_NONE) diff --git a/src/pokemon_sprite_visualizer.c b/src/pokemon_sprite_visualizer.c index bedd8ec25b..96f61d57c9 100644 --- a/src/pokemon_sprite_visualizer.c +++ b/src/pokemon_sprite_visualizer.c @@ -782,13 +782,13 @@ static void UpdateBattlerValue(struct PokemonSpriteVisualizer *data) } } -static void BattleLoadOpponentMonSpriteGfxCustom(u16 species, bool8 isFemale, bool8 isShiny, u8 battlerId) +static void BattleLoadOpponentMonSpriteGfxCustom(u16 species, bool8 isFemale, bool8 isShiny, enum BattlerId battler) { const u16 *palette = GetMonSpritePalFromSpecies(species, isShiny, isFemale); - u16 paletteOffset = OBJ_PLTT_ID(battlerId); + u16 paletteOffset = OBJ_PLTT_ID(battler); LoadPalette(palette, paletteOffset, PLTT_SIZE_4BPP); - LoadPalette(palette, BG_PLTT_ID(8) + BG_PLTT_ID(battlerId), PLTT_SIZE_4BPP); + LoadPalette(palette, BG_PLTT_ID(8) + BG_PLTT_ID(battler), PLTT_SIZE_4BPP); } static void SetConstSpriteValues(struct PokemonSpriteVisualizer *data) diff --git a/src/recorded_battle.c b/src/recorded_battle.c index f89bfbb73b..9b63a1c89b 100644 --- a/src/recorded_battle.c +++ b/src/recorded_battle.c @@ -151,13 +151,13 @@ void RecordedBattle_SetTrainerInfo(void) } } -void RecordedBattle_SetBattlerAction(u8 battler, u8 action) +void RecordedBattle_SetBattlerAction(enum BattlerId battler, u8 action) { if (sBattlerRecordSizes[battler] < BATTLER_RECORD_SIZE && sRecordMode != B_RECORD_MODE_PLAYBACK) sBattleRecords[battler][sBattlerRecordSizes[battler]++] = action; } -void RecordedBattle_ClearBattlerAction(u8 battler, u8 bytesToClear) +void RecordedBattle_ClearBattlerAction(enum BattlerId battler, u8 bytesToClear) { s32 i; @@ -170,7 +170,7 @@ void RecordedBattle_ClearBattlerAction(u8 battler, u8 bytesToClear) } } -u8 RecordedBattle_GetBattlerAction(u32 actionType, u8 battler) +u8 RecordedBattle_GetBattlerAction(u32 actionType, enum BattlerId battler) { if (gTestRunnerEnabled) TestRunner_Battle_CheckBattleRecordActionType(battler, sBattlerRecordSizes[battler], actionType); @@ -236,7 +236,7 @@ void RecordedBattle_RecordAllBattlerData(u8 *src) { for (size = *src; size != 0;) { - u8 battler = GetNextRecordedDataByte(src, &idx, &size); + enum BattlerId battler = GetNextRecordedDataByte(src, &idx, &size); u8 numActions = GetNextRecordedDataByte(src, &idx, &size); for (i = 0; i < numActions; i++) @@ -617,7 +617,7 @@ static void RecordedBattle_RestoreSavedParties(void) } } -u8 GetBattlerLinkPlayerGender(u32 battler) +u8 GetBattlerLinkPlayerGender(enum BattlerId battler) { s32 i; @@ -659,7 +659,7 @@ u8 GetTextSpeedInRecordedBattle(void) return sTextSpeed; } -void RecordedBattle_CopyBattlerMoves(u32 battler) +void RecordedBattle_CopyBattlerMoves(enum BattlerId battler) { s32 i; @@ -680,12 +680,12 @@ void RecordedBattle_CopyBattlerMoves(u32 battler) void RecordedBattle_CheckMovesetChanges(u8 mode) { - s32 battler, j, k; + s32 j, k; if (gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK)) return; - for (battler = 0; battler < gBattlersCount; battler++) + for (enum BattlerId battler = 0; battler < gBattlersCount; battler++) { // Player's side only if (IsOnPlayerSide(battler)) @@ -776,14 +776,14 @@ void RecordedBattle_CheckMovesetChanges(u8 mode) SetMonData(mon, MON_DATA_PP_BONUSES, &ppBonusSet); } - gChosenMoveByBattler[battler] = GetChosenMoveFromPosition(battler); + gChosenMoveByBattler[battler] = GetBattlerChosenMove(battler); } } } } } -u64 GetAiScriptsInRecordedBattle(u32 battler) +u64 GetAiScriptsInRecordedBattle(enum BattlerId battler) { return sAI_Scripts[battler]; } diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c index f4aeea8e8f..72317d6795 100644 --- a/src/reshow_battle_screen.c +++ b/src/reshow_battle_screen.c @@ -19,8 +19,8 @@ // this file's functions static void CB2_ReshowBattleScreenAfterMenu(void); static void CB2_ReshowBlankBattleScreenAfterMenu(void); -static bool8 LoadBattlerSpriteGfx(u32 battler); -static void CreateHealthboxSprite(u32 battler); +static bool8 LoadBattlerSpriteGfx(enum BattlerId battler); +static void CreateHealthboxSprite(enum BattlerId battler); static void ClearBattleBgCntBaseBlocks(void); static void CreateCaughtMonSprite(void); @@ -132,7 +132,7 @@ static void CB2_ReshowBattleScreenAfterMenu(void) break; case 19: { - u8 opponentBattler; + enum BattlerId opponentBattler; u16 species; LoadAndCreateEnemyShadowSprites(); @@ -264,10 +264,11 @@ static void ClearBattleBgCntBaseBlocks(void) regBgcnt2->charBaseBlock = 0; } -static bool8 LoadBattlerSpriteGfx(u32 battler) +static bool8 LoadBattlerSpriteGfx(enum BattlerId battler) { if (battler < gBattlersCount) { + enum BattlerPosition position = GetBattlerPosition(battler); if (!IsOnPlayerSide(battler)) { if (!gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) @@ -275,9 +276,9 @@ static bool8 LoadBattlerSpriteGfx(u32 battler) else BattleLoadSubstituteOrMonSpriteGfx(battler, FALSE); } - else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == B_POSITION_PLAYER_LEFT) // Should be checking position, not battler. + else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && position == B_POSITION_PLAYER_LEFT) DecompressTrainerBackPic(gSaveBlock2Ptr->playerGender, battler); - else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == B_POSITION_PLAYER_LEFT) // Should be checking position, not battler. + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && position == B_POSITION_PLAYER_LEFT) DecompressTrainerBackPic(TRAINER_PIC_BACK_WALLY, battler); else if (!gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) BattleLoadMonSpriteGfx(GetBattlerMon(battler), battler); @@ -289,11 +290,12 @@ static bool8 LoadBattlerSpriteGfx(u32 battler) return TRUE; } -void CreateBattlerSprite(u32 battler) +void CreateBattlerSprite(enum BattlerId battler) { if (battler < gBattlersCount) { u8 posY; + enum BattlerPosition position = GetBattlerPosition(battler); if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute) posY = GetSubstituteSpriteDefault_Y(battler); @@ -309,7 +311,7 @@ void CreateBattlerSprite(u32 battler) return; u32 species = GetMonData(mon, MON_DATA_SPECIES); - SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler)); + SetMultiuseSpriteTemplateToPokemon(species, position); gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate, GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2), posY, GetBattlerSpriteSubpriority(battler)); gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler; gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy; @@ -318,9 +320,9 @@ void CreateBattlerSprite(u32 battler) StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 0); } - else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == B_POSITION_PLAYER_LEFT) + else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && position == B_POSITION_PLAYER_LEFT) { - SetMultiuseSpriteTemplateToTrainerBack(gSaveBlock2Ptr->playerGender, GetBattlerPosition(B_POSITION_PLAYER_LEFT)); + SetMultiuseSpriteTemplateToTrainerBack(gSaveBlock2Ptr->playerGender, position); gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate, 0x50, (8 - gTrainerBacksprites[gSaveBlock2Ptr->playerGender].coordinates.size) * 4 + 80, GetBattlerSpriteSubpriority(0)); @@ -328,9 +330,9 @@ void CreateBattlerSprite(u32 battler) gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy; gSprites[gBattlerSpriteIds[battler]].data[0] = battler; } - else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == B_POSITION_PLAYER_LEFT) + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && position == B_POSITION_PLAYER_LEFT) { - SetMultiuseSpriteTemplateToTrainerBack(TRAINER_PIC_BACK_WALLY, GetBattlerPosition(B_POSITION_PLAYER_LEFT)); + SetMultiuseSpriteTemplateToTrainerBack(TRAINER_PIC_BACK_WALLY, position); gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate, 0x50, (8 - gTrainerBacksprites[TRAINER_PIC_BACK_WALLY].coordinates.size) * 4 + 80, GetBattlerSpriteSubpriority(0)); @@ -345,7 +347,7 @@ void CreateBattlerSprite(u32 battler) return; u32 species = GetMonData(mon, MON_DATA_SPECIES); - SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler)); + SetMultiuseSpriteTemplateToPokemon(species, position); gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate, GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2), posY, GetBattlerSpriteSubpriority(battler)); gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler; gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy; @@ -359,15 +361,16 @@ void CreateBattlerSprite(u32 battler) } } -static void CreateHealthboxSprite(u32 battler) +static void CreateHealthboxSprite(enum BattlerId battler) { if (battler < gBattlersCount) { u8 healthboxSpriteId; - if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && battler == B_POSITION_PLAYER_LEFT) + enum BattlerPosition position = GetBattlerPosition(battler); + if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && position == B_POSITION_PLAYER_LEFT) healthboxSpriteId = CreateSafariPlayerHealthboxSprites(); - else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && battler == B_POSITION_PLAYER_LEFT) + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && position == B_POSITION_PLAYER_LEFT) return; else healthboxSpriteId = CreateBattlerHealthboxSprites(battler); diff --git a/src/trainer_slide.c b/src/trainer_slide.c index ff26974562..9a7eb1ca0d 100644 --- a/src/trainer_slide.c +++ b/src/trainer_slide.c @@ -40,20 +40,20 @@ #include "trainer_slide.h" #include "battle_message.h" -static u32 BattlerHPPercentage(u32 battler, u32 operation, u32 threshold); +static u32 BattlerHPPercentage(enum BattlerId battler, u32 operation, u32 threshold); static u32 GetPartyMonCount(u32 firstId, u32 lastId, enum BattleSide side, bool32 onlyAlive); static bool32 DoesTrainerHaveSlideMessage(enum DifficultyLevel difficulty, u32 trainerId, u32 slideId); -static bool32 ShouldRunTrainerSlidePlayerLandsFirstCriticalHit(u32 battler, enum TrainerSlideType slideId); -static bool32 ShouldRunTrainerSlideEnemyLandsFirstCriticalHit(u32 battler, enum TrainerSlideType slideId); -static bool32 ShouldRunTrainerSlidePlayerLandsFirstSuperEffectiveHit(u32 battler, enum TrainerSlideType slideId); -static bool32 ShouldRunTrainerSlidePlayerLandsFirstSTABMove(u32 firstId, u32 lastId, enum BattleSide side, u32 battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlidePlayerLandsFirstCriticalHit(enum BattlerId battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlideEnemyLandsFirstCriticalHit(enum BattlerId battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlidePlayerLandsFirstSuperEffectiveHit(enum BattlerId battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlidePlayerLandsFirstSTABMove(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler, enum TrainerSlideType slideId); static bool32 ShouldRunTrainerSlidePlayerLandsFirstDown(u32 firstId, u32 lastId, enum BattleSide side); -static bool32 ShouldRunTrainerSlideEnemyMonUnaffected(u32 firstId, u32 lastId, enum BattleSide side, u32 battler, enum TrainerSlideType slideId); -static bool32 ShouldRunTrainerSlideLastSwitchIn(u32 battler); -static bool32 ShouldRunTrainerSlideLastHalfHP(u32 firstId, u32 lastId, enum BattleSide side, u32 battler); -static bool32 ShouldRunTrainerSlideLastLowHp(u32 firstId, u32 lastId, enum BattleSide side, u32 battler); -static void SetTrainerSlideParameters(u32 battler, u32* firstId, u32* lastId, u32* trainerId, u32* retValue); -static bool32 IsSlideInitalizedOrPlayed(u32 battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlideEnemyMonUnaffected(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler, enum TrainerSlideType slideId); +static bool32 ShouldRunTrainerSlideLastSwitchIn(enum BattlerId battler); +static bool32 ShouldRunTrainerSlideLastHalfHP(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler); +static bool32 ShouldRunTrainerSlideLastLowHp(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler); +static void SetTrainerSlideParameters(enum BattlerId battler, u32* firstId, u32* lastId, u32* trainerId, u32* retValue); +static bool32 IsSlideInitalizedOrPlayed(enum BattlerId battler, enum TrainerSlideType slideId); // Partner trainers must be added as TRAINER_PARTNER(PARTNER_XXXX) static const u8* const sTrainerSlides[DIFFICULTY_COUNT][TRAINER_PARTNER(PARTNER_COUNT)][TRAINER_SLIDE_COUNT] = @@ -75,7 +75,7 @@ static const u8* const sTestTrainerSlides[DIFFICULTY_COUNT][TRAINER_PARTNER(PART #include "../test/battle/trainer_slides.h" }; -static u32 BattlerHPPercentage(u32 battler, u32 operation, u32 threshold) +static u32 BattlerHPPercentage(enum BattlerId battler, u32 operation, u32 threshold) { switch (operation) { @@ -133,7 +133,7 @@ static u32 GetPartyMonCount(u32 firstId, u32 lastId, enum BattleSide side, bool3 } static const u8* const *GetTrainerSlideArray(enum DifficultyLevel difficulty, u32 trainerId, u32 slideId) -{ +{ #if TESTING return (FlagGet(TESTING_FLAG_TRAINER_SLIDES) ? sTestTrainerSlides[difficulty][trainerId] : NULL); #else @@ -180,17 +180,17 @@ void SetTrainerSlideMessage(enum DifficultyLevel difficulty, u32 trainerId, u32 gBattleStruct->trainerSlideMsg = trainerSlidesNormal[slideId]; } -static bool32 ShouldRunTrainerSlidePlayerLandsFirstCriticalHit(u32 battler, enum TrainerSlideType slideId) +static bool32 ShouldRunTrainerSlidePlayerLandsFirstCriticalHit(enum BattlerId battler, enum TrainerSlideType slideId) { return IsTrainerSlideInitialized(battler, slideId); } -static bool32 ShouldRunTrainerSlideEnemyLandsFirstCriticalHit(u32 battler, enum TrainerSlideType slideId) +static bool32 ShouldRunTrainerSlideEnemyLandsFirstCriticalHit(enum BattlerId battler, enum TrainerSlideType slideId) { return IsTrainerSlideInitialized(battler, slideId); } -static bool32 ShouldRunTrainerSlidePlayerLandsFirstSuperEffectiveHit(u32 battler, enum TrainerSlideType slideId) +static bool32 ShouldRunTrainerSlidePlayerLandsFirstSuperEffectiveHit(enum BattlerId battler, enum TrainerSlideType slideId) { if (!IsTrainerSlideInitialized(battler, slideId)) return FALSE; @@ -201,7 +201,7 @@ static bool32 ShouldRunTrainerSlidePlayerLandsFirstSuperEffectiveHit(u32 battler return TRUE; } -static bool32 ShouldRunTrainerSlidePlayerLandsFirstSTABMove(u32 firstId, u32 lastId, enum BattleSide side, u32 battler, enum TrainerSlideType slideId) +static bool32 ShouldRunTrainerSlidePlayerLandsFirstSTABMove(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler, enum TrainerSlideType slideId) { if (!IsTrainerSlideInitialized(battler, slideId)) return FALSE; @@ -217,7 +217,7 @@ static bool32 ShouldRunTrainerSlidePlayerLandsFirstDown(u32 firstId, u32 lastId, return ((GetPartyMonCount(firstId, lastId, side, TRUE) == (GetPartyMonCount(firstId, lastId, side, FALSE) - 1))); } -static bool32 ShouldRunTrainerSlideEnemyMonUnaffected(u32 firstId, u32 lastId, enum BattleSide side, u32 battler, enum TrainerSlideType slideId) +static bool32 ShouldRunTrainerSlideEnemyMonUnaffected(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler, enum TrainerSlideType slideId) { if (!IsTrainerSlideInitialized(battler, slideId)) return FALSE; @@ -225,12 +225,12 @@ static bool32 ShouldRunTrainerSlideEnemyMonUnaffected(u32 firstId, u32 lastId, e return (GetPartyMonCount(firstId, lastId, side, TRUE) == GetPartyMonCount(firstId, lastId, side, FALSE)); } -static bool32 ShouldRunTrainerSlideLastSwitchIn(u32 battler) +static bool32 ShouldRunTrainerSlideLastSwitchIn(enum BattlerId battler) { return !CanBattlerSwitch(battler); } -static bool32 ShouldRunTrainerSlideLastHalfHP(u32 firstId, u32 lastId, enum BattleSide side, u32 battler) +static bool32 ShouldRunTrainerSlideLastHalfHP(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler) { if (GetPartyMonCount(firstId, lastId, side, TRUE) != 1) return FALSE; @@ -241,7 +241,7 @@ static bool32 ShouldRunTrainerSlideLastHalfHP(u32 firstId, u32 lastId, enum Batt return (BattlerHPPercentage(battler, GREATER_THAN, 4)); } -static bool32 ShouldRunTrainerSlideLastLowHp(u32 firstId, u32 lastId, enum BattleSide side, u32 battler) +static bool32 ShouldRunTrainerSlideLastLowHp(u32 firstId, u32 lastId, enum BattleSide side, enum BattlerId battler) { if (GetPartyMonCount(firstId, lastId, side, TRUE) != 1) return FALSE; @@ -252,7 +252,7 @@ static bool32 ShouldRunTrainerSlideLastLowHp(u32 firstId, u32 lastId, enum Battl return (BattlerHPPercentage(battler, LESS_THAN_OR_EQUAL, 4)); } -static void SetTrainerSlideParameters(u32 battler, u32* firstId, u32* lastId, u32* trainerId, u32* retValue) +static void SetTrainerSlideParameters(enum BattlerId battler, u32* firstId, u32* lastId, u32* trainerId, u32* retValue) { if ((battler & BIT_SIDE) == B_SIDE_OPPONENT) { @@ -288,7 +288,7 @@ static void SetTrainerSlideParameters(u32 battler, u32* firstId, u32* lastId, u3 } } -enum TrainerSlideTargets ShouldDoTrainerSlide(u32 battler, enum TrainerSlideType slideId) +enum TrainerSlideTargets ShouldDoTrainerSlide(enum BattlerId battler, enum TrainerSlideType slideId) { u32 firstId = 0, lastId = PARTY_SIZE, trainerId = 0; enum BattleSide side = GetBattlerSide(battler); @@ -361,13 +361,13 @@ enum TrainerSlideTargets ShouldDoTrainerSlide(u32 battler, enum TrainerSlideType { MarkTrainerSlideAsPlayed(BATTLE_PARTNER(battler), slideId); } - + MarkTrainerSlideAsPlayed(battler, slideId); SetTrainerSlideMessage(difficulty,trainerId,slideId); return retValue; } -static bool32 IsSlideInitalizedOrPlayed(u32 battler, enum TrainerSlideType slideId) +static bool32 IsSlideInitalizedOrPlayed(enum BattlerId battler, enum TrainerSlideType slideId) { if (IsTrainerSlideInitialized(battler, slideId)) return TRUE; @@ -378,7 +378,7 @@ static bool32 IsSlideInitalizedOrPlayed(u32 battler, enum TrainerSlideType slide return FALSE; } -void TryInitializeFirstSTABMoveTrainerSlide(u32 battlerDef, u32 battlerAtk, enum Type moveType) +void TryInitializeFirstSTABMoveTrainerSlide(enum BattlerId battlerDef, enum BattlerId battlerAtk, enum Type moveType) { enum TrainerSlideType slideId = TRAINER_SLIDE_PLAYER_LANDS_FIRST_STAB_MOVE; @@ -446,7 +446,7 @@ void TryInitializeTrainerSlideEnemyMonUnaffected(u32 target) InitalizeTrainerSlide(target, slideId); } -bool32 IsTrainerSlideInitialized(u32 battler, enum TrainerSlideType slideId) +bool32 IsTrainerSlideInitialized(enum BattlerId battler, enum TrainerSlideType slideId) { u32 arrayIndex = slideId / TRAINER_SLIDES_PER_ARRAY; u32 bitPosition = slideId % TRAINER_SLIDES_PER_ARRAY; @@ -454,7 +454,7 @@ bool32 IsTrainerSlideInitialized(u32 battler, enum TrainerSlideType slideId) return (gBattleStruct->slideMessageStatus.messageInitalized[battler][arrayIndex] & (1 << bitPosition)) != 0; } -bool32 IsTrainerSlidePlayed(u32 battler, enum TrainerSlideType slideId) +bool32 IsTrainerSlidePlayed(enum BattlerId battler, enum TrainerSlideType slideId) { u32 arrayIndex = slideId / TRAINER_SLIDES_PER_ARRAY; u32 bitPosition = slideId % TRAINER_SLIDES_PER_ARRAY; @@ -462,7 +462,7 @@ bool32 IsTrainerSlidePlayed(u32 battler, enum TrainerSlideType slideId) return (gBattleStruct->slideMessageStatus.messagePlayed[battler][arrayIndex] & (1 << bitPosition)) != 0; } -void InitalizeTrainerSlide(u32 battler, enum TrainerSlideType slideId) +void InitalizeTrainerSlide(enum BattlerId battler, enum TrainerSlideType slideId) { u32 arrayIndex = slideId / TRAINER_SLIDES_PER_ARRAY; u32 bitPosition = slideId % TRAINER_SLIDES_PER_ARRAY; @@ -470,7 +470,7 @@ void InitalizeTrainerSlide(u32 battler, enum TrainerSlideType slideId) gBattleStruct->slideMessageStatus.messageInitalized[battler][arrayIndex] |= (1 << bitPosition); } -void MarkInitializedTrainerSlidesAsPlayed(u32 battler, enum TrainerSlideType slideId) +void MarkInitializedTrainerSlidesAsPlayed(enum BattlerId battler, enum TrainerSlideType slideId) { u32 arrayIndex = slideId / TRAINER_SLIDES_PER_ARRAY; u32 bitPosition = slideId % TRAINER_SLIDES_PER_ARRAY; @@ -479,7 +479,7 @@ void MarkInitializedTrainerSlidesAsPlayed(u32 battler, enum TrainerSlideType sli gBattleStruct->slideMessageStatus.messagePlayed[battler][arrayIndex] |= (1 << bitPosition); } -void MarkTrainerSlideAsPlayed(u32 battler, enum TrainerSlideType slideId) +void MarkTrainerSlideAsPlayed(enum BattlerId battler, enum TrainerSlideType slideId) { u32 arrayIndex = slideId / TRAINER_SLIDES_PER_ARRAY; u32 bitPosition = slideId % TRAINER_SLIDES_PER_ARRAY; diff --git a/src/type_icons.c b/src/type_icons.c index 5874cc172a..3df968fd74 100644 --- a/src/type_icons.c +++ b/src/type_icons.c @@ -10,27 +10,27 @@ #include "type_icons.h" static void LoadTypeSpritesAndPalettes(void); -static void LoadTypeIconsPerBattler(u32, u32); +static void LoadTypeIconsPerBattler(enum BattlerId, u32); static bool32 UseDoubleBattleCoords(u32); -static enum Type GetMonPublicType(u32, u32); +static enum Type GetMonPublicType(enum BattlerId, u32); static bool32 ShouldHideUncaughtType(u32 species); static bool32 ShouldHideUnseenType(u32 species); -static enum Type GetMonDefensiveTeraType(struct Pokemon *, struct Pokemon*, u32, u32, u32, u32); -static bool32 IsIllusionActiveAndTypeUnchanged(struct Pokemon*, u32, u32); +static enum Type GetMonDefensiveTeraType(struct Pokemon *, struct Pokemon *, enum BattlerId, u32, u32, u32); +static bool32 IsIllusionActiveAndTypeUnchanged(struct Pokemon *, u32, enum BattlerId); -static void CreateSpriteFromType(u32, bool32, enum Type[], u32, u32); +static void CreateSpriteFromType(u32, bool32, enum Type[], u32, enum BattlerId); static bool32 ShouldSkipSecondType(enum Type[], u32); static void SetTypeIconXY(s32*, s32*, u32, bool32, u32); -static void CreateSpriteAndSetTypeSpriteAttributes(enum Type, u32 x, u32 y, u32, u32, bool32); +static void CreateSpriteAndSetTypeSpriteAttributes(enum Type, u32 x, u32 y, u32, enum BattlerId, bool32); static bool32 ShouldFlipTypeIcon(bool32, u32, enum Type); static void SpriteCB_TypeIcon(struct Sprite*); static void DestroyTypeIcon(struct Sprite*); static void FreeAllTypeIconResources(void); -static bool32 ShouldHideTypeIcon(u32); +static bool32 ShouldHideTypeIcon(enum BattlerId); static s32 GetTypeIconHideMovement(bool32, u32); static s32 GetTypeIconSlideMovement(bool32, u32, s32); static s32 GetTypeIconBounceMovement(s32, u32); @@ -232,7 +232,7 @@ const struct SpriteTemplate sSpriteTemplate_TypeIcons2 = .callback = SpriteCB_TypeIcon }; -void LoadTypeIcons(u32 battler) +void LoadTypeIcons(enum BattlerId battler) { u32 position; @@ -260,11 +260,11 @@ static void LoadTypeSpritesAndPalettes(void) LoadSpritePalette(&sTypeIconPal2); } -static void LoadTypeIconsPerBattler(u32 battler, u32 position) +static void LoadTypeIconsPerBattler(enum BattlerId battler, u32 position) { u32 typeNum; enum Type types[2]; - u32 battlerId = GetBattlerAtPosition(position); + enum BattlerId battlerId = GetBattlerAtPosition(position); bool32 useDoubleBattleCoords = UseDoubleBattleCoords(battlerId); if (!IsBattlerAlive(battlerId)) @@ -291,7 +291,7 @@ static bool32 UseDoubleBattleCoords(u32 position) return TRUE; } -static enum Type GetMonPublicType(u32 battlerId, u32 typeNum) +static enum Type GetMonPublicType(enum BattlerId battlerId, u32 typeNum) { struct Pokemon *mon = GetBattlerMon(battlerId); u32 monSpecies = GetMonData(mon,MON_DATA_SPECIES,NULL); @@ -335,7 +335,7 @@ static bool32 ShouldHideUnseenType(u32 species) return TRUE; } -static enum Type GetMonDefensiveTeraType(struct Pokemon *mon, struct Pokemon *monIllusion, u32 battlerId, u32 typeNum, u32 illusionSpecies, u32 monSpecies) +static enum Type GetMonDefensiveTeraType(struct Pokemon *mon, struct Pokemon *monIllusion, enum BattlerId battlerId, u32 typeNum, u32 illusionSpecies, u32 monSpecies) { enum Type teraType = GetBattlerTeraType(battlerId); u32 targetSpecies; @@ -348,7 +348,7 @@ static enum Type GetMonDefensiveTeraType(struct Pokemon *mon, struct Pokemon *mo return GetSpeciesType(targetSpecies, typeNum); } -static bool32 IsIllusionActiveAndTypeUnchanged(struct Pokemon *monIllusion, u32 monSpecies, u32 battlerId) +static bool32 IsIllusionActiveAndTypeUnchanged(struct Pokemon *monIllusion, u32 monSpecies, enum BattlerId battlerId) { u32 typeNum; @@ -362,7 +362,7 @@ static bool32 IsIllusionActiveAndTypeUnchanged(struct Pokemon *monIllusion, u32 return TRUE; } -static void CreateSpriteFromType(u32 position, bool32 useDoubleBattleCoords, enum Type types[], u32 typeNum, u32 battler) +static void CreateSpriteFromType(u32 position, bool32 useDoubleBattleCoords, enum Type types[], u32 typeNum, enum BattlerId battler) { s32 x = 0, y = 0; @@ -391,7 +391,7 @@ static void SetTypeIconXY(s32* x, s32* y, u32 position, bool32 useDoubleBattleCo *y = sTypeIconPositions[position][useDoubleBattleCoords].y + (11 * typeNum); } -static void CreateSpriteAndSetTypeSpriteAttributes(enum Type type, u32 x, u32 y, u32 position, u32 battler, bool32 useDoubleBattleCoords) +static void CreateSpriteAndSetTypeSpriteAttributes(enum Type type, u32 x, u32 y, u32 position, enum BattlerId battler, bool32 useDoubleBattleCoords) { struct Sprite* sprite; const struct SpriteTemplate* spriteTemplate = gTypesInfo[type].useSecondTypeIconPalette ? &sSpriteTemplate_TypeIcons2 : &sSpriteTemplate_TypeIcons1; @@ -423,7 +423,7 @@ static bool32 ShouldFlipTypeIcon(bool32 useDoubleBattleCoords, u32 position, enu static void SpriteCB_TypeIcon(struct Sprite *sprite) { u32 position = sprite->tMonPosition; - u32 battlerId = sprite->tBattlerId; + enum BattlerId battlerId = sprite->tBattlerId; bool32 useDoubleBattleCoords = UseDoubleBattleCoords(GetBattlerAtPosition(position)); if (sprite->tHideIconTimer == NUM_FRAMES_HIDE_TYPE_ICON) @@ -484,7 +484,7 @@ static void FreeAllTypeIconResources(void) } } -static void (*const sShowTypesControllerFuncs[])(u32 battler) = +static void (*const sShowTypesControllerFuncs[])(enum BattlerId battler) = { PlayerHandleChooseMove, HandleChooseMoveAfterDma3, @@ -496,7 +496,7 @@ static void (*const sShowTypesControllerFuncs[])(u32 battler) = }; -static bool32 ShouldHideTypeIcon(u32 battlerId) +static bool32 ShouldHideTypeIcon(enum BattlerId battlerId) { u32 funcIndex; diff --git a/test/battle/ability/arena_trap.c b/test/battle/ability/arena_trap.c index 67384fa68e..79ed93c8ec 100644 --- a/test/battle/ability/arena_trap.c +++ b/test/battle/ability/arena_trap.c @@ -9,8 +9,8 @@ SINGLE_BATTLE_TEST("Arena Trap prevents grounded adjacent opponents from switchi } WHEN { TURN { MOVE(player, MOVE_CELEBRATE); } } THEN { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u32 trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); EXPECT_EQ(IsAbilityPreventingEscape(battler), trapper + 1); } } @@ -86,8 +86,8 @@ WILD_BATTLE_TEST("Arena Trap prevents switching but Run Away allows fleeing") } WHEN { TURN { MOVE(player, MOVE_CELEBRATE); } } THEN { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u32 trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); EXPECT_EQ(IsAbilityPreventingEscape(battler), trapper + 1); EXPECT_EQ(IsRunningFromBattleImpossible(battler), BATTLE_RUN_SUCCESS); } @@ -102,8 +102,8 @@ WILD_BATTLE_TEST("Arena Trap prevents switching but Smoke Ball allows fleeing") } WHEN { TURN { MOVE(player, MOVE_CELEBRATE); } } THEN { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u32 trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); EXPECT_EQ(IsAbilityPreventingEscape(battler), trapper + 1); EXPECT_EQ(IsRunningFromBattleImpossible(battler), BATTLE_RUN_SUCCESS); } @@ -119,8 +119,8 @@ SINGLE_BATTLE_TEST("Arena Trap prevents switch outs from Ghost-type Pokémon (Ge } WHEN { TURN { MOVE(player, MOVE_CELEBRATE); } } THEN { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); - u32 trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId trapper = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); EXPECT_EQ(IsAbilityPreventingEscape(battler), trapper + 1); } } @@ -135,7 +135,7 @@ SINGLE_BATTLE_TEST("Arena Trap doesn't prevent switch outs from Ghost-type Poké } WHEN { TURN { MOVE(player, MOVE_CELEBRATE); } } THEN { - u32 battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + enum BattlerId battler = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); EXPECT_EQ(IsAbilityPreventingEscape(battler), 0); } } diff --git a/test/battle/ai/ai_doubles.c b/test/battle/ai/ai_doubles.c index b8b44eb3f0..d071365761 100644 --- a/test/battle/ai/ai_doubles.c +++ b/test/battle/ai/ai_doubles.c @@ -602,7 +602,7 @@ AI_DOUBLE_BATTLE_TEST("Battler 3 has Battler 1 AI flags set correctly (doubles)" ASSUME(IsExplosionMove(MOVE_EXPLOSION)); u32 aiFlags; - u32 battler; + enum BattlerId battler; PARAMETRIZE { aiFlags = 0; battler = 1; } PARAMETRIZE { aiFlags = 0; battler = 3; } diff --git a/test/battle/ai/ai_multi.c b/test/battle/ai/ai_multi.c index 70d28e34e3..4a6e44caa7 100644 --- a/test/battle/ai/ai_multi.c +++ b/test/battle/ai/ai_multi.c @@ -8,7 +8,7 @@ AI_MULTI_BATTLE_TEST("AI will only explode and kill everything on the field with ASSUME(IsExplosionMove(MOVE_EXPLOSION)); u32 aiFlags; - u32 battler; + enum BattlerId battler; PARAMETRIZE { aiFlags = 0; battler = 1; } PARAMETRIZE { aiFlags = 0; battler = 3; } @@ -38,7 +38,7 @@ AI_ONE_VS_TWO_BATTLE_TEST("AI will only explode and kill everything on the field ASSUME(IsExplosionMove(MOVE_EXPLOSION)); u32 aiFlags; - u32 battler; + enum BattlerId battler; PARAMETRIZE { aiFlags = 0; battler = 1; } PARAMETRIZE { aiFlags = 0; battler = 3; } @@ -102,7 +102,7 @@ AI_TWO_VS_ONE_BATTLE_TEST("Battler 3 has Battler 1 AI flags set correctly (2v1)" ASSUME(IsExplosionMove(MOVE_EXPLOSION)); u32 aiFlags; - u32 battler; + enum BattlerId battler; PARAMETRIZE { aiFlags = 0; battler = 1; } PARAMETRIZE { aiFlags = 0; battler = 3; } diff --git a/test/test_runner_battle.c b/test/test_runner_battle.c index 0d049bb93e..f20b34b176 100644 --- a/test/test_runner_battle.c +++ b/test/test_runner_battle.c @@ -55,8 +55,8 @@ STATIC_ASSERT(sizeof(struct BattleTestRunnerState) <= sizeof(sBackupMapData), sB static void CB2_BattleTest_NextParameter(void); static void CB2_BattleTest_NextTrial(void); static void PushBattlerAction(u32 sourceLine, s32 battlerId, u32 actionType, u32 byte); -static void PrintAiMoveLog(u32 battlerId, u32 moveSlot, enum Move moveId, s32 totalScore); -static void ClearAiLog(u32 battlerId); +static void PrintAiMoveLog(enum BattlerId battlerId, u32 moveSlot, enum Move moveId, s32 totalScore); +static void ClearAiLog(enum BattlerId battlerId); static const char *BattlerIdentifier(s32 battlerId); NAKED static void InvokeSingleTestFunctionWithStack(void *results, u32 i, struct BattlePokemon *player, struct BattlePokemon *opponent, SingleBattleTestFunction function, void *stack) @@ -671,7 +671,7 @@ static u32 BattleTest_RandomUniform(enum RandomTag tag, u32 lo, u32 hi, bool32 ( const struct BattlerTurn *turn = NULL; if (gCurrentTurnActionNumber < gBattlersCount) { - u32 battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; + enum BattlerId battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; turn = &DATA.battleRecordTurns[gBattleResults.battleTurnCounter][battlerId]; if (turn && turn->rng.tag == tag) { @@ -733,7 +733,7 @@ static u32 BattleTest_RandomWeightedArray(enum RandomTag tag, u32 sum, u32 n, co const struct BattlerTurn *turn = NULL; if (gCurrentTurnActionNumber < gBattlersCount || tag == RNG_SHELL_SIDE_ARM) { - u32 battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; + enum BattlerId battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; turn = &DATA.battleRecordTurns[gBattleResults.battleTurnCounter][battlerId]; if (turn && turn->rng.tag == tag) return turn->rng.value; @@ -778,7 +778,7 @@ static const void *BattleTest_RandomElementArray(enum RandomTag tag, const void const struct BattlerTurn *turn = NULL; if (gCurrentTurnActionNumber < gBattlersCount) { - u32 battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; + enum BattlerId battlerId = gBattlerByTurnOrder[gCurrentTurnActionNumber]; turn = &DATA.battleRecordTurns[gBattleResults.battleTurnCounter][battlerId]; if (turn && turn->rng.tag == tag) { @@ -802,7 +802,7 @@ static const void *BattleTest_RandomElementArray(enum RandomTag tag, const void return RandomElementArrayDefaultValue(tag, array, size, count, caller); } -static s32 TryAbilityPopUp(s32 i, s32 n, u32 battlerId, enum Ability ability) +static s32 TryAbilityPopUp(s32 i, s32 n, enum BattlerId battlerId, enum Ability ability) { struct QueuedAbilityEvent *event; s32 iMax = i + n; @@ -820,7 +820,7 @@ static s32 TryAbilityPopUp(s32 i, s32 n, u32 battlerId, enum Ability ability) return -1; } -void TestRunner_Battle_RecordAbilityPopUp(u32 battlerId, enum Ability ability) +void TestRunner_Battle_RecordAbilityPopUp(enum BattlerId battlerId, enum Ability ability) { s32 queuedEvent; s32 match; @@ -930,7 +930,7 @@ void TestRunner_Battle_RecordAnimation(u32 animType, u32 animId) } } -static s32 TryHP(s32 i, s32 n, u32 battlerId, u32 oldHP, u32 newHP) +static s32 TryHP(s32 i, s32 n, enum BattlerId battlerId, u32 oldHP, u32 newHP) { struct QueuedHPEvent *event; s32 iMax = i + n; @@ -977,7 +977,7 @@ static s32 TryHP(s32 i, s32 n, u32 battlerId, u32 oldHP, u32 newHP) return -1; } -void TestRunner_Battle_RecordHP(u32 battlerId, u32 oldHP, u32 newHP) +void TestRunner_Battle_RecordHP(enum BattlerId battlerId, u32 oldHP, u32 newHP) { s32 queuedEvent; s32 match; @@ -1022,7 +1022,7 @@ void TestRunner_Battle_RecordHP(u32 battlerId, u32 oldHP, u32 newHP) } } -static s32 TrySubHit(s32 i, s32 n, u32 battlerId, u32 damage, bool32 broke) +static s32 TrySubHit(s32 i, s32 n, enum BattlerId battlerId, u32 damage, bool32 broke) { struct QueuedSubHitEvent *event; s32 iMax = i + n; @@ -1058,7 +1058,7 @@ static s32 TrySubHit(s32 i, s32 n, u32 battlerId, u32 damage, bool32 broke) return -1; } -void TestRunner_Battle_RecordSubHit(u32 battlerId, u32 damage, bool32 broke) +void TestRunner_Battle_RecordSubHit(enum BattlerId battlerId, u32 damage, bool32 broke) { s32 queuedEvent; s32 match; @@ -1120,7 +1120,7 @@ static const char *const sGimmickIdentifiers[GIMMICKS_COUNT] = [GIMMICK_TERA] = "Terastallize", }; -static u32 CountAiExpectMoves(struct ExpectedAIAction *expectedAction, u32 battlerId, bool32 printLog) +static u32 CountAiExpectMoves(struct ExpectedAIAction *expectedAction, enum BattlerId battlerId, bool32 printLog) { u32 i, countExpected = 0; for (i = 0; i < MAX_MON_MOVES; i++) @@ -1135,7 +1135,7 @@ static u32 CountAiExpectMoves(struct ExpectedAIAction *expectedAction, u32 battl return countExpected; } -void TestRunner_Battle_CheckChosenMove(u32 battlerId, enum Move moveId, u32 target, enum Gimmick gimmick) +void TestRunner_Battle_CheckChosenMove(enum BattlerId battlerId, enum Move moveId, u32 target, enum Gimmick gimmick) { const char *filename = gTestRunnerState.test->filename; u32 id = DATA.trial.aiActionsPlayed[battlerId]; @@ -1212,7 +1212,7 @@ void TestRunner_Battle_CheckChosenMove(u32 battlerId, enum Move moveId, u32 targ DATA.trial.aiActionsPlayed[battlerId]++; } -void TestRunner_Battle_CheckSwitch(u32 battlerId, u32 partyIndex) +void TestRunner_Battle_CheckSwitch(enum BattlerId battlerId, u32 partyIndex) { const char *filename = gTestRunnerState.test->filename; u32 id = DATA.trial.aiActionsPlayed[battlerId]; @@ -1258,7 +1258,7 @@ static const char *const sCmpToStringTable[] = [CMP_GREATER_THAN] = "GT", }; -static void CheckIfMaxScoreEqualExpectMove(u32 battlerId, s32 target, struct ExpectedAIAction *aiAction, const char *filename) +static void CheckIfMaxScoreEqualExpectMove(enum BattlerId battlerId, s32 target, struct ExpectedAIAction *aiAction, const char *filename) { u32 i; s32 *scores = gAiBattleData->finalScore[battlerId][target]; @@ -1297,7 +1297,7 @@ static void CheckIfMaxScoreEqualExpectMove(u32 battlerId, s32 target, struct Exp } } -static void PrintAiMoveLog(u32 battlerId, u32 moveSlot, enum Move moveId, s32 totalScore) +static void PrintAiMoveLog(enum BattlerId battlerId, u32 moveSlot, enum Move moveId, s32 totalScore) { s32 i, scoreFromLogs = 0; @@ -1339,7 +1339,7 @@ static void PrintAiMoveLog(u32 battlerId, u32 moveSlot, enum Move moveId, s32 to Test_MgbaPrintf("Total: %d\n", totalScore); } -static void ClearAiLog(u32 battlerId) +static void ClearAiLog(enum BattlerId battlerId) { u32 i, j; for (i = 0; i < MAX_MON_MOVES; i++) @@ -1351,7 +1351,7 @@ static void ClearAiLog(u32 battlerId) DATA.aiLogPrintedForMove[battlerId] = 0; } -void TestRunner_Battle_CheckAiMoveScores(u32 battlerId) +void TestRunner_Battle_CheckAiMoveScores(enum BattlerId battlerId) { s32 i; struct ExpectedAIAction *aiAction; @@ -1411,7 +1411,7 @@ void TestRunner_Battle_CheckAiMoveScores(u32 battlerId) } } -static s32 TryExp(s32 i, s32 n, u32 battlerId, u32 oldExp, u32 newExp) +static s32 TryExp(s32 i, s32 n, enum BattlerId battlerId, u32 oldExp, u32 newExp) { struct QueuedExpEvent *event; s32 iMax = i + n; @@ -1458,7 +1458,7 @@ static s32 TryExp(s32 i, s32 n, u32 battlerId, u32 oldExp, u32 newExp) return -1; } -void TestRunner_Battle_RecordExp(u32 battlerId, u32 oldExp, u32 newExp) +void TestRunner_Battle_RecordExp(enum BattlerId battlerId, u32 oldExp, u32 newExp) { s32 queuedEvent; s32 match; @@ -1595,7 +1595,7 @@ void TestRunner_Battle_RecordMessage(const u8 *string) } } -static s32 TryStatus(s32 i, s32 n, u32 battlerId, u32 status1) +static s32 TryStatus(s32 i, s32 n, enum BattlerId battlerId, u32 status1) { struct QueuedStatusEvent *event; s32 iMax = i + n; @@ -1617,7 +1617,7 @@ static s32 TryStatus(s32 i, s32 n, u32 battlerId, u32 status1) return -1; } -void TestRunner_Battle_RecordStatus1(u32 battlerId, u32 status1) +void TestRunner_Battle_RecordStatus1(enum BattlerId battlerId, u32 status1) { s32 queuedEvent; s32 match; @@ -1939,7 +1939,7 @@ void AIFlags_(u32 sourceLine, u64 flags) DATA.hasAI = TRUE; } -void BattlerAIFlags_(u32 sourceLine, u32 battler, u64 flags) +void BattlerAIFlags_(u32 sourceLine, enum BattlerId battler, u64 flags) { INVALID_IF(!IsAITest(), "AI_FLAGS is usable only in AI_SINGLE_BATTLE_TEST, AI_DOUBLE_BATTLE_TEST, AI_MULTI_BATTLE_TEST, and AI_TWO_VS_ONE_TEST"); DATA.recordedBattle.AI_scripts[battler] |= flags; @@ -2155,7 +2155,7 @@ void ClosePokemon(u32 sourceLine) DATA.currentMon = NULL; } -static void SetGimmick(u32 sourceLine, u32 battler, u32 partyIndex, enum Gimmick gimmick) +static void SetGimmick(u32 sourceLine, enum BattlerId battler, u32 partyIndex, enum Gimmick gimmick) { enum Gimmick currentGimmick = DATA.chosenGimmick[GetBattlerTrainer(battler)][partyIndex]; if (!((currentGimmick == GIMMICK_ULTRA_BURST && gimmick == GIMMICK_Z_MOVE) @@ -2493,7 +2493,7 @@ static void PushBattlerAction(u32 sourceLine, s32 battlerId, u32 actionType, u32 DATA.recordedBattle.battleRecord[battlerId][recordIndex] = byte; } -void TestRunner_Battle_CheckBattleRecordActionType(u32 battlerId, u32 recordIndex, u32 actionType) +void TestRunner_Battle_CheckBattleRecordActionType(enum BattlerId battlerId, u32 recordIndex, u32 actionType) { // An illegal move choice will cause the battle to request a new // move slot and target. This detects the move slot. @@ -2937,7 +2937,7 @@ void ExpectSendOut(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex gTestRunnerState.expectedFailState = EXPECT_FAIL_TURN_OPEN; } -s32 GetAiMoveTargetForScoreCompare(u32 battlerId, enum Move moveId, struct MoveContext *ctx, u32 sourceLine) +s32 GetAiMoveTargetForScoreCompare(enum BattlerId battlerId, enum Move moveId, struct MoveContext *ctx, u32 sourceLine) { s32 target; @@ -3175,7 +3175,7 @@ void CloseQueueGroup(u32 sourceLine) void QueueAbility(u32 sourceLine, struct BattlePokemon *battler, struct AbilityEventContext ctx) { - s32 battlerId = battler - gBattleMons; + enum BattlerId battlerId = battler - gBattleMons; if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN) gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN; @@ -3476,7 +3476,7 @@ u32 TestRunner_Battle_GetChosenGimmick(enum BattleTrainer trainer, u32 partyInde // TODO: Consider storing the last successful i and searching from i+1 // to improve performance. -struct AILogLine *GetLogLine(u32 battlerId, u32 moveIndex) +struct AILogLine *GetLogLine(enum BattlerId battlerId, u32 moveIndex) { s32 i; @@ -3493,7 +3493,7 @@ struct AILogLine *GetLogLine(u32 battlerId, u32 moveIndex) return NULL; } -void TestRunner_Battle_AILogScore(const char *file, u32 line, u32 battlerId, u32 moveIndex, s32 score, bool32 setScore) +void TestRunner_Battle_AILogScore(const char *file, u32 line, enum BattlerId battlerId, u32 moveIndex, s32 score, bool32 setScore) { struct AILogLine *log; @@ -3506,12 +3506,12 @@ void TestRunner_Battle_AILogScore(const char *file, u32 line, u32 battlerId, u32 log->set = setScore; } -void TestRunner_Battle_AISetScore(const char *file, u32 line, u32 battlerId, u32 moveIndex, s32 score) +void TestRunner_Battle_AISetScore(const char *file, u32 line, enum BattlerId battlerId, u32 moveIndex, s32 score) { TestRunner_Battle_AILogScore(file, line, battlerId, moveIndex, score, TRUE); } -void TestRunner_Battle_AIAdjustScore(const char *file, u32 line, u32 battlerId, u32 moveIndex, s32 score) +void TestRunner_Battle_AIAdjustScore(const char *file, u32 line, enum BattlerId battlerId, u32 moveIndex, s32 score) { TestRunner_Battle_AILogScore(file, line, battlerId, moveIndex, score, FALSE); }