Added enum BattlerId type checks (#8954)

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;

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

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

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;
 

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

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

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;

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);
 

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);
 

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);

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);

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[];
 

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);

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);

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);

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);
 

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);

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);

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

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

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

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

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,

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]
 //

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);

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);

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);

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);

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

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);

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);

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

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

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;
 

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))
         {

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);

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;

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;
 

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;

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

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;

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 = &REG_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;
 }

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])
     {

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)
     {

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;

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;

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);

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;
             }
         }

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;

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;

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];

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];

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))

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;

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];

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;

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;
 

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)
     {

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];

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;
 

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]);
 

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];

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))
     {

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}");

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);

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];

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);

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);

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);

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);

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);

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);

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,

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;

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;

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;

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);

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;
 

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;

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;
 }
-

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;
 

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)
     {

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));

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);

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;
 

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);

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;
     }
 }

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)

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;

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);

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)

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)

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];
 }

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);

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;

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;