Merge branch 'upcoming' into berryexpansion

data/battle_scripts_1.s

@@ -8853,6 +8853,16 @@ BattleScript_ZeroToHeroActivates::
  waitmessage B_WAIT_TIME_LONG
  end3
 
+BattleScript_HospitalityActivates::
+ pause B_WAIT_TIME_SHORT
+ call BattleScript_AbilityPopUp
+ printstring STRINGID_HOSPITALITYRESTORATION
+ waitmessage B_WAIT_TIME_LONG
+ orword gHitMarker, HITMARKER_IGNORE_SUBSTITUTE
+ healthbarupdate BS_TARGET
+ datahpupdate BS_TARGET
+ end3
+
 BattleScript_AttackWeakenedByStrongWinds::
  pause B_WAIT_TIME_SHORT
  printstring STRINGID_ATTACKWEAKENEDBSTRONGWINDS
@@ -9249,6 +9259,7 @@ BattleScript_BattlerAbilityStatRaiseOnSwitchIn::
  waitanimation
  printstring STRINGID_BATTLERABILITYRAISEDSTAT
  waitmessage B_WAIT_TIME_LONG
+ copybyte gBattlerAttacker, sSAVED_BATTLER
  end3
 
 BattleScript_ScriptingAbilityStatRaise::

include/battle.h

@@ -336,7 +336,7 @@ struct AI_ThinkingStruct
  u16 moveConsidered;
  s32 score[MAX_MON_MOVES];
  u32 funcResult;
- u32 aiFlags;
+ u32 aiFlags[MAX_BATTLERS_COUNT];
  u8 aiAction;
  u8 aiLogicId;
  struct AI_SavedBattleMon saved[MAX_BATTLERS_COUNT];

include/battle_scripts.h

@@ -461,6 +461,7 @@ extern const u8 BattleScript_CudChewActivates[];
 extern const u8 BattleScript_SupremeOverlordActivates[];
 extern const u8 BattleScript_CostarActivates[];
 extern const u8 BattleScript_ZeroToHeroActivates[];
+extern const u8 BattleScript_HospitalityActivates[];
 extern const u8 BattleScript_ToxicDebrisActivates[];
 extern const u8 BattleScript_EarthEaterActivates[];
 extern const u8 BattleScript_MimicryActivates_End3[];

include/constants/battle_string_ids.h

@@ -696,8 +696,9 @@
 #define STRINGID_SWAMPENVELOPEDSIDE 694
 #define STRINGID_THESWAMPDISAPPEARED 695
 #define STRINGID_PKMNTELLCHILLINGRECEPTIONJOKE 696
+#define STRINGID_HOSPITALITYRESTORATION 697
 
-#define BATTLESTRINGS_COUNT 697
+#define BATTLESTRINGS_COUNT 698
 
 // This is the string id that gBattleStringsTable starts with.
 // String ids before this (e.g. STRINGID_INTROMSG) are not in the table,

src/battle_ai_main.c

@@ -22,6 +22,7 @@
 #include "constants/hold_effects.h"
 #include "constants/moves.h"
 #include "constants/items.h"
+#include "constants/trainers.h"
 
 #define AI_ACTION_DONE (1 << 0)
 #define AI_ACTION_FLEE (1 << 1)
@@ -139,48 +140,89 @@ static u32 GetWildAiFlags(void)
  return flags;
 }
 
+static u32 GetAiFlags(u16 trainerId)
+{
+ u32 flags = 0;
+
+ if (!(gBattleTypeFlags & BATTLE_TYPE_HAS_AI) && !IsWildMonSmart())
+ return 0;
+ if (trainerId == 0xFFFF)
+ {
+ flags = GetWildAiFlags();
+ }
+ else
+ {
+ if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
+ flags = GetAiScriptsInRecordedBattle();
+ else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+ flags = AI_FLAG_SAFARI;
+ else if (gBattleTypeFlags & BATTLE_TYPE_ROAMER)
+ flags = AI_FLAG_ROAMING;
+ else if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
+ flags = AI_FLAG_FIRST_BATTLE;
+ else if (gBattleTypeFlags & BATTLE_TYPE_FACTORY)
+ flags = GetAiScriptsInBattleFactory();
+ else if (gBattleTypeFlags & (BATTLE_TYPE_FRONTIER | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_TRAINER_HILL | BATTLE_TYPE_SECRET_BASE))
+ flags = AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT;
+ else
+ flags = gTrainers[trainerId].aiFlags;
+ }
+
+ if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+ flags |= AI_FLAG_DOUBLE_BATTLE;
+
+ return flags;
+}
+
 void BattleAI_SetupFlags(void)
 {
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_PLAYER_LEFT] = 0; // player has no AI
+
 #if DEBUG_OVERWORLD_MENU == TRUE
  if (gIsDebugBattle)
- AI_THINKING_STRUCT->aiFlags = gDebugAIFlags;
- else
+ {
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_LEFT] = gDebugAIFlags;
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_RIGHT] = gDebugAIFlags;
+ return;
+ } 
 #endif
- if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
- AI_THINKING_STRUCT->aiFlags = GetAiScriptsInRecordedBattle();
- else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
- AI_THINKING_STRUCT->aiFlags = AI_FLAG_SAFARI;
- else if (gBattleTypeFlags & BATTLE_TYPE_ROAMER)
- AI_THINKING_STRUCT->aiFlags = AI_FLAG_ROAMING;
- else if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
- AI_THINKING_STRUCT->aiFlags = AI_FLAG_FIRST_BATTLE;
- else if (gBattleTypeFlags & BATTLE_TYPE_FACTORY)
- AI_THINKING_STRUCT->aiFlags = GetAiScriptsInBattleFactory();
- else if (gBattleTypeFlags & (BATTLE_TYPE_FRONTIER | BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_TRAINER_HILL | BATTLE_TYPE_SECRET_BASE))
- AI_THINKING_STRUCT->aiFlags = AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_CHECK_VIABILITY | AI_FLAG_TRY_TO_FAINT;
- else if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
- AI_THINKING_STRUCT->aiFlags = gTrainers[gTrainerBattleOpponent_A].aiFlags | gTrainers[gTrainerBattleOpponent_B].aiFlags;
+
+ if (IsWildMonSmart() && !(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER)))
+ {
+ // smart wild AI
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(0xFFFF);
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(0xFFFF);
+ }
  else
- AI_THINKING_STRUCT->aiFlags = gTrainers[gTrainerBattleOpponent_A].aiFlags;
-
- // check smart wild AI
- if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER)) && IsWildMonSmart())
- AI_THINKING_STRUCT->aiFlags |= GetWildAiFlags();
-
- if (gBattleTypeFlags & (BATTLE_TYPE_DOUBLE | BATTLE_TYPE_TWO_OPPONENTS) || gTrainers[gTrainerBattleOpponent_A].doubleBattle)
- AI_THINKING_STRUCT->aiFlags |= AI_FLAG_DOUBLE_BATTLE; // Act smart in doubles and don't attack your partner.
+ {
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_LEFT] = GetAiFlags(gTrainerBattleOpponent_A);
+ if (gTrainerBattleOpponent_B != 0)
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_RIGHT] = GetAiFlags(gTrainerBattleOpponent_B);
+ else
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_RIGHT] = AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_LEFT];
+ }
+
+ if (gBattleTypeFlags & BATTLE_TYPE_INGAME_PARTNER)
+ {
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_PLAYER_RIGHT] = GetAiFlags(gPartnerTrainerId - TRAINER_PARTNER(PARTNER_NONE));
+ }
+ else
+ {
+ AI_THINKING_STRUCT->aiFlags[B_POSITION_PLAYER_RIGHT] = 0; // player
+ }
 }
 
 // sBattler_AI set in ComputeBattleAiScores
 void BattleAI_SetupAIData(u8 defaultScoreMoves, u32 battler)
 {
  s32 i;
  u8 moveLimitations;
+ u32 flags[MAX_BATTLERS_COUNT];
 
  // Clear AI data but preserve the flags.
- u32 flags = AI_THINKING_STRUCT->aiFlags;
+ memcpy(&flags[0], &AI_THINKING_STRUCT->aiFlags[0], sizeof(u32) * MAX_BATTLERS_COUNT);
  memset(AI_THINKING_STRUCT, 0, sizeof(struct AI_ThinkingStruct));
- AI_THINKING_STRUCT->aiFlags = flags;
+ memcpy(&AI_THINKING_STRUCT->aiFlags[0], &flags[0], sizeof(u32) * MAX_BATTLERS_COUNT);
 
  // Conditional score reset, unlike Ruby.
  for (i = 0; i < MAX_MON_MOVES; i++)
@@ -251,7 +293,7 @@ static void CopyBattlerDataToAIParty(u32 bPosition, u32 side)
 void Ai_InitPartyStruct(void)
 {
  u32 i;
- bool32 isOmniscient = (AI_THINKING_STRUCT->aiFlags & AI_FLAG_OMNISCIENT);
+ bool32 isOmniscient = (AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_LEFT] & AI_FLAG_OMNISCIENT) || (AI_THINKING_STRUCT->aiFlags[B_POSITION_OPPONENT_RIGHT] & AI_FLAG_OMNISCIENT);
  struct Pokemon *mon;
 
  AI_PARTY->count[B_SIDE_PLAYER] = gPlayerPartyCount;
@@ -433,13 +475,13 @@ static bool32 AI_ShouldSwitchIfBadMoves(u32 battler, bool32 doubleBattle)
  if (CountUsablePartyMons(battler) > 0
  && !IsBattlerTrapped(battler, TRUE)
  && !(gBattleTypeFlags & (BATTLE_TYPE_ARENA | BATTLE_TYPE_PALACE))
- && AI_THINKING_STRUCT->aiFlags & (AI_FLAG_CHECK_VIABILITY | AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_TRY_TO_FAINT | AI_FLAG_PREFER_BATON_PASS))
+ && AI_THINKING_STRUCT->aiFlags[battler] & (AI_FLAG_CHECK_VIABILITY | AI_FLAG_CHECK_BAD_MOVE | AI_FLAG_TRY_TO_FAINT | AI_FLAG_PREFER_BATON_PASS))
  {
  // Consider switching if all moves are worthless to use.
  if (GetTotalBaseStat(gBattleMons[battler].species) >= 310 // Mon is not weak.
  && gBattleMons[battler].hp >= gBattleMons[battler].maxHP / 2) // Mon has more than 50% of its HP
  {
- s32 cap = AI_THINKING_STRUCT->aiFlags & (AI_FLAG_CHECK_VIABILITY) ? 95 : 93;
+ s32 cap = AI_THINKING_STRUCT->aiFlags[battler] & (AI_FLAG_CHECK_VIABILITY) ? 95 : 93;
  if (doubleBattle)
  {
  for (i = 0; i < MAX_BATTLERS_COUNT; i++)
@@ -492,7 +534,7 @@ static u32 ChooseMoveOrAction_Singles(u32 battlerAi)
  u8 consideredMoveArray[MAX_MON_MOVES];
  u32 numOfBestMoves;
  s32 i;
- u32 flags = AI_THINKING_STRUCT->aiFlags;
+ u32 flags = AI_THINKING_STRUCT->aiFlags[battlerAi];
 
  AI_DATA->partnerMove = 0; // no ally
  while (flags != 0)
@@ -577,7 +619,7 @@ static u32 ChooseMoveOrAction_Doubles(u32 battlerAi)
  AI_DATA->partnerMove = GetAllyChosenMove(battlerAi);
  AI_THINKING_STRUCT->aiLogicId = 0;
  AI_THINKING_STRUCT->movesetIndex = 0;
- flags = AI_THINKING_STRUCT->aiFlags;
+ flags = AI_THINKING_STRUCT->aiFlags[sBattler_AI];
 
  while (flags != 0)
  {
@@ -1017,7 +1059,7 @@ static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, u32 move, s32 score)
  ADJUST_SCORE(-10);
  break;
  case EFFECT_EXPLOSION:
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_WILL_SUICIDE))
+ if (!(AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_WILL_SUICIDE))
  ADJUST_SCORE(-2);
 
  if (effectiveness == AI_EFFECTIVENESS_x0)
@@ -1996,7 +2038,7 @@ static s32 AI_CheckBadMove(u32 battlerAtk, u32 battlerDef, u32 move, s32 score)
  }
  }
 
- /*if (AI_THINKING_STRUCT->aiFlags == AI_SCRIPT_CHECK_BAD_MOVE //Only basic AI
+ /*if (AI_THINKING_STRUCT->aiFlags[battlerAtk] == AI_SCRIPT_CHECK_BAD_MOVE //Only basic AI
  && IS_DOUBLE_BATTLE) //Make the regular AI know how to use Protect minimally in Doubles
  {
  u8 shouldProtect = ShouldProtect(battlerAtk, battlerDef, move);
@@ -2803,7 +2845,7 @@ static s32 AI_DoubleBattle(u32 battlerAtk, u32 battlerDef, u32 move, s32 score)
  switch (atkPartnerAbility)
  {
  case ABILITY_VOLT_ABSORB:
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_HP_AWARE))
+ if (!(AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_HP_AWARE))
  {
  RETURN_SCORE_MINUS(10);
  }
@@ -2824,7 +2866,7 @@ static s32 AI_DoubleBattle(u32 battlerAtk, u32 battlerDef, u32 move, s32 score)
  break;
  case ABILITY_WATER_ABSORB:
  case ABILITY_DRY_SKIN:
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_HP_AWARE))
+ if (!(AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_HP_AWARE))
  {
  RETURN_SCORE_MINUS(10);
  }
@@ -3233,15 +3275,15 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  }
 
  // check status move preference
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_PREFER_STATUS_MOVES && IS_MOVE_STATUS(move) && effectiveness != AI_EFFECTIVENESS_x0)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_PREFER_STATUS_MOVES && IS_MOVE_STATUS(move) && effectiveness != AI_EFFECTIVENESS_x0)
  ADJUST_SCORE(1);
 
  // check thawing moves
  if ((gBattleMons[battlerAtk].status1 & (STATUS1_FREEZE | STATUS1_FROSTBITE)) && gBattleMoves[move].thawsUser)
  ADJUST_SCORE(10);
 
  // check burn / frostbite
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING && AI_DATA->abilities[battlerAtk] == ABILITY_NATURAL_CURE)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_SMART_SWITCHING && AI_DATA->abilities[battlerAtk] == ABILITY_NATURAL_CURE)
  {
  if ((gBattleMons[battlerAtk].status1 & STATUS1_BURN && HasOnlyMovesWithCategory(battlerAtk, BATTLE_CATEGORY_PHYSICAL, TRUE))
  || (gBattleMons[battlerAtk].status1 & STATUS1_FROSTBITE && HasOnlyMovesWithCategory(battlerAtk, BATTLE_CATEGORY_SPECIAL, TRUE)))
@@ -3263,7 +3305,7 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  ADJUST_SCORE(2);
  case EFFECT_EXPLOSION:
  case EFFECT_MEMENTO:
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_WILL_SUICIDE && gBattleMons[battlerDef].statStages[STAT_EVASION] < 7)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_WILL_SUICIDE && gBattleMons[battlerDef].statStages[STAT_EVASION] < 7)
  {
  if (aiData->hpPercents[battlerAtk] < 50 && AI_RandLessThan(128))
  ADJUST_SCORE(1);
@@ -3569,7 +3611,7 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  ADJUST_SCORE(5);
  if (aiData->holdEffects[battlerAtk] == HOLD_EFFECT_LIGHT_CLAY)
  ADJUST_SCORE(2);
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SCREENER)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_SCREENER)
  ADJUST_SCORE(2);
  }
  break;
@@ -3611,7 +3653,7 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  ADJUST_SCORE(5);
  break;
  case EFFECT_MIST:
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SCREENER)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_SCREENER)
  ADJUST_SCORE(2);
  break;
  case EFFECT_FOCUS_ENERGY:
@@ -4070,7 +4112,7 @@ static s32 AI_CheckViability(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  break;
  case STAT_DEF:
  case STAT_SPDEF:
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_STALL)
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_STALL)
  ADJUST_SCORE(1);
  break;
  }
@@ -4868,7 +4910,7 @@ static s32 AI_SetupFirstTurn(u32 battlerAtk, u32 battlerDef, u32 move, s32 score
  || gBattleResults.battleTurnCounter != 0)
  return score;
 
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING
+ if (AI_THINKING_STRUCT->aiFlags[battlerAtk] & AI_FLAG_SMART_SWITCHING
  && AI_WhoStrikesFirst(battlerAtk, battlerDef, move) == AI_IS_SLOWER
  && CanTargetFaintAi(battlerDef, battlerAtk)
  && GetMovePriority(battlerAtk, move) == 0)

src/battle_ai_switch_items.c

@@ -38,10 +38,10 @@ static void InitializeSwitchinCandidate(struct Pokemon *mon)
 
 static bool32 IsAceMon(u32 battler, u32 monPartyId)
 {
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_ACE_POKEMON
- && !(gBattleStruct->forcedSwitch & gBitTable[battler])
- && monPartyId == CalculateEnemyPartyCount()-1)
-  return TRUE;
+ if (AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_ACE_POKEMON
+  && !(gBattleStruct->forcedSwitch & gBitTable[battler])
+  && monPartyId == CalculateEnemyPartyCount()-1)
+ return TRUE;
  return FALSE;
 }
 
@@ -77,7 +77,7 @@ static bool32 HasBadOdds(u32 battler, bool32 emitResult)
  u16 typeEffectiveness = UQ_4_12(1.0), aiMoveEffect; //baseline typing damage
 
  // Only use this if AI_FLAG_SMART_SWITCHING is set for the trainer
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING))
+ if (!(AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_SWITCHING))
  return FALSE;
 
  // Won't bother configuring this for double battles
@@ -433,7 +433,7 @@ static bool32 ShouldSwitchIfGameStatePrompt(u32 battler, bool32 emitResult)
  && monAbility != ABILITY_SOUNDPROOF)
  switchMon = TRUE;
 
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING)
+ if (AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_SWITCHING)
  {
  //Yawn
  if (gStatuses3[battler] & STATUS3_YAWN
@@ -851,7 +851,7 @@ static bool32 CanMonSurviveHazardSwitchin(u32 battler)
 static bool32 ShouldSwitchIfEncored(u32 battler, bool32 emitResult)
 {
  // Only use this if AI_FLAG_SMART_SWITCHING is set for the trainer
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING))
+ if (!(AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_SWITCHING))
  return FALSE;
 
  // If not Encored or if no good switchin, don't switch
@@ -877,7 +877,7 @@ static bool32 AreAttackingStatsLowered(u32 battler, bool32 emitResult)
  s8 spAttackingStage = gBattleMons[battler].statStages[STAT_SPATK];
 
  // Only use this if AI_FLAG_SMART_SWITCHING is set for the trainer
- if (!(AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING))
+ if (!(AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_SWITCHING))
  return FALSE;
 
  // Physical attacker
@@ -1015,7 +1015,7 @@ bool32 ShouldSwitch(u32 battler, bool32 emitResult)
  return TRUE;
 
  //These Functions can prompt switch to generic pary members
- if ((AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_SWITCHING) && (CanMonSurviveHazardSwitchin(battler) == FALSE))
+ if ((AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_SWITCHING) && (CanMonSurviveHazardSwitchin(battler) == FALSE))
  return FALSE;
  if (ShouldSwitchIfAllBadMoves(battler, emitResult))
  return TRUE;
@@ -1939,7 +1939,7 @@ u8 GetMostSuitableMonToSwitchInto(u32 battler, bool32 switchAfterMonKOd)
 
  // Split ideal mon decision between after previous mon KO'd (prioritize offensive options) and after switching active mon out (prioritize defensive options), and expand the scope of both.
  // Only use better mon selection if AI_FLAG_SMART_MON_CHOICES is set for the trainer.
- if (AI_THINKING_STRUCT->aiFlags & AI_FLAG_SMART_MON_CHOICES)
+ if (AI_THINKING_STRUCT->aiFlags[battler] & AI_FLAG_SMART_MON_CHOICES)
  {
  bestMonId = GetBestMonIntegrated(party, firstId, lastId, battler, opposingBattler, battlerIn1, battlerIn2, switchAfterMonKOd);
  return bestMonId;