diff --git a/include/battle.h b/include/battle.h
index d7621a2a5..20a2ad71f 100644
--- a/include/battle.h
+++ b/include/battle.h
@@ -982,7 +982,7 @@ extern u8 gBattlerPositions[MAX_BATTLERS_COUNT];
 extern u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
 extern u8 gBattleOutcome;
 extern u8 gBattleMonForms[MAX_BATTLERS_COUNT];
-extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void);
+extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler);
 extern u32 gBattleControllerExecFlags;
 extern u8 gBattleBufferA[MAX_BATTLERS_COUNT][0x200];
 extern u8 gBattleBufferB[MAX_BATTLERS_COUNT][0x200];
diff --git a/include/battle_controllers.h b/include/battle_controllers.h
index e6efe1366..c26645304 100644
--- a/include/battle_controllers.h
+++ b/include/battle_controllers.h
@@ -252,8 +252,8 @@ void BtlController_EmitResetActionMoveSelection(u32 bufferId, u8 caseId);
 void BtlController_EmitEndLinkBattle(u32 bufferId, u8 battleOutcome);
 
 // player controller
-void BattleControllerDummy(void);
-void SetControllerToPlayer(void);
+void BattleControllerDummy(u32 battler);
+void SetControllerToPlayer(u32 battler);
 void PlayerHandleGetRawMonData(u32 battler);
 void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite);
 void SetCB2ToReshowScreenAfterMenu(void);
@@ -261,25 +261,25 @@ void SetCB2ToReshowScreenAfterMenu2(void);
 void Task_PlayerController_RestoreBgmAfterCry(u8 taskId);
 void ActionSelectionCreateCursorAt(u8 cursorPos, u8 unused);
 void ActionSelectionDestroyCursorAt(u8 cursorPos);
-void InitMoveSelectionsVarsAndStrings(void);
-void SetBattleEndCallbacks(void);
+void InitMoveSelectionsVarsAndStrings(u32 battler);
+void SetBattleEndCallbacks(u32 battler);
 void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1);
 void MoveSelectionDestroyCursorAt(u8 cursorPos);
-void HandleInputChooseMove(void);
+void HandleInputChooseMove(u32 battler);
 
 // opponent controller
-void SetControllerToOpponent(void);
-void OpponentBufferExecCompleted(void);
+void SetControllerToOpponent(u32 battler);
+void OpponentBufferExecCompleted(u32 battler);
 
 // safari controller
-void SetControllerToSafari(void);
+void SetControllerToSafari(u32 battler);
 
 // pokedude controller
-void SetControllerToPokedude(void);
+void SetControllerToPokedude(u32 battler);
 void InitPokedudePartyAndOpponent(void);
 
 // oak and old man controller
-void SetControllerToOakOrOldMan(void);
+void SetControllerToOakOrOldMan(u32 battler);
 
 // These flags are set to signal that the indicated message
 // was already emitted
@@ -295,17 +295,17 @@ void SetControllerToOakOrOldMan(void);
 
 bool8 BtlCtrl_OakOldMan_TestState2Flag(u8 mask);
 void BtlCtrl_OakOldMan_SetState2Flag(u8 mask);
-void PrintOakText_InflictingDamageIsKey(void);
-void PrintOakText_HowDisappointing(void);
-void PrintOakText_OakNoRunningFromATrainer(void);
-void OakOldManHandleInputChooseMove(void);
+void PrintOakText_InflictingDamageIsKey(u32 battler);
+void PrintOakText_HowDisappointing(u32 battler);
+void PrintOakText_OakNoRunningFromATrainer(u32 battler);
+void OakOldManHandleInputChooseMove(u32 battler);
 void BtlCtrl_DrawVoiceoverMessageFrame(void);
 void BtlCtrl_RemoveVoiceoverMessageFrame(void);
 
 // link opponent controller
-void SetControllerToLinkOpponent(void);
+void SetControllerToLinkOpponent(u32 battler);
 
 // link partner controller
-void SetControllerToLinkPartner(void);
+void SetControllerToLinkPartner(u32 battler);
 
 #endif // GUARD_BATTLE_CONTROLLERS_H
diff --git a/src/battle_controller_link_opponent.c b/src/battle_controller_link_opponent.c
index 7b6f432d6..a08a3c331 100644
--- a/src/battle_controller_link_opponent.c
+++ b/src/battle_controller_link_opponent.c
@@ -16,77 +16,77 @@
 #include "constants/sound.h"
 #include "constants/trainers.h"
 
-static void LinkOpponentHandleGetMonData(void);
-static void LinkOpponentHandleGetRawMonData(void);
-static void LinkOpponentHandleSetMonData(void);
-static void LinkOpponentHandleSetRawMonData(void);
-static void LinkOpponentHandleLoadMonSprite(void);
-static void LinkOpponentHandleSwitchInAnim(void);
-static void LinkOpponentHandleReturnMonToBall(void);
-static void LinkOpponentHandleDrawTrainerPic(void);
-static void LinkOpponentHandleTrainerSlide(void);
-static void LinkOpponentHandleTrainerSlideBack(void);
-static void LinkOpponentHandleFaintAnimation(void);
-static void LinkOpponentHandlePaletteFade(void);
-static void LinkOpponentHandleSuccessBallThrowAnim(void);
-static void LinkOpponentHandleBallThrowAnim(void);
-static void LinkOpponentHandlePause(void);
-static void LinkOpponentHandleMoveAnimation(void);
-static void LinkOpponentHandlePrintString(void);
-static void LinkOpponentHandlePrintSelectionString(void);
-static void LinkOpponentHandleChooseAction(void);
-static void LinkOpponentHandleUnknownYesNoBox(void);
-static void LinkOpponentHandleChooseMove(void);
-static void LinkOpponentHandleChooseItem(void);
-static void LinkOpponentHandleChoosePokemon(void);
-static void LinkOpponentHandleCmd23(void);
-static void LinkOpponentHandleHealthBarUpdate(void);
-static void LinkOpponentHandleExpUpdate(void);
-static void LinkOpponentHandleStatusIconUpdate(void);
-static void LinkOpponentHandleStatusAnimation(void);
-static void LinkOpponentHandleStatusXor(void);
-static void LinkOpponentHandleDataTransfer(void);
-static void LinkOpponentHandleDMA3Transfer(void);
-static void LinkOpponentHandlePlayBGM(void);
-static void LinkOpponentHandleCmd32(void);
-static void LinkOpponentHandleTwoReturnValues(void);
-static void LinkOpponentHandleChosenMonReturnValue(void);
-static void LinkOpponentHandleOneReturnValue(void);
-static void LinkOpponentHandleOneReturnValue_Duplicate(void);
-static void LinkOpponentHandleClearUnkVar(void);
-static void LinkOpponentHandleSetUnkVar(void);
-static void LinkOpponentHandleClearUnkFlag(void);
-static void LinkOpponentHandleToggleUnkFlag(void);
-static void LinkOpponentHandleHitAnimation(void);
-static void LinkOpponentHandleCantSwitch(void);
-static void LinkOpponentHandlePlaySE(void);
-static void LinkOpponentHandlePlayFanfare(void);
-static void LinkOpponentHandleFaintingCry(void);
-static void LinkOpponentHandleIntroSlide(void);
-static void LinkOpponentHandleIntroTrainerBallThrow(void);
-static void LinkOpponentHandleDrawPartyStatusSummary(void);
-static void LinkOpponentHandleHidePartyStatusSummary(void);
-static void LinkOpponentHandleEndBounceEffect(void);
-static void LinkOpponentHandleSpriteInvisibility(void);
-static void LinkOpponentHandleBattleAnimation(void);
-static void LinkOpponentHandleLinkStandbyMsg(void);
-static void LinkOpponentHandleResetActionMoveSelection(void);
-static void LinkOpponentHandleEndLinkBattle(void);
-static void LinkOpponentCmdEnd(void);
+static void LinkOpponentHandleGetMonData(u32 battler);
+static void LinkOpponentHandleGetRawMonData(u32 battler);
+static void LinkOpponentHandleSetMonData(u32 battler);
+static void LinkOpponentHandleSetRawMonData(u32 battler);
+static void LinkOpponentHandleLoadMonSprite(u32 battler);
+static void LinkOpponentHandleSwitchInAnim(u32 battler);
+static void LinkOpponentHandleReturnMonToBall(u32 battler);
+static void LinkOpponentHandleDrawTrainerPic(u32 battler);
+static void LinkOpponentHandleTrainerSlide(u32 battler);
+static void LinkOpponentHandleTrainerSlideBack(u32 battler);
+static void LinkOpponentHandleFaintAnimation(u32 battler);
+static void LinkOpponentHandlePaletteFade(u32 battler);
+static void LinkOpponentHandleSuccessBallThrowAnim(u32 battler);
+static void LinkOpponentHandleBallThrowAnim(u32 battler);
+static void LinkOpponentHandlePause(u32 battler);
+static void LinkOpponentHandleMoveAnimation(u32 battler);
+static void LinkOpponentHandlePrintString(u32 battler);
+static void LinkOpponentHandlePrintSelectionString(u32 battler);
+static void LinkOpponentHandleChooseAction(u32 battler);
+static void LinkOpponentHandleUnknownYesNoBox(u32 battler);
+static void LinkOpponentHandleChooseMove(u32 battler);
+static void LinkOpponentHandleChooseItem(u32 battler);
+static void LinkOpponentHandleChoosePokemon(u32 battler);
+static void LinkOpponentHandleCmd23(u32 battler);
+static void LinkOpponentHandleHealthBarUpdate(u32 battler);
+static void LinkOpponentHandleExpUpdate(u32 battler);
+static void LinkOpponentHandleStatusIconUpdate(u32 battler);
+static void LinkOpponentHandleStatusAnimation(u32 battler);
+static void LinkOpponentHandleStatusXor(u32 battler);
+static void LinkOpponentHandleDataTransfer(u32 battler);
+static void LinkOpponentHandleDMA3Transfer(u32 battler);
+static void LinkOpponentHandlePlayBGM(u32 battler);
+static void LinkOpponentHandleCmd32(u32 battler);
+static void LinkOpponentHandleTwoReturnValues(u32 battler);
+static void LinkOpponentHandleChosenMonReturnValue(u32 battler);
+static void LinkOpponentHandleOneReturnValue(u32 battler);
+static void LinkOpponentHandleOneReturnValue_Duplicate(u32 battler);
+static void LinkOpponentHandleClearUnkVar(u32 battler);
+static void LinkOpponentHandleSetUnkVar(u32 battler);
+static void LinkOpponentHandleClearUnkFlag(u32 battler);
+static void LinkOpponentHandleToggleUnkFlag(u32 battler);
+static void LinkOpponentHandleHitAnimation(u32 battler);
+static void LinkOpponentHandleCantSwitch(u32 battler);
+static void LinkOpponentHandlePlaySE(u32 battler);
+static void LinkOpponentHandlePlayFanfare(u32 battler);
+static void LinkOpponentHandleFaintingCry(u32 battler);
+static void LinkOpponentHandleIntroSlide(u32 battler);
+static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler);
+static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler);
+static void LinkOpponentHandleHidePartyStatusSummary(u32 battler);
+static void LinkOpponentHandleEndBounceEffect(u32 battler);
+static void LinkOpponentHandleSpriteInvisibility(u32 battler);
+static void LinkOpponentHandleBattleAnimation(u32 battler);
+static void LinkOpponentHandleLinkStandbyMsg(u32 battler);
+static void LinkOpponentHandleResetActionMoveSelection(u32 battler);
+static void LinkOpponentHandleEndLinkBattle(u32 battler);
+static void LinkOpponentCmdEnd(u32 battler);
 
-static void LinkOpponentBufferRunCommand(void);
-static void LinkOpponentBufferExecCompleted(void);
-static void SwitchIn_HandleSoundAndEnd(void);
+static void LinkOpponentBufferRunCommand(u32 battler);
+static void LinkOpponentBufferExecCompleted(u32 battler);
+static void SwitchIn_HandleSoundAndEnd(u32 battler);
 static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst);
 static void SetLinkOpponentMonData(u8 monId);
 static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
-static void DoSwitchOutAnimation(void);
-static void LinkOpponentDoMoveAnimation(void);
+static void DoSwitchOutAnimation(u32 battler);
+static void LinkOpponentDoMoveAnimation(u32 battler);
 static void Task_StartSendOutAnim(u8 taskId);
 static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite);
-static void EndDrawPartyStatusSummary(void);
+static void EndDrawPartyStatusSummary(u32 battler);
 
-static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = LinkOpponentHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = LinkOpponentHandleGetRawMonData,
@@ -147,33 +147,33 @@ static void (*const sLinkOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_TERMINATOR_NOP]           = LinkOpponentCmdEnd
 };
 
-static void LinkOpponentDummy(void)
+static void LinkOpponentDummy(u32 battler)
 {
 }
 
-void SetControllerToLinkOpponent(void)
+void SetControllerToLinkOpponent(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = LinkOpponentBufferRunCommand;
 }
 
-static void LinkOpponentBufferRunCommand(void)
+static void LinkOpponentBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < ARRAY_COUNT(sLinkOpponentBufferCommands))
-            sLinkOpponentBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            sLinkOpponentBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         else
-            LinkOpponentBufferExecCompleted();
+            LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
 }
 
-static void FreeTrainerSpriteAfterSlide(void)
+static void FreeTrainerSpriteAfterSlide(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
@@ -181,20 +181,20 @@ static void FreeTrainerSpriteAfterSlide(void)
         gSprites[gBattlerSpriteIds[gActiveBattler]].oam.tileNum = gSprites[gBattlerSpriteIds[gActiveBattler]].data[5];
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void Intro_DelayAndEnd(void)
+static void Intro_DelayAndEnd(u32 battler)
 {
     if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0;
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void Intro_WaitForShinyAnimAndHealthbox(void)
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler)
 {
     bool32 healthboxAnimDone = FALSE;
 
@@ -241,7 +241,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(void)
     }
 }
 
-static void Intro_TryShinyAnimShowHealthbox(void)
+static void Intro_TryShinyAnimShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive
      && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].ballAnimActive)
@@ -278,7 +278,7 @@ static void Intro_TryShinyAnimShowHealthbox(void)
     }
 }
 
-static void TryShinyAnimAfterMonAnim(void)
+static void TryShinyAnimAfterMonAnim(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded == TRUE
      && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0)
@@ -293,12 +293,12 @@ static void TryShinyAnimAfterMonAnim(void)
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE;
             FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS);
             FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS);
-            LinkOpponentBufferExecCompleted();
+            LinkOpponentBufferExecCompleted(battler);
         }
     }
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
     s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
 
@@ -307,19 +307,19 @@ static void CompleteOnHealthbarDone(void)
     if (hpValue != -1)
         UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], hpValue, HP_CURRENT);
     else
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
 }
 
-static void HideHealthboxAfterMonFaint(void)
+static void HideHealthboxAfterMonFaint(u32 battler)
 {
     if (!gSprites[gBattlerSpriteIds[gActiveBattler]].inUse)
     {
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void FreeMonSpriteAfterSwitchOutAnim(void)
+static void FreeMonSpriteAfterSwitchOutAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
@@ -327,17 +327,17 @@ static void FreeMonSpriteAfterSwitchOutAnim(void)
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         HideBattlerShadowSprite(gActiveBattler);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(B_WIN_MSG))
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
     u8 spriteId = gBattlerSpriteIds[gActiveBattler];
 
@@ -346,7 +346,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -356,7 +356,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void SwitchIn_ShowSubstitute(void)
+static void SwitchIn_ShowSubstitute(u32 battler)
 {
     if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
@@ -367,16 +367,16 @@ static void SwitchIn_ShowSubstitute(void)
     }
 }
 
-static void SwitchIn_HandleSoundAndEnd(void)
+static void SwitchIn_HandleSoundAndEnd(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive && !IsCryPlayingOrClearCrySongs())
     {
         m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100);
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void SwitchIn_ShowHealthbox(void)
+static void SwitchIn_ShowHealthbox(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim)
     {
@@ -396,7 +396,7 @@ static void SwitchIn_ShowHealthbox(void)
     }
 }
 
-static void SwitchIn_TryShinyAnim(void)
+static void SwitchIn_TryShinyAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive
         && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim)
@@ -413,19 +413,19 @@ static void SwitchIn_TryShinyAnim(void)
     }
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentBufferExecCompleted(void)
+static void LinkOpponentBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = LinkOpponentBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -441,7 +441,7 @@ static void LinkOpponentBufferExecCompleted(void)
     }
 }
 
-static void LinkOpponentHandleGetMonData(void)
+static void LinkOpponentHandleGetMonData(u32 battler)
 {
     u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data
     u32 size = 0;
@@ -463,7 +463,7 @@ static void LinkOpponentHandleGetMonData(void)
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
 static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst)
@@ -771,12 +771,12 @@ static u32 CopyLinkOpponentMonData(u8 monId, u8 *dst)
     return size;
 }
 
-static void LinkOpponentHandleGetRawMonData(void)
+static void LinkOpponentHandleGetRawMonData(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleSetMonData(void)
+static void LinkOpponentHandleSetMonData(u32 battler)
 {
     u8 monToCheck;
     u8 i;
@@ -795,7 +795,7 @@ static void LinkOpponentHandleSetMonData(void)
             monToCheck >>= 1;
         }
     }
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
 static void SetLinkOpponentMonData(u8 monId)
@@ -1014,7 +1014,7 @@ static void SetLinkOpponentMonData(u8 monId)
     }
 }
 
-static void LinkOpponentHandleSetRawMonData(void)
+static void LinkOpponentHandleSetRawMonData(u32 battler)
 {
     u8 *dst = (u8 *)&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
     u8 i;
@@ -1022,10 +1022,10 @@ static void LinkOpponentHandleSetRawMonData(void)
     for (i = 0; i < gBattleBufferA[gActiveBattler][2]; i++)
         dst[i] = gBattleBufferA[gActiveBattler][3 + i];
 
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleLoadMonSprite(void)
+static void LinkOpponentHandleLoadMonSprite(u32 battler)
 {
     u16 species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
@@ -1047,7 +1047,7 @@ static void LinkOpponentHandleLoadMonSprite(void)
     gBattlerControllerFuncs[gActiveBattler] = TryShinyAnimAfterMonAnim;
 }
 
-static void LinkOpponentHandleSwitchInAnim(void)
+static void LinkOpponentHandleSwitchInAnim(u32 battler)
 {
     gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1];
     StartSendOutAnim(gActiveBattler, gBattleBufferA[gActiveBattler][2]);
@@ -1083,7 +1083,7 @@ static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
     gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
 }
 
-static void LinkOpponentHandleReturnMonToBall(void)
+static void LinkOpponentHandleReturnMonToBall(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] == 0)
     {
@@ -1096,11 +1096,11 @@ static void LinkOpponentHandleReturnMonToBall(void)
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         HideBattlerShadowSprite(gActiveBattler);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
     switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
     {
@@ -1123,7 +1123,7 @@ static void DoSwitchOutAnimation(void)
 
 #define sSpeedX data[0]
 
-static void LinkOpponentHandleDrawTrainerPic(void)
+static void LinkOpponentHandleDrawTrainerPic(u32 battler)
 {
     s16 xPos;
     u32 trainerPicId;
@@ -1195,14 +1195,14 @@ static void LinkOpponentHandleDrawTrainerPic(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
-static void LinkOpponentHandleTrainerSlide(void)
+static void LinkOpponentHandleTrainerSlide(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
 #undef sSpeedX
 
-static void LinkOpponentHandleTrainerSlideBack(void)
+static void LinkOpponentHandleTrainerSlideBack(u32 battler)
 {
     SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
     gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 35;
@@ -1213,7 +1213,7 @@ static void LinkOpponentHandleTrainerSlideBack(void)
     gBattlerControllerFuncs[gActiveBattler] = FreeTrainerSpriteAfterSlide;
 }
 
-static void LinkOpponentHandleFaintAnimation(void)
+static void LinkOpponentHandleFaintAnimation(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0)
     {
@@ -1233,27 +1233,27 @@ static void LinkOpponentHandleFaintAnimation(void)
     }
 }
 
-static void LinkOpponentHandlePaletteFade(void)
+static void LinkOpponentHandlePaletteFade(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleSuccessBallThrowAnim(void)
+static void LinkOpponentHandleSuccessBallThrowAnim(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleBallThrowAnim(void)
+static void LinkOpponentHandleBallThrowAnim(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandlePause(void)
+static void LinkOpponentHandlePause(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleMoveAnimation(void)
+static void LinkOpponentHandleMoveAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1268,7 +1268,7 @@ static void LinkOpponentHandleMoveAnimation(void)
         gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
         if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE
         {
-            LinkOpponentBufferExecCompleted();
+            LinkOpponentBufferExecCompleted(battler);
         }
         else
         {
@@ -1278,7 +1278,7 @@ static void LinkOpponentHandleMoveAnimation(void)
     }
 }
 
-static void LinkOpponentDoMoveAnimation(void)
+static void LinkOpponentDoMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
     u8 multihit = gBattleBufferA[gActiveBattler][11];
@@ -1321,13 +1321,13 @@ static void LinkOpponentDoMoveAnimation(void)
             CopyAllBattleSpritesInvisibilities();
             TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            LinkOpponentBufferExecCompleted();
+            LinkOpponentBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void LinkOpponentHandlePrintString(void)
+static void LinkOpponentHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -1342,42 +1342,42 @@ static void LinkOpponentHandlePrintString(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
-static void LinkOpponentHandlePrintSelectionString(void)
+static void LinkOpponentHandlePrintSelectionString(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleChooseAction(void)
+static void LinkOpponentHandleChooseAction(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleUnknownYesNoBox(void)
+static void LinkOpponentHandleUnknownYesNoBox(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleChooseMove(void)
+static void LinkOpponentHandleChooseMove(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleChooseItem(void)
+static void LinkOpponentHandleChooseItem(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleChoosePokemon(void)
+static void LinkOpponentHandleChoosePokemon(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleCmd23(void)
+static void LinkOpponentHandleCmd23(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleHealthBarUpdate(void)
+static void LinkOpponentHandleHealthBarUpdate(u32 battler)
 {
     s16 hpVal;
 
@@ -1401,12 +1401,12 @@ static void LinkOpponentHandleHealthBarUpdate(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
 }
 
-static void LinkOpponentHandleExpUpdate(void)
+static void LinkOpponentHandleExpUpdate(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleStatusIconUpdate(void)
+static void LinkOpponentHandleStatusIconUpdate(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1419,7 +1419,7 @@ static void LinkOpponentHandleStatusIconUpdate(void)
     }
 }
 
-static void LinkOpponentHandleStatusAnimation(void)
+static void LinkOpponentHandleStatusAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1429,80 +1429,80 @@ static void LinkOpponentHandleStatusAnimation(void)
     }
 }
 
-static void LinkOpponentHandleStatusXor(void)
+static void LinkOpponentHandleStatusXor(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleDataTransfer(void)
+static void LinkOpponentHandleDataTransfer(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleDMA3Transfer(void)
+static void LinkOpponentHandleDMA3Transfer(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandlePlayBGM(void)
+static void LinkOpponentHandlePlayBGM(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleCmd32(void)
+static void LinkOpponentHandleCmd32(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleTwoReturnValues(void)
+static void LinkOpponentHandleTwoReturnValues(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleChosenMonReturnValue(void)
+static void LinkOpponentHandleChosenMonReturnValue(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleOneReturnValue(void)
+static void LinkOpponentHandleOneReturnValue(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleOneReturnValue_Duplicate(void)
+static void LinkOpponentHandleOneReturnValue_Duplicate(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleClearUnkVar(void)
+static void LinkOpponentHandleClearUnkVar(u32 battler)
 {
     gUnusedControllerStruct.unk = 0;
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleSetUnkVar(void)
+static void LinkOpponentHandleSetUnkVar(u32 battler)
 {
     gUnusedControllerStruct.unk = gBattleBufferA[gActiveBattler][1];
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleClearUnkFlag(void)
+static void LinkOpponentHandleClearUnkFlag(u32 battler)
 {
     gUnusedControllerStruct.flag = 0;
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleToggleUnkFlag(void)
+static void LinkOpponentHandleToggleUnkFlag(u32 battler)
 {
     gUnusedControllerStruct.flag ^= 1;
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleHitAnimation(void)
+static void LinkOpponentHandleHitAnimation(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
     {
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -1513,12 +1513,12 @@ static void LinkOpponentHandleHitAnimation(void)
     }
 }
 
-static void LinkOpponentHandleCantSwitch(void)
+static void LinkOpponentHandleCantSwitch(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandlePlaySE(void)
+static void LinkOpponentHandlePlaySE(u32 battler)
 {
     s8 pan;
 
@@ -1528,31 +1528,31 @@ static void LinkOpponentHandlePlaySE(void)
         pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandlePlayFanfare(void)
+static void LinkOpponentHandlePlayFanfare(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleFaintingCry(void)
+static void LinkOpponentHandleFaintingCry(u32 battler)
 {
     u16 species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry_ByMode(species, 25, CRY_MODE_FAINT);
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleIntroSlide(void)
+static void LinkOpponentHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleIntroTrainerBallThrow(void)
+static void LinkOpponentHandleIntroTrainerBallThrow(u32 battler)
 {
     u8 taskId;
 
@@ -1607,11 +1607,11 @@ static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite)
     DestroySprite(sprite);
 }
 
-static void LinkOpponentHandleDrawPartyStatusSummary(void)
+static void LinkOpponentHandleDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] != 0 && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -1640,38 +1640,38 @@ static void LinkOpponentHandleDrawPartyStatusSummary(void)
     }
 }
 
-static void EndDrawPartyStatusSummary(void)
+static void EndDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer++ > 92)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0;
-        LinkOpponentBufferExecCompleted();
+        LinkOpponentBufferExecCompleted(battler);
     }
 }
 
-static void LinkOpponentHandleHidePartyStatusSummary(void)
+static void LinkOpponentHandleHidePartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
         gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleEndBounceEffect(void)
+static void LinkOpponentHandleEndBounceEffect(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleSpriteInvisibility(void)
+static void LinkOpponentHandleSpriteInvisibility(u32 battler)
 {
     if (IsBattlerSpritePresent(gActiveBattler))
     {
         gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleBufferA[gActiveBattler][1];
         CopyBattleSpriteInvisibility(gActiveBattler);
     }
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleBattleAnimation(void)
+static void LinkOpponentHandleBattleAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1679,23 +1679,23 @@ static void LinkOpponentHandleBattleAnimation(void)
         u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
         if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-            LinkOpponentBufferExecCompleted();
+            LinkOpponentBufferExecCompleted(battler);
         else
             gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
     }
 }
 
-static void LinkOpponentHandleLinkStandbyMsg(void)
+static void LinkOpponentHandleLinkStandbyMsg(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleResetActionMoveSelection(void)
+static void LinkOpponentHandleResetActionMoveSelection(u32 battler)
 {
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
 }
 
-static void LinkOpponentHandleEndLinkBattle(void)
+static void LinkOpponentHandleEndLinkBattle(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] == B_OUTCOME_DREW)
         gBattleOutcome = gBattleBufferA[gActiveBattler][1];
@@ -1704,10 +1704,10 @@ static void LinkOpponentHandleEndLinkBattle(void)
 
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
-    LinkOpponentBufferExecCompleted();
+    LinkOpponentBufferExecCompleted(battler);
     gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks;
 }
 
-static void LinkOpponentCmdEnd(void)
+static void LinkOpponentCmdEnd(u32 battler)
 {
 }
diff --git a/src/battle_controller_link_partner.c b/src/battle_controller_link_partner.c
index 3621131c4..250ded60c 100644
--- a/src/battle_controller_link_partner.c
+++ b/src/battle_controller_link_partner.c
@@ -14,76 +14,76 @@
 #include "constants/songs.h"
 #include "constants/sound.h"
 
-static void LinkPartnerHandleGetMonData(void);
-static void LinkPartnerHandleGetRawMonData(void);
-static void LinkPartnerHandleSetMonData(void);
-static void LinkPartnerHandleSetRawMonData(void);
-static void LinkPartnerHandleLoadMonSprite(void);
-static void LinkPartnerHandleSwitchInAnim(void);
-static void LinkPartnerHandleReturnMonToBall(void);
-static void LinkPartnerHandleDrawTrainerPic(void);
-static void LinkPartnerHandleTrainerSlide(void);
-static void LinkPartnerHandleTrainerSlideBack(void);
-static void LinkPartnerHandleFaintAnimation(void);
-static void LinkPartnerHandlePaletteFade(void);
-static void LinkPartnerHandleSuccessBallThrowAnim(void);
-static void LinkPartnerHandleBallThrowAnim(void);
-static void LinkPartnerHandlePause(void);
-static void LinkPartnerHandleMoveAnimation(void);
-static void LinkPartnerHandlePrintString(void);
-static void LinkPartnerHandlePrintSelectionString(void);
-static void LinkPartnerHandleChooseAction(void);
-static void LinkPartnerHandleUnknownYesNoBox(void);
-static void LinkPartnerHandleChooseMove(void);
-static void LinkPartnerHandleChooseItem(void);
-static void LinkPartnerHandleChoosePokemon(void);
-static void LinkPartnerHandleCmd23(void);
-static void LinkPartnerHandleHealthBarUpdate(void);
-static void LinkPartnerHandleExpUpdate(void);
-static void LinkPartnerHandleStatusIconUpdate(void);
-static void LinkPartnerHandleStatusAnimation(void);
-static void LinkPartnerHandleStatusXor(void);
-static void LinkPartnerHandleDataTransfer(void);
-static void LinkPartnerHandleDMA3Transfer(void);
-static void LinkPartnerHandlePlayBGM(void);
-static void LinkPartnerHandleCmd32(void);
-static void LinkPartnerHandleTwoReturnValues(void);
-static void LinkPartnerHandleChosenMonReturnValue(void);
-static void LinkPartnerHandleOneReturnValue(void);
-static void LinkPartnerHandleOneReturnValue_Duplicate(void);
-static void LinkPartnerHandleClearUnkVar(void);
-static void LinkPartnerHandleSetUnkVar(void);
-static void LinkPartnerHandleClearUnkFlag(void);
-static void LinkPartnerHandleToggleUnkFlag(void);
-static void LinkPartnerHandleHitAnimation(void);
-static void LinkPartnerHandleCantSwitch(void);
-static void LinkPartnerHandlePlaySE(void);
-static void LinkPartnerHandlePlayFanfare(void);
-static void LinkPartnerHandleFaintingCry(void);
-static void LinkPartnerHandleIntroSlide(void);
-static void LinkPartnerHandleIntroTrainerBallThrow(void);
-static void LinkPartnerHandleDrawPartyStatusSummary(void);
-static void LinkPartnerHandleHidePartyStatusSummary(void);
-static void LinkPartnerHandleEndBounceEffect(void);
-static void LinkPartnerHandleSpriteInvisibility(void);
-static void LinkPartnerHandleBattleAnimation(void);
-static void LinkPartnerHandleLinkStandbyMsg(void);
-static void LinkPartnerHandleResetActionMoveSelection(void);
-static void LinkPartnerHandleEndLinkBattle(void);
-static void LinkPartnerCmdEnd(void);
+static void LinkPartnerHandleGetMonData(u32 battler);
+static void LinkPartnerHandleGetRawMonData(u32 battler);
+static void LinkPartnerHandleSetMonData(u32 battler);
+static void LinkPartnerHandleSetRawMonData(u32 battler);
+static void LinkPartnerHandleLoadMonSprite(u32 battler);
+static void LinkPartnerHandleSwitchInAnim(u32 battler);
+static void LinkPartnerHandleReturnMonToBall(u32 battler);
+static void LinkPartnerHandleDrawTrainerPic(u32 battler);
+static void LinkPartnerHandleTrainerSlide(u32 battler);
+static void LinkPartnerHandleTrainerSlideBack(u32 battler);
+static void LinkPartnerHandleFaintAnimation(u32 battler);
+static void LinkPartnerHandlePaletteFade(u32 battler);
+static void LinkPartnerHandleSuccessBallThrowAnim(u32 battler);
+static void LinkPartnerHandleBallThrowAnim(u32 battler);
+static void LinkPartnerHandlePause(u32 battler);
+static void LinkPartnerHandleMoveAnimation(u32 battler);
+static void LinkPartnerHandlePrintString(u32 battler);
+static void LinkPartnerHandlePrintSelectionString(u32 battler);
+static void LinkPartnerHandleChooseAction(u32 battler);
+static void LinkPartnerHandleUnknownYesNoBox(u32 battler);
+static void LinkPartnerHandleChooseMove(u32 battler);
+static void LinkPartnerHandleChooseItem(u32 battler);
+static void LinkPartnerHandleChoosePokemon(u32 battler);
+static void LinkPartnerHandleCmd23(u32 battler);
+static void LinkPartnerHandleHealthBarUpdate(u32 battler);
+static void LinkPartnerHandleExpUpdate(u32 battler);
+static void LinkPartnerHandleStatusIconUpdate(u32 battler);
+static void LinkPartnerHandleStatusAnimation(u32 battler);
+static void LinkPartnerHandleStatusXor(u32 battler);
+static void LinkPartnerHandleDataTransfer(u32 battler);
+static void LinkPartnerHandleDMA3Transfer(u32 battler);
+static void LinkPartnerHandlePlayBGM(u32 battler);
+static void LinkPartnerHandleCmd32(u32 battler);
+static void LinkPartnerHandleTwoReturnValues(u32 battler);
+static void LinkPartnerHandleChosenMonReturnValue(u32 battler);
+static void LinkPartnerHandleOneReturnValue(u32 battler);
+static void LinkPartnerHandleOneReturnValue_Duplicate(u32 battler);
+static void LinkPartnerHandleClearUnkVar(u32 battler);
+static void LinkPartnerHandleSetUnkVar(u32 battler);
+static void LinkPartnerHandleClearUnkFlag(u32 battler);
+static void LinkPartnerHandleToggleUnkFlag(u32 battler);
+static void LinkPartnerHandleHitAnimation(u32 battler);
+static void LinkPartnerHandleCantSwitch(u32 battler);
+static void LinkPartnerHandlePlaySE(u32 battler);
+static void LinkPartnerHandlePlayFanfare(u32 battler);
+static void LinkPartnerHandleFaintingCry(u32 battler);
+static void LinkPartnerHandleIntroSlide(u32 battler);
+static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler);
+static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler);
+static void LinkPartnerHandleHidePartyStatusSummary(u32 battler);
+static void LinkPartnerHandleEndBounceEffect(u32 battler);
+static void LinkPartnerHandleSpriteInvisibility(u32 battler);
+static void LinkPartnerHandleBattleAnimation(u32 battler);
+static void LinkPartnerHandleLinkStandbyMsg(u32 battler);
+static void LinkPartnerHandleResetActionMoveSelection(u32 battler);
+static void LinkPartnerHandleEndLinkBattle(u32 battler);
+static void LinkPartnerCmdEnd(u32 battler);
 
-static void LinkPartnerBufferRunCommand(void);
-static void LinkPartnerBufferExecCompleted(void);
-static void SwitchIn_WaitAndEnd(void);
+static void LinkPartnerBufferRunCommand(u32 battler);
+static void LinkPartnerBufferExecCompleted(u32 battler);
+static void SwitchIn_WaitAndEnd(u32 battler);
 static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst);
 static void SetLinkPartnerMonData(u8 monId);
 static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
-static void DoSwitchOutAnimation(void);
-static void LinkPartnerDoMoveAnimation(void);
+static void DoSwitchOutAnimation(u32 battler);
+static void LinkPartnerDoMoveAnimation(u32 battler);
 static void Task_StartSendOutAnim(u8 taskId);
-static void EndDrawPartyStatusSummary(void);
+static void EndDrawPartyStatusSummary(u32 battler);
 
-static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = LinkPartnerHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = LinkPartnerHandleGetRawMonData,
@@ -144,53 +144,53 @@ static void (*const sLinkPartnerBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_TERMINATOR_NOP]           = LinkPartnerCmdEnd
 };
 
-static void LinkPartnerDummy(void)
+static void LinkPartnerDummy(u32 battler)
 {
 }
 
-void SetControllerToLinkPartner(void)
+void SetControllerToLinkPartner(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = LinkPartnerBufferRunCommand;
 }
 
-static void LinkPartnerBufferRunCommand(void)
+static void LinkPartnerBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < ARRAY_COUNT(sLinkPartnerBufferCommands))
-            sLinkPartnerBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            sLinkPartnerBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         else
-            LinkPartnerBufferExecCompleted();
+            LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
 }
 
-static void FreeTrainerSpriteAfterSlide(void)
+static void FreeTrainerSpriteAfterSlide(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
         BattleGfxSfxDummy3(MALE);
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void Intro_DelayAndEnd(void)
+static void Intro_DelayAndEnd(u32 battler)
 {
     if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0;
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void Intro_WaitForHealthbox(void)
+static void Intro_WaitForHealthbox(u32 battler)
 {
     bool32 finished = FALSE;
 
@@ -215,7 +215,7 @@ static void Intro_WaitForHealthbox(void)
     }
 }
 
-static void Intro_ShowHealthbox(void)
+static void Intro_ShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive
         && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].ballAnimActive
@@ -248,13 +248,13 @@ static void Intro_ShowHealthbox(void)
     }
 }
 
-static void WaitForMonAnimAfterLoad(void)
+static void WaitForMonAnimAfterLoad(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0)
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
     s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
 
@@ -267,39 +267,39 @@ static void CompleteOnHealthbarDone(void)
     else
     {
         HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void FreeMonSpriteAfterFaintAnim(void)
+static void FreeMonSpriteAfterFaintAnim(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].y + gSprites[gBattlerSpriteIds[gActiveBattler]].y2 > DISPLAY_HEIGHT)
     {
         FreeOamMatrix(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.matrixNum);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void FreeMonSpriteAfterSwitchOutAnim(void)
+static void FreeMonSpriteAfterSwitchOutAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(B_WIN_MSG))
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
     u8 spriteId = gBattlerSpriteIds[gActiveBattler];
 
@@ -308,7 +308,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
     else
     {
@@ -318,7 +318,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void SwitchIn_ShowSubstitute(void)
+static void SwitchIn_ShowSubstitute(u32 battler)
 {
     if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
@@ -329,15 +329,15 @@ static void SwitchIn_ShowSubstitute(void)
     }
 }
 
-static void SwitchIn_WaitAndEnd(void)
+static void SwitchIn_WaitAndEnd(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void SwitchIn_ShowHealthbox(void)
+static void SwitchIn_ShowHealthbox(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim)
     {
@@ -358,7 +358,7 @@ static void SwitchIn_ShowHealthbox(void)
     }
 }
 
-static void SwitchIn_TryShinyAnim(void)
+static void SwitchIn_TryShinyAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim
         && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
@@ -374,7 +374,7 @@ static void SwitchIn_TryShinyAnim(void)
     }
 }
 
-static void LinkPartnerBufferExecCompleted(void)
+static void LinkPartnerBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = LinkPartnerBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -390,19 +390,19 @@ static void LinkPartnerBufferExecCompleted(void)
     }
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleGetMonData(void)
+static void LinkPartnerHandleGetMonData(u32 battler)
 {
     u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data
     u32 size = 0;
@@ -424,7 +424,7 @@ static void LinkPartnerHandleGetMonData(void)
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
 static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst)
@@ -733,12 +733,12 @@ static u32 CopyLinkPartnerMonData(u8 monId, u8 *dst)
     return size;
 }
 
-static void LinkPartnerHandleGetRawMonData(void)
+static void LinkPartnerHandleGetRawMonData(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleSetMonData(void)
+static void LinkPartnerHandleSetMonData(u32 battler)
 {
     u8 monToCheck;
     u8 i;
@@ -757,7 +757,7 @@ static void LinkPartnerHandleSetMonData(void)
             monToCheck >>= 1;
         }
     }
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
 static void SetLinkPartnerMonData(u8 monId)
@@ -978,7 +978,7 @@ static void SetLinkPartnerMonData(u8 monId)
     HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
 }
 
-static void LinkPartnerHandleSetRawMonData(void)
+static void LinkPartnerHandleSetRawMonData(u32 battler)
 {
     u8 *dst = (u8 *)&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
     u8 i;
@@ -986,10 +986,10 @@ static void LinkPartnerHandleSetRawMonData(void)
     for (i = 0; i < gBattleBufferA[gActiveBattler][2]; i++)
         dst[i] = gBattleBufferA[gActiveBattler][3 + i];
 
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleLoadMonSprite(void)
+static void LinkPartnerHandleLoadMonSprite(u32 battler)
 {
     u16 species;
 
@@ -1008,7 +1008,7 @@ static void LinkPartnerHandleLoadMonSprite(void)
     gBattlerControllerFuncs[gActiveBattler] = WaitForMonAnimAfterLoad;
 }
 
-static void LinkPartnerHandleSwitchInAnim(void)
+static void LinkPartnerHandleSwitchInAnim(u32 battler)
 {
     ClearTemporarySpeciesSpriteData(gActiveBattler, gBattleBufferA[gActiveBattler][2]);
     gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1];
@@ -1046,7 +1046,7 @@ static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
     gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
 }
 
-static void LinkPartnerHandleReturnMonToBall(void)
+static void LinkPartnerHandleReturnMonToBall(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] == 0)
     {
@@ -1058,11 +1058,11 @@ static void LinkPartnerHandleReturnMonToBall(void)
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
     switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
     {
@@ -1085,7 +1085,7 @@ static void DoSwitchOutAnimation(void)
 
 #define sSpeedX data[0]
 
-static void LinkPartnerHandleDrawTrainerPic(void)
+static void LinkPartnerHandleDrawTrainerPic(u32 battler)
 {
     s16 xPos;
     u32 trainerPicId;
@@ -1120,12 +1120,12 @@ static void LinkPartnerHandleDrawTrainerPic(void)
 
 #undef sSpeedX
 
-static void LinkPartnerHandleTrainerSlide(void)
+static void LinkPartnerHandleTrainerSlide(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleTrainerSlideBack(void)
+static void LinkPartnerHandleTrainerSlideBack(u32 battler)
 {
     SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
     gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 35;
@@ -1139,7 +1139,7 @@ static void LinkPartnerHandleTrainerSlideBack(void)
 #define sSpeedX data[1]
 #define sSpeedY data[2]
 
-static void LinkPartnerHandleFaintAnimation(void)
+static void LinkPartnerHandleFaintAnimation(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0)
     {
@@ -1165,27 +1165,27 @@ static void LinkPartnerHandleFaintAnimation(void)
 #undef sSpeedX
 #undef sSpeedY
 
-static void LinkPartnerHandlePaletteFade(void)
+static void LinkPartnerHandlePaletteFade(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleSuccessBallThrowAnim(void)
+static void LinkPartnerHandleSuccessBallThrowAnim(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleBallThrowAnim(void)
+static void LinkPartnerHandleBallThrowAnim(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandlePause(void)
+static void LinkPartnerHandlePause(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleMoveAnimation(void)
+static void LinkPartnerHandleMoveAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1200,7 +1200,7 @@ static void LinkPartnerHandleMoveAnimation(void)
         gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
         if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE
         {
-            LinkPartnerBufferExecCompleted();
+            LinkPartnerBufferExecCompleted(battler);
         }
         else
         {
@@ -1210,7 +1210,7 @@ static void LinkPartnerHandleMoveAnimation(void)
     }
 }
 
-static void LinkPartnerDoMoveAnimation(void)
+static void LinkPartnerDoMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
     u8 multihit = gBattleBufferA[gActiveBattler][11];
@@ -1253,13 +1253,13 @@ static void LinkPartnerDoMoveAnimation(void)
             CopyAllBattleSpritesInvisibilities();
             TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            LinkPartnerBufferExecCompleted();
+            LinkPartnerBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void LinkPartnerHandlePrintString(void)
+static void LinkPartnerHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -1274,42 +1274,42 @@ static void LinkPartnerHandlePrintString(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
-static void LinkPartnerHandlePrintSelectionString(void)
+static void LinkPartnerHandlePrintSelectionString(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleChooseAction(void)
+static void LinkPartnerHandleChooseAction(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleUnknownYesNoBox(void)
+static void LinkPartnerHandleUnknownYesNoBox(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleChooseMove(void)
+static void LinkPartnerHandleChooseMove(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleChooseItem(void)
+static void LinkPartnerHandleChooseItem(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleChoosePokemon(void)
+static void LinkPartnerHandleChoosePokemon(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleCmd23(void)
+static void LinkPartnerHandleCmd23(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleHealthBarUpdate(void)
+static void LinkPartnerHandleHealthBarUpdate(u32 battler)
 {
     s16 hpVal;
 
@@ -1333,12 +1333,12 @@ static void LinkPartnerHandleHealthBarUpdate(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
 }
 
-static void LinkPartnerHandleExpUpdate(void)
+static void LinkPartnerHandleExpUpdate(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleStatusIconUpdate(void)
+static void LinkPartnerHandleStatusIconUpdate(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1351,7 +1351,7 @@ static void LinkPartnerHandleStatusIconUpdate(void)
     }
 }
 
-static void LinkPartnerHandleStatusAnimation(void)
+static void LinkPartnerHandleStatusAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1361,80 +1361,80 @@ static void LinkPartnerHandleStatusAnimation(void)
     }
 }
 
-static void LinkPartnerHandleStatusXor(void)
+static void LinkPartnerHandleStatusXor(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleDataTransfer(void)
+static void LinkPartnerHandleDataTransfer(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleDMA3Transfer(void)
+static void LinkPartnerHandleDMA3Transfer(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandlePlayBGM(void)
+static void LinkPartnerHandlePlayBGM(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleCmd32(void)
+static void LinkPartnerHandleCmd32(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleTwoReturnValues(void)
+static void LinkPartnerHandleTwoReturnValues(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleChosenMonReturnValue(void)
+static void LinkPartnerHandleChosenMonReturnValue(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleOneReturnValue(void)
+static void LinkPartnerHandleOneReturnValue(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleOneReturnValue_Duplicate(void)
+static void LinkPartnerHandleOneReturnValue_Duplicate(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleClearUnkVar(void)
+static void LinkPartnerHandleClearUnkVar(u32 battler)
 {
     gUnusedControllerStruct.unk = 0;
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleSetUnkVar(void)
+static void LinkPartnerHandleSetUnkVar(u32 battler)
 {
     gUnusedControllerStruct.unk = gBattleBufferA[gActiveBattler][1];
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleClearUnkFlag(void)
+static void LinkPartnerHandleClearUnkFlag(u32 battler)
 {
     gUnusedControllerStruct.flag = 0;
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleToggleUnkFlag(void)
+static void LinkPartnerHandleToggleUnkFlag(u32 battler)
 {
     gUnusedControllerStruct.flag ^= 1;
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleHitAnimation(void)
+static void LinkPartnerHandleHitAnimation(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
     {
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
     else
     {
@@ -1445,12 +1445,12 @@ static void LinkPartnerHandleHitAnimation(void)
     }
 }
 
-static void LinkPartnerHandleCantSwitch(void)
+static void LinkPartnerHandleCantSwitch(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandlePlaySE(void)
+static void LinkPartnerHandlePlaySE(u32 battler)
 {
     s8 pan;
 
@@ -1460,31 +1460,31 @@ static void LinkPartnerHandlePlaySE(void)
         pan = SOUND_PAN_TARGET;
 
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandlePlayFanfare(void)
+static void LinkPartnerHandlePlayFanfare(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleFaintingCry(void)
+static void LinkPartnerHandleFaintingCry(u32 battler)
 {
     u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry_ByMode(species, -25, CRY_MODE_FAINT);
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleIntroSlide(void)
+static void LinkPartnerHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleIntroTrainerBallThrow(void)
+static void LinkPartnerHandleIntroTrainerBallThrow(u32 battler)
 {
     u8 paletteNum;
     u8 taskId;
@@ -1559,11 +1559,11 @@ static void Task_StartSendOutAnim(u8 taskId)
     }
 }
 
-static void LinkPartnerHandleDrawPartyStatusSummary(void)
+static void LinkPartnerHandleDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] != 0 && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
     else
     {
@@ -1578,38 +1578,38 @@ static void LinkPartnerHandleDrawPartyStatusSummary(void)
     }
 }
 
-static void EndDrawPartyStatusSummary(void)
+static void EndDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer++ > 92)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0;
-        LinkPartnerBufferExecCompleted();
+        LinkPartnerBufferExecCompleted(battler);
     }
 }
 
-static void LinkPartnerHandleHidePartyStatusSummary(void)
+static void LinkPartnerHandleHidePartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
         gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleEndBounceEffect(void)
+static void LinkPartnerHandleEndBounceEffect(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleSpriteInvisibility(void)
+static void LinkPartnerHandleSpriteInvisibility(u32 battler)
 {
     if (IsBattlerSpritePresent(gActiveBattler))
     {
         gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleBufferA[gActiveBattler][1];
         CopyBattleSpriteInvisibility(gActiveBattler);
     }
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleBattleAnimation(void)
+static void LinkPartnerHandleBattleAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1617,31 +1617,31 @@ static void LinkPartnerHandleBattleAnimation(void)
         u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
         if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-            LinkPartnerBufferExecCompleted();
+            LinkPartnerBufferExecCompleted(battler);
         else
             gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
     }
 }
 
-static void LinkPartnerHandleLinkStandbyMsg(void)
+static void LinkPartnerHandleLinkStandbyMsg(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleResetActionMoveSelection(void)
+static void LinkPartnerHandleResetActionMoveSelection(u32 battler)
 {
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
 }
 
-static void LinkPartnerHandleEndLinkBattle(void)
+static void LinkPartnerHandleEndLinkBattle(u32 battler)
 {
     gBattleOutcome = gBattleBufferA[gActiveBattler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
-    LinkPartnerBufferExecCompleted();
+    LinkPartnerBufferExecCompleted(battler);
     gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks;
 }
 
-static void LinkPartnerCmdEnd(void)
+static void LinkPartnerCmdEnd(u32 battler)
 {
 }
diff --git a/src/battle_controller_oak_old_man.c b/src/battle_controller_oak_old_man.c
index 25475af35..0af676512 100644
--- a/src/battle_controller_oak_old_man.c
+++ b/src/battle_controller_oak_old_man.c
@@ -18,85 +18,85 @@
 #include "constants/songs.h"
 #include "constants/items.h"
 
-static void OakOldManHandleGetMonData(void);
-static void OakOldManHandleGetRawMonData(void);
-static void OakOldManHandleSetMonData(void);
-static void OakOldManHandleSetRawMonData(void);
-static void OakOldManHandleLoadMonSprite(void);
-static void OakOldManHandleSwitchInAnim(void);
-static void OakOldManHandleReturnMonToBall(void);
-static void OakOldManHandleDrawTrainerPic(void);
-static void OakOldManHandleTrainerSlide(void);
-static void OakOldManHandleTrainerSlideBack(void);
-static void OakOldManHandleFaintAnimation(void);
-static void OakOldManHandlePaletteFade(void);
-static void OakOldManHandleSuccessBallThrowAnim(void);
-static void OakOldManHandleBallThrowAnim(void);
-static void OakOldManHandlePause(void);
-static void OakOldManHandleMoveAnimation(void);
-static void OakOldManHandlePrintString(void);
-static void OakOldManHandlePrintSelectionString(void);
-static void OakOldManHandleChooseAction(void);
-static void OakOldManHandleUnknownYesNoBox(void);
-static void OakOldManHandleChooseMove(void);
-static void OakOldManHandleChooseItem(void);
-static void OakOldManHandleChoosePokemon(void);
-static void OakOldManHandleCmd23(void);
-static void OakOldManHandleHealthBarUpdate(void);
-static void OakOldManHandleExpUpdate(void);
-static void OakOldManHandleStatusIconUpdate(void);
-static void OakOldManHandleStatusAnimation(void);
-static void OakOldManHandleStatusXor(void);
-static void OakOldManHandleDataTransfer(void);
-static void OakOldManHandleDMA3Transfer(void);
-static void OakOldManHandlePlayBGM(void);
-static void OakOldManHandleCmd32(void);
-static void OakOldManHandleTwoReturnValues(void);
-static void OakOldManHandleChosenMonReturnValue(void);
-static void OakOldManHandleOneReturnValue(void);
-static void OakOldManHandleOneReturnValue_Duplicate(void);
-static void OakOldManHandleCmd37(void);
-static void OakOldManHandleCmd38(void);
-static void OakOldManHandleCmd39(void);
-static void OakOldManHandleCmd40(void);
-static void OakOldManHandleHitAnimation(void);
-static void OakOldManHandleCmd42(void);
-static void OakOldManHandlePlaySE(void);
-static void OakOldManHandlePlayFanfare(void);
-static void OakOldManHandleFaintingCry(void);
-static void OakOldManHandleIntroSlide(void);
-static void OakOldManHandleIntroTrainerBallThrow(void);
-static void OakOldManHandleDrawPartyStatusSummary(void);
-static void OakOldManHandleHidePartyStatusSummary(void);
-static void OakOldManHandleEndBounceEffect(void);
-static void OakOldManHandleSpriteInvisibility(void);
-static void OakOldManHandleBattleAnimation(void);
-static void OakOldManHandleLinkStandbyMsg(void);
-static void OakOldManHandleResetActionMoveSelection(void);
-static void OakOldManHandleCmd55(void);
-static void OakOldManCmdEnd(void);
+static void OakOldManHandleGetMonData(u32 battler);
+static void OakOldManHandleGetRawMonData(u32 battler);
+static void OakOldManHandleSetMonData(u32 battler);
+static void OakOldManHandleSetRawMonData(u32 battler);
+static void OakOldManHandleLoadMonSprite(u32 battler);
+static void OakOldManHandleSwitchInAnim(u32 battler);
+static void OakOldManHandleReturnMonToBall(u32 battler);
+static void OakOldManHandleDrawTrainerPic(u32 battler);
+static void OakOldManHandleTrainerSlide(u32 battler);
+static void OakOldManHandleTrainerSlideBack(u32 battler);
+static void OakOldManHandleFaintAnimation(u32 battler);
+static void OakOldManHandlePaletteFade(u32 battler);
+static void OakOldManHandleSuccessBallThrowAnim(u32 battler);
+static void OakOldManHandleBallThrowAnim(u32 battler);
+static void OakOldManHandlePause(u32 battler);
+static void OakOldManHandleMoveAnimation(u32 battler);
+static void OakOldManHandlePrintString(u32 battler);
+static void OakOldManHandlePrintSelectionString(u32 battler);
+static void OakOldManHandleChooseAction(u32 battler);
+static void OakOldManHandleUnknownYesNoBox(u32 battler);
+static void OakOldManHandleChooseMove(u32 battler);
+static void OakOldManHandleChooseItem(u32 battler);
+static void OakOldManHandleChoosePokemon(u32 battler);
+static void OakOldManHandleCmd23(u32 battler);
+static void OakOldManHandleHealthBarUpdate(u32 battler);
+static void OakOldManHandleExpUpdate(u32 battler);
+static void OakOldManHandleStatusIconUpdate(u32 battler);
+static void OakOldManHandleStatusAnimation(u32 battler);
+static void OakOldManHandleStatusXor(u32 battler);
+static void OakOldManHandleDataTransfer(u32 battler);
+static void OakOldManHandleDMA3Transfer(u32 battler);
+static void OakOldManHandlePlayBGM(u32 battler);
+static void OakOldManHandleCmd32(u32 battler);
+static void OakOldManHandleTwoReturnValues(u32 battler);
+static void OakOldManHandleChosenMonReturnValue(u32 battler);
+static void OakOldManHandleOneReturnValue(u32 battler);
+static void OakOldManHandleOneReturnValue_Duplicate(u32 battler);
+static void OakOldManHandleCmd37(u32 battler);
+static void OakOldManHandleCmd38(u32 battler);
+static void OakOldManHandleCmd39(u32 battler);
+static void OakOldManHandleCmd40(u32 battler);
+static void OakOldManHandleHitAnimation(u32 battler);
+static void OakOldManHandleCmd42(u32 battler);
+static void OakOldManHandlePlaySE(u32 battler);
+static void OakOldManHandlePlayFanfare(u32 battler);
+static void OakOldManHandleFaintingCry(u32 battler);
+static void OakOldManHandleIntroSlide(u32 battler);
+static void OakOldManHandleIntroTrainerBallThrow(u32 battler);
+static void OakOldManHandleDrawPartyStatusSummary(u32 battler);
+static void OakOldManHandleHidePartyStatusSummary(u32 battler);
+static void OakOldManHandleEndBounceEffect(u32 battler);
+static void OakOldManHandleSpriteInvisibility(u32 battler);
+static void OakOldManHandleBattleAnimation(u32 battler);
+static void OakOldManHandleLinkStandbyMsg(u32 battler);
+static void OakOldManHandleResetActionMoveSelection(u32 battler);
+static void OakOldManHandleCmd55(u32 battler);
+static void OakOldManCmdEnd(u32 battler);
 
-static void OakOldManBufferRunCommand(void);
-static void OakOldManBufferExecCompleted(void);
-static void WaitForMonSelection(void);
-static void CompleteWhenChoseItem(void);
-static void PrintOakText_KeepAnEyeOnHP(void);
-static void Intro_WaitForShinyAnimAndHealthbox(void);
-static void PrintOakText_ForPetesSake(void);
+static void OakOldManBufferRunCommand(u32 battler);
+static void OakOldManBufferExecCompleted(u32 battler);
+static void WaitForMonSelection(u32 battler);
+static void CompleteWhenChoseItem(u32 battler);
+static void PrintOakText_KeepAnEyeOnHP(u32 battler);
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler);
+static void PrintOakText_ForPetesSake(u32 battler);
 static void Task_LaunchLvlUpAnim(u8 taskId);
 static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId);
-static void CompleteOnInactiveTextPrinter2(void);
+static void CompleteOnInactiveTextPrinter2(u32 battler);
 static void Task_PrepareToGiveExpWithExpBar(u8 taskId);
 static void Task_GiveExpWithExpBar(u8 taskId);
 static void Task_UpdateLvlInHealthbox(u8 taskId);
-static void PrintOakTextWithMainBgDarkened(const u8 *text, u8 delay);
+static void PrintOakTextWithMainBgDarkened(u32 battler, const u8 *text, u8 delay);
 static u32 CopyOakOldManMonData(u8 monId, u8 *dst);
 static void SetOakOldManMonData(u8 monId);
-static void OakOldManDoMoveAnimation(void);
-static void HandleInputChooseAction(void);
+static void OakOldManDoMoveAnimation(u32 battler);
+static void HandleInputChooseAction(u32 battler);
 static void Task_StartSendOutAnim(u8 taskId);
 
-static void (*const sOakOldManBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sOakOldManBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = OakOldManHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = OakOldManHandleGetRawMonData,
@@ -142,7 +142,7 @@ static void (*const sOakOldManBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_HITANIMATION]             = OakOldManHandleHitAnimation,
     [CONTROLLER_CANTSWITCH]               = OakOldManHandleCmd42,
     [CONTROLLER_PLAYSE]                   = OakOldManHandlePlaySE,
-    [CONTROLLER_PLAYFANFAREORBGM]              = OakOldManHandlePlayFanfare,
+    [CONTROLLER_PLAYFANFAREORBGM]         = OakOldManHandlePlayFanfare,
     [CONTROLLER_FAINTINGCRY]              = OakOldManHandleFaintingCry,
     [CONTROLLER_INTROSLIDE]               = OakOldManHandleIntroSlide,
     [CONTROLLER_INTROTRAINERBALLTHROW]    = OakOldManHandleIntroTrainerBallThrow,
@@ -157,11 +157,11 @@ static void (*const sOakOldManBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_TERMINATOR_NOP]           = OakOldManCmdEnd,
 };
 
-static void OakOldManDummy(void)
+static void OakOldManDummy(u32 battler)
 {
 }
 
-void SetControllerToOakOrOldMan(void)
+void SetControllerToOakOrOldMan(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = OakOldManBufferRunCommand;
     gBattleStruct->simulatedInputState[0] = 0;
@@ -170,18 +170,18 @@ void SetControllerToOakOrOldMan(void)
     gBattleStruct->simulatedInputState[3] = 0;
 }
 
-static void OakOldManBufferRunCommand(void)
+static void OakOldManBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < NELEMS(sOakOldManBufferCommands))
-            sOakOldManBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            sOakOldManBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         else
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void HandleInputChooseAction(void)
+static void HandleInputChooseAction(u32 battler)
 {
     // Like player, but specifically for Rival in Oak's Lab
     u16 itemId = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
@@ -207,7 +207,7 @@ static void HandleInputChooseAction(void)
             BtlController_EmitTwoReturnValues(1, B_ACTION_RUN, 0);
             break;
         }
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else if (JOY_NEW(DPAD_LEFT))
     {
@@ -266,7 +266,7 @@ static void HandleInputChooseAction(void)
             }
             PlaySE(SE_SELECT);
             BtlController_EmitTwoReturnValues(1, B_ACTION_CANCEL_PARTNER, 0);
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
         }
     }
     else if (JOY_NEW(START_BUTTON))
@@ -275,7 +275,7 @@ static void HandleInputChooseAction(void)
     }
 }
 
-static void SimulateInputChooseAction(void)
+static void SimulateInputChooseAction(u32 battler)
 {
     // Old Man
     switch (gBattleStruct->simulatedInputState[0])
@@ -301,25 +301,25 @@ static void SimulateInputChooseAction(void)
             // Open bag
             PlaySE(SE_SELECT);
             BtlController_EmitTwoReturnValues(1, B_ACTION_USE_ITEM, 0);
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManSetBattleEndCallbacks(void)
+static void OakOldManSetBattleEndCallbacks(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -329,20 +329,20 @@ static void OakOldManSetBattleEndCallbacks(void)
     }
 }
 
-static void CompleteOnSpecialAnimDone(void)
+static void CompleteOnSpecialAnimDone(u32 battler)
 {
     if (!gDoingBattleAnim)
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-void OakOldManHandleInputChooseMove(void)
+void OakOldManHandleInputChooseMove(u32 battler)
 {
-    HandleInputChooseMove();
+    HandleInputChooseMove(battler);
     if (!(gBattleControllerExecFlags & gBitTable[gActiveBattler]))
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void OpenPartyMenuToChooseMon(void)
+static void OpenPartyMenuToChooseMon(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -356,7 +356,7 @@ static void OpenPartyMenuToChooseMon(void)
     }
 }
 
-static void WaitForMonSelection(void)
+static void WaitForMonSelection(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
@@ -364,11 +364,11 @@ static void WaitForMonSelection(void)
             BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder);
         else
             BtlController_EmitChosenMonReturnValue(1, 6, NULL);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void OpenBagAndChooseItem(void)
+static void OpenBagAndChooseItem(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -382,7 +382,7 @@ static void OpenBagAndChooseItem(void)
     }
 }
 
-static void CompleteWhenChoseItem(void)
+static void CompleteWhenChoseItem(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
@@ -396,12 +396,12 @@ static void CompleteWhenChoseItem(void)
         else
         {
             BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
         }
     }
 }
 
-static void Intro_TryShinyAnimShowHealthbox(void)
+static void Intro_TryShinyAnimShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim
      && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
@@ -431,7 +431,7 @@ static void Intro_TryShinyAnimShowHealthbox(void)
     }
 }
 
-static void Intro_WaitForShinyAnimAndHealthbox(void)
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler)
 {
     bool32 r4 = FALSE;
 
@@ -612,18 +612,18 @@ static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId)
     DestroyTask(taskId);
 }
 
-static void FreeMonSpriteAfterFaintAnim(void)
+static void FreeMonSpriteAfterFaintAnim(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].y + gSprites[gBattlerSpriteIds[gActiveBattler]].y2 > DISPLAY_HEIGHT)
     {
         FreeOamMatrix(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.matrixNum);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void PrintOakText_ForPetesSake(void)
+static void PrintOakText_ForPetesSake(u32 battler)
 {
     u32 mask;
 
@@ -710,38 +710,38 @@ static void PrintOakText_ForPetesSake(void)
             DoFreeHealthboxPalsForLevelUp(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT));
             BtlCtrl_RemoveVoiceoverMessageFrame();
             gBattleStruct->simulatedInputState[0] = 0;
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-void PrintOakText_InflictingDamageIsKey(void)
+void PrintOakText_InflictingDamageIsKey(u32 battler)
 {
-    PrintOakTextWithMainBgDarkened(gText_InflictingDamageIsKey, 1);
+    PrintOakTextWithMainBgDarkened(battler, gText_InflictingDamageIsKey, 1);
 }
 
-static void PrintOakText_LoweringStats(void)
+static void PrintOakText_LoweringStats(u32 battler)
 {
-    PrintOakTextWithMainBgDarkened(gText_LoweringStats, 64);
+    PrintOakTextWithMainBgDarkened(battler, gText_LoweringStats, 64);
 }
 
-void PrintOakText_OakNoRunningFromATrainer(void)
+void PrintOakText_OakNoRunningFromATrainer(u32 battler)
 {
-    PrintOakTextWithMainBgDarkened(gText_OakNoRunningFromATrainer, 1);
+    PrintOakTextWithMainBgDarkened(battler, gText_OakNoRunningFromATrainer, 1);
 }
 
-static void PrintOakText_WinEarnsPrizeMoney(void)
+static void PrintOakText_WinEarnsPrizeMoney(u32 battler)
 {
-    PrintOakTextWithMainBgDarkened(gText_WinEarnsPrizeMoney, 64);
+    PrintOakTextWithMainBgDarkened(battler, gText_WinEarnsPrizeMoney, 64);
 }
 
-void PrintOakText_HowDisappointing(void)
+void PrintOakText_HowDisappointing(u32 battler)
 {
-    PrintOakTextWithMainBgDarkened(gText_HowDissapointing, 64);
+    PrintOakTextWithMainBgDarkened(battler, gText_HowDissapointing, 64);
 }
 
-static void PrintOakTextWithMainBgDarkened(const u8 *text, u8 delay)
+static void PrintOakTextWithMainBgDarkened(u32 battler, const u8 *text, u8 delay)
 {
     // If delay is 0, it's treated as 256.
     switch (gBattleStruct->simulatedInputState[0])
@@ -792,9 +792,9 @@ static void PrintOakTextWithMainBgDarkened(const u8 *text, u8 delay)
         {
             BtlCtrl_RemoveVoiceoverMessageFrame();
             if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-                OakOldManBufferExecCompleted();
+                OakOldManBufferExecCompleted(battler);
             else
-                OpponentBufferExecCompleted();
+                OpponentBufferExecCompleted(battler);
             gBattleCommunication[MSG_DISPLAY] = 0;
             gBattleStruct->simulatedInputState[0] = 0;
         }
@@ -802,7 +802,7 @@ static void PrintOakTextWithMainBgDarkened(const u8 *text, u8 delay)
     }
 }
 
-static void PrintOakText_KeepAnEyeOnHP(void)
+static void PrintOakText_KeepAnEyeOnHP(u32 battler)
 {
     u32 mask;
 
@@ -872,14 +872,14 @@ static void PrintOakText_KeepAnEyeOnHP(void)
         {
             BtlCtrl_RemoveVoiceoverMessageFrame();
             BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
             gBattleStruct->simulatedInputState[0] = 0;
         }
         break;
     }
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
     s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
 
@@ -891,17 +891,17 @@ static void CompleteOnHealthbarDone(void)
     else
     {
         HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter2(void)
+static void CompleteOnInactiveTextPrinter2(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
     u8 spriteId = gBattlerSpriteIds[gActiveBattler];
 
@@ -910,7 +910,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -920,30 +920,30 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy2(void)
+static void CompleteOnBattlerSpriteCallbackDummy2(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManBufferExecCompleted(void)
+static void OakOldManBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = OakOldManBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -959,13 +959,13 @@ static void OakOldManBufferExecCompleted(void)
     }
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleGetMonData(void)
+static void OakOldManHandleGetMonData(u32 battler)
 {
     u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data
     u32 size = 0;
@@ -987,7 +987,7 @@ static void OakOldManHandleGetMonData(void)
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
 static u32 CopyOakOldManMonData(u8 monId, u8 *dst)
@@ -1295,12 +1295,12 @@ static u32 CopyOakOldManMonData(u8 monId, u8 *dst)
     return size;
 }
 
-static void OakOldManHandleGetRawMonData(void)
+static void OakOldManHandleGetRawMonData(u32 battler)
 {
     PlayerHandleGetRawMonData(gActiveBattler);
 }
 
-static void OakOldManHandleSetMonData(void)
+static void OakOldManHandleSetMonData(u32 battler)
 {
     u8 monToCheck;
     u8 i;
@@ -1319,7 +1319,7 @@ static void OakOldManHandleSetMonData(void)
             monToCheck >>= 1;
         }
     }
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
 static void SetOakOldManMonData(u8 monId)
@@ -1539,22 +1539,22 @@ static void SetOakOldManMonData(u8 monId)
     HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
 }
 
-static void OakOldManHandleSetRawMonData(void)
+static void OakOldManHandleSetRawMonData(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleLoadMonSprite(void)
+static void OakOldManHandleLoadMonSprite(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleSwitchInAnim(void)
+static void OakOldManHandleSwitchInAnim(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleReturnMonToBall(void)
+static void OakOldManHandleReturnMonToBall(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] == 0)
     {
@@ -1566,11 +1566,11 @@ static void OakOldManHandleReturnMonToBall(void)
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void OakOldManHandleDrawTrainerPic(void)
+static void OakOldManHandleDrawTrainerPic(u32 battler)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
     {
@@ -1597,7 +1597,7 @@ static void OakOldManHandleDrawTrainerPic(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
-static void OakOldManHandleTrainerSlide(void)
+static void OakOldManHandleTrainerSlide(u32 battler)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
     {
@@ -1624,12 +1624,12 @@ static void OakOldManHandleTrainerSlide(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy2;
 }
 
-static void OakOldManHandleTrainerSlideBack(void)
+static void OakOldManHandleTrainerSlideBack(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleFaintAnimation(void)
+static void OakOldManHandleFaintAnimation(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0)
     {
@@ -1652,12 +1652,12 @@ static void OakOldManHandleFaintAnimation(void)
     }
 }
 
-static void OakOldManHandlePaletteFade(void)
+static void OakOldManHandlePaletteFade(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleSuccessBallThrowAnim(void)
+static void OakOldManHandleSuccessBallThrowAnim(u32 battler)
 {
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS;
     gDoingBattleAnim = TRUE;
@@ -1665,7 +1665,7 @@ static void OakOldManHandleSuccessBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void OakOldManHandleBallThrowAnim(void)
+static void OakOldManHandleBallThrowAnim(u32 battler)
 {
     u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1];
 
@@ -1675,12 +1675,12 @@ static void OakOldManHandleBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void OakOldManHandlePause(void)
+static void OakOldManHandlePause(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleMoveAnimation(void)
+static void OakOldManHandleMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
 
@@ -1693,7 +1693,7 @@ static void OakOldManHandleMoveAnimation(void)
     gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
     if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE
     {
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -1702,7 +1702,7 @@ static void OakOldManHandleMoveAnimation(void)
     }
 }
 
-static void OakOldManDoMoveAnimation(void)
+static void OakOldManDoMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
 
@@ -1737,13 +1737,13 @@ static void OakOldManDoMoveAnimation(void)
             CopyAllBattleSpritesInvisibilities();
             TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            OakOldManBufferExecCompleted();
+            OakOldManBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void OakOldManHandlePrintString(void)
+static void OakOldManHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -1752,7 +1752,7 @@ static void OakOldManHandlePrintString(void)
     stringId = (u16 *)(&gBattleBufferA[gActiveBattler][2]);
     if (gBattleTypeFlags & BATTLE_TYPE_OLD_MAN_TUTORIAL && *stringId == 1)
     {
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -1788,15 +1788,15 @@ static void OakOldManHandlePrintString(void)
     }
 }
 
-static void OakOldManHandlePrintSelectionString(void)
+static void OakOldManHandlePrintSelectionString(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        OakOldManHandlePrintString();
+        OakOldManHandlePrintString(battler);
     else
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
 }
 
-static void HandleChooseActionAfterDma3(void)
+static void HandleChooseActionAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -1809,7 +1809,7 @@ static void HandleChooseActionAfterDma3(void)
     }
 }
 
-static void OakOldManHandleChooseAction(void)
+static void OakOldManHandleChooseAction(u32 battler)
 {
     s32 i;
 
@@ -1826,12 +1826,12 @@ static void OakOldManHandleChooseAction(void)
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT);
 }
 
-static void OakOldManHandleUnknownYesNoBox(void)
+static void OakOldManHandleUnknownYesNoBox(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakHandleChooseMove_WaitDma3(void)
+static void OakHandleChooseMove_WaitDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -1841,11 +1841,11 @@ static void OakHandleChooseMove_WaitDma3(void)
     }
 }
 
-static void OakOldManHandleChooseMove(void)
+static void OakOldManHandleChooseMove(u32 battler)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
     {
-        InitMoveSelectionsVarsAndStrings();
+        InitMoveSelectionsVarsAndStrings(battler);
         gBattlerControllerFuncs[gActiveBattler] = OakHandleChooseMove_WaitDma3;
     }
     else
@@ -1853,7 +1853,7 @@ static void OakOldManHandleChooseMove(void)
         switch (gBattleStruct->simulatedInputState[1])
         {
         case 0:
-            InitMoveSelectionsVarsAndStrings();
+            InitMoveSelectionsVarsAndStrings(battler);
             ++gBattleStruct->simulatedInputState[1];
             gBattleStruct->simulatedInputState[3] = 80;
             // fall through
@@ -1862,14 +1862,14 @@ static void OakOldManHandleChooseMove(void)
             {
                 PlaySE(SE_SELECT);
                 BtlController_EmitTwoReturnValues(1, 10, 0x100);
-                OakOldManBufferExecCompleted();
+                OakOldManBufferExecCompleted(battler);
             }
             break;
         }
     }
 }
 
-static void OakOldManHandleChooseItem(void)
+static void OakOldManHandleChooseItem(u32 battler)
 {
     s32 i;
 
@@ -1880,7 +1880,7 @@ static void OakOldManHandleChooseItem(void)
         gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][i + 1];
 }
 
-static void OakOldManHandleChoosePokemon(void)
+static void OakOldManHandleChoosePokemon(u32 battler)
 {
     s32 i;
 
@@ -1896,12 +1896,12 @@ static void OakOldManHandleChoosePokemon(void)
     gBattlerInMenuId = gActiveBattler;
 }
 
-static void OakOldManHandleCmd23(void)
+static void OakOldManHandleCmd23(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleHealthBarUpdate(void)
+static void OakOldManHandleHealthBarUpdate(u32 battler)
 {
     s16 hpVal;
 
@@ -1924,13 +1924,13 @@ static void OakOldManHandleHealthBarUpdate(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
 }
 
-static void OakOldManHandleExpUpdate(void)
+static void OakOldManHandleExpUpdate(u32 battler)
 {
     u8 monId = gBattleBufferA[gActiveBattler][1];
 
     if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL)
     {
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -1948,86 +1948,86 @@ static void OakOldManHandleExpUpdate(void)
     }
 }
 
-static void OakOldManHandleStatusIconUpdate(void)
+static void OakOldManHandleStatusIconUpdate(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleStatusAnimation(void)
+static void OakOldManHandleStatusAnimation(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleStatusXor(void)
+static void OakOldManHandleStatusXor(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleDataTransfer(void)
+static void OakOldManHandleDataTransfer(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleDMA3Transfer(void)
+static void OakOldManHandleDMA3Transfer(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandlePlayBGM(void)
+static void OakOldManHandlePlayBGM(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd32(void)
+static void OakOldManHandleCmd32(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleTwoReturnValues(void)
+static void OakOldManHandleTwoReturnValues(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleChosenMonReturnValue(void)
+static void OakOldManHandleChosenMonReturnValue(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleOneReturnValue(void)
+static void OakOldManHandleOneReturnValue(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleOneReturnValue_Duplicate(void)
+static void OakOldManHandleOneReturnValue_Duplicate(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd37(void)
+static void OakOldManHandleCmd37(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd38(void)
+static void OakOldManHandleCmd38(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd39(void)
+static void OakOldManHandleCmd39(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd40(void)
+static void OakOldManHandleCmd40(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleHitAnimation(void)
+static void OakOldManHandleHitAnimation(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
     {
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -2038,39 +2038,39 @@ static void OakOldManHandleHitAnimation(void)
     }
 }
 
-static void OakOldManHandleCmd42(void)
+static void OakOldManHandleCmd42(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandlePlaySE(void)
+static void OakOldManHandlePlaySE(u32 battler)
 {
     PlaySE(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandlePlayFanfare(void)
+static void OakOldManHandlePlayFanfare(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleFaintingCry(void)
+static void OakOldManHandleFaintingCry(u32 battler)
 {
     u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry_Normal(species, 25);
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleIntroSlide(void)
+static void OakOldManHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleIntroTrainerBallThrow(void)
+static void OakOldManHandleIntroTrainerBallThrow(u32 battler)
 {
     u8 paletteNum;
     u8 taskId;
@@ -2099,7 +2099,7 @@ static void OakOldManHandleIntroTrainerBallThrow(void)
     {
         if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
             gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
@@ -2145,12 +2145,12 @@ static void Task_StartSendOutAnim(u8 taskId)
     }
 }
 
-static void OakOldManHandleDrawPartyStatusSummary(void)
+static void OakOldManHandleDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] != 0
      && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
     else
     {
@@ -2159,39 +2159,39 @@ static void OakOldManHandleDrawPartyStatusSummary(void)
                                                                                       (struct HpAndStatus *)&gBattleBufferA[gActiveBattler][4],
                                                                                       gBattleBufferA[gActiveBattler][1],
                                                                                       gBattleBufferA[gActiveBattler][2]);
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     }
 }
 
-static void OakOldManHandleHidePartyStatusSummary(void)
+static void OakOldManHandleHidePartyStatusSummary(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleEndBounceEffect(void)
+static void OakOldManHandleEndBounceEffect(u32 battler)
 {
     EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX);
     EndBounceEffect(gActiveBattler, BOUNCE_MON);
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleSpriteInvisibility(void)
+static void OakOldManHandleSpriteInvisibility(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleBattleAnimation(void)
+static void OakOldManHandleBattleAnimation(u32 battler)
 {
     u8 animationId = gBattleBufferA[gActiveBattler][1];
     u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
     if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-        OakOldManBufferExecCompleted();
+        OakOldManBufferExecCompleted(battler);
     else
         gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
 }
 
-static void OakOldManHandleLinkStandbyMsg(void)
+static void OakOldManHandleLinkStandbyMsg(u32 battler)
 {
     switch (gBattleBufferA[gActiveBattler][1])
     {
@@ -2203,25 +2203,25 @@ static void OakOldManHandleLinkStandbyMsg(void)
     case 2:
         break;
     }
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleResetActionMoveSelection(void)
+static void OakOldManHandleResetActionMoveSelection(u32 battler)
 {
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
 }
 
-static void OakOldManHandleCmd55(void)
+static void OakOldManHandleCmd55(u32 battler)
 {
     gBattleOutcome = gBattleBufferA[gActiveBattler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
-    OakOldManBufferExecCompleted();
+    OakOldManBufferExecCompleted(battler);
     if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER) && gBattleTypeFlags & BATTLE_TYPE_LINK)
         gBattlerControllerFuncs[gActiveBattler] = OakOldManSetBattleEndCallbacks;
 }
 
-static void OakOldManCmdEnd(void)
+static void OakOldManCmdEnd(u32 battler)
 {
 }
 
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
index 2c889e9d9..e6599ddbf 100644
--- a/src/battle_controller_opponent.c
+++ b/src/battle_controller_opponent.c
@@ -21,76 +21,76 @@
 #include "constants/songs.h"
 #include "constants/sound.h"
 
-static void OpponentHandleGetMonData(void);
-static void OpponentHandleGetRawMonData(void);
-static void OpponentHandleSetMonData(void);
-static void OpponentHandleSetRawMonData(void);
-static void OpponentHandleLoadMonSprite(void);
-static void OpponentHandleSwitchInAnim(void);
-static void OpponentHandleReturnMonToBall(void);
-static void OpponentHandleDrawTrainerPic(void);
-static void OpponentHandleTrainerSlide(void);
-static void OpponentHandleTrainerSlideBack(void);
-static void OpponentHandleFaintAnimation(void);
-static void OpponentHandlePaletteFade(void);
-static void OpponentHandleSuccessBallThrowAnim(void);
-static void OpponentHandleBallThrowAnim(void);
-static void OpponentHandlePause(void);
-static void OpponentHandleMoveAnimation(void);
-static void OpponentHandlePrintString(void);
-static void OpponentHandlePrintSelectionString(void);
-static void OpponentHandleChooseAction(void);
-static void OpponentHandleUnknownYesNoBox(void);
-static void OpponentHandleChooseMove(void);
-static void OpponentHandleChooseItem(void);
-static void OpponentHandleChoosePokemon(void);
-static void OpponentHandleCmd23(void);
-static void OpponentHandleHealthBarUpdate(void);
-static void OpponentHandleExpUpdate(void);
-static void OpponentHandleStatusIconUpdate(void);
-static void OpponentHandleStatusAnimation(void);
-static void OpponentHandleStatusXor(void);
-static void OpponentHandleDataTransfer(void);
-static void OpponentHandleDMA3Transfer(void);
-static void OpponentHandlePlayBGM(void);
-static void OpponentHandleCmd32(void);
-static void OpponentHandleTwoReturnValues(void);
-static void OpponentHandleChosenMonReturnValue(void);
-static void OpponentHandleOneReturnValue(void);
-static void OpponentHandleOneReturnValue_Duplicate(void);
-static void OpponentHandleCmd37(void);
-static void OpponentHandleCmd38(void);
-static void OpponentHandleCmd39(void);
-static void OpponentHandleCmd40(void);
-static void OpponentHandleHitAnimation(void);
-static void OpponentHandleCmd42(void);
-static void OpponentHandlePlaySE(void);
-static void OpponentHandlePlayFanfare(void);
-static void OpponentHandleFaintingCry(void);
-static void OpponentHandleIntroSlide(void);
-static void OpponentHandleIntroTrainerBallThrow(void);
-static void OpponentHandleDrawPartyStatusSummary(void);
-static void OpponentHandleHidePartyStatusSummary(void);
-static void OpponentHandleEndBounceEffect(void);
-static void OpponentHandleSpriteInvisibility(void);
-static void OpponentHandleBattleAnimation(void);
-static void OpponentHandleLinkStandbyMsg(void);
-static void OpponentHandleResetActionMoveSelection(void);
-static void OpponentHandleCmd55(void);
-static void OpponentCmdEnd(void);
+static void OpponentHandleGetMonData(u32 battler);
+static void OpponentHandleGetRawMonData(u32 battler);
+static void OpponentHandleSetMonData(u32 battler);
+static void OpponentHandleSetRawMonData(u32 battler);
+static void OpponentHandleLoadMonSprite(u32 battler);
+static void OpponentHandleSwitchInAnim(u32 battler);
+static void OpponentHandleReturnMonToBall(u32 battler);
+static void OpponentHandleDrawTrainerPic(u32 battler);
+static void OpponentHandleTrainerSlide(u32 battler);
+static void OpponentHandleTrainerSlideBack(u32 battler);
+static void OpponentHandleFaintAnimation(u32 battler);
+static void OpponentHandlePaletteFade(u32 battler);
+static void OpponentHandleSuccessBallThrowAnim(u32 battler);
+static void OpponentHandleBallThrowAnim(u32 battler);
+static void OpponentHandlePause(u32 battler);
+static void OpponentHandleMoveAnimation(u32 battler);
+static void OpponentHandlePrintString(u32 battler);
+static void OpponentHandlePrintSelectionString(u32 battler);
+static void OpponentHandleChooseAction(u32 battler);
+static void OpponentHandleUnknownYesNoBox(u32 battler);
+static void OpponentHandleChooseMove(u32 battler);
+static void OpponentHandleChooseItem(u32 battler);
+static void OpponentHandleChoosePokemon(u32 battler);
+static void OpponentHandleCmd23(u32 battler);
+static void OpponentHandleHealthBarUpdate(u32 battler);
+static void OpponentHandleExpUpdate(u32 battler);
+static void OpponentHandleStatusIconUpdate(u32 battler);
+static void OpponentHandleStatusAnimation(u32 battler);
+static void OpponentHandleStatusXor(u32 battler);
+static void OpponentHandleDataTransfer(u32 battler);
+static void OpponentHandleDMA3Transfer(u32 battler);
+static void OpponentHandlePlayBGM(u32 battler);
+static void OpponentHandleCmd32(u32 battler);
+static void OpponentHandleTwoReturnValues(u32 battler);
+static void OpponentHandleChosenMonReturnValue(u32 battler);
+static void OpponentHandleOneReturnValue(u32 battler);
+static void OpponentHandleOneReturnValue_Duplicate(u32 battler);
+static void OpponentHandleCmd37(u32 battler);
+static void OpponentHandleCmd38(u32 battler);
+static void OpponentHandleCmd39(u32 battler);
+static void OpponentHandleCmd40(u32 battler);
+static void OpponentHandleHitAnimation(u32 battler);
+static void OpponentHandleCmd42(u32 battler);
+static void OpponentHandlePlaySE(u32 battler);
+static void OpponentHandlePlayFanfare(u32 battler);
+static void OpponentHandleFaintingCry(u32 battler);
+static void OpponentHandleIntroSlide(u32 battler);
+static void OpponentHandleIntroTrainerBallThrow(u32 battler);
+static void OpponentHandleDrawPartyStatusSummary(u32 battler);
+static void OpponentHandleHidePartyStatusSummary(u32 battler);
+static void OpponentHandleEndBounceEffect(u32 battler);
+static void OpponentHandleSpriteInvisibility(u32 battler);
+static void OpponentHandleBattleAnimation(u32 battler);
+static void OpponentHandleLinkStandbyMsg(u32 battler);
+static void OpponentHandleResetActionMoveSelection(u32 battler);
+static void OpponentHandleCmd55(u32 battler);
+static void OpponentCmdEnd(u32 battler);
 
-static void OpponentBufferRunCommand(void);
+static void OpponentBufferRunCommand(u32 battler);
 static u32 GetOpponentMonData(u8 monId, u8 *dst);
 static void SetOpponentMonData(u8 monId);
-static void DoSwitchOutAnimation(void);
-static void OpponentDoMoveAnimation(void);
-static void SwitchIn_HandleSoundAndEnd(void);
+static void DoSwitchOutAnimation(u32 battler);
+static void OpponentDoMoveAnimation(u32 battler);
+static void SwitchIn_HandleSoundAndEnd(u32 battler);
 static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
 static void Task_StartSendOutAnim(u8 taskId);
 static void SpriteCB_FreeOpponentSprite(struct Sprite *sprite);
-static void EndDrawPartyStatusSummary(void);
+static void EndDrawPartyStatusSummary(u32 battler);
 
-static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = OpponentHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = OpponentHandleGetRawMonData,
@@ -154,39 +154,39 @@ static void (*const sOpponentBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
 // unknown unused data
 static const u8 sUnused[] = { 0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20 };
 
-static void OpponentDummy(void)
+static void OpponentDummy(u32 battler)
 {
 }
 
-void SetControllerToOpponent(void)
+void SetControllerToOpponent(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = OpponentBufferRunCommand;
 }
 
-static void OpponentBufferRunCommand(void)
+static void OpponentBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < NELEMS(sOpponentBufferCommands))
-            sOpponentBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            sOpponentBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         else
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy2(void)
+static void CompleteOnBattlerSpriteCallbackDummy2(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
 }
 
-static void FreeTrainerSpriteAfterSlide(void)
+static void FreeTrainerSpriteAfterSlide(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
@@ -194,20 +194,20 @@ static void FreeTrainerSpriteAfterSlide(void)
         gSprites[gBattlerSpriteIds[gActiveBattler]].oam.tileNum = gSprites[gBattlerSpriteIds[gActiveBattler]].data[5];
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void Intro_DelayAndEnd(void)
+static void Intro_DelayAndEnd(u32 battler)
 {
     if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0;
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void Intro_WaitForShinyAnimAndHealthbox(void)
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler)
 {
     bool8 var = FALSE;
 
@@ -240,7 +240,7 @@ static void Intro_WaitForShinyAnimAndHealthbox(void)
     }
 }
 
-static void Intro_TryShinyAnimShowHealthbox(void)
+static void Intro_TryShinyAnimShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
         TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]);
@@ -270,7 +270,7 @@ static void Intro_TryShinyAnimShowHealthbox(void)
     }
 }
 
-static void TryShinyAnimAfterMonAnim(void)
+static void TryShinyAnimAfterMonAnim(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded == TRUE
      && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0)
@@ -285,12 +285,12 @@ static void TryShinyAnimAfterMonAnim(void)
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE;
             FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS);
             FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS);
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
         }
     }
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
     s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
     
@@ -308,21 +308,21 @@ static void CompleteOnHealthbarDone(void)
         }
         else
         {
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
         }
     }
 }
 
-static void HideHealthboxAfterMonFaint(void)
+static void HideHealthboxAfterMonFaint(u32 battler)
 {
     if (!gSprites[gBattlerSpriteIds[gActiveBattler]].inUse)
     {
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void FreeMonSpriteAfterSwitchOutAnim(void)
+static void FreeMonSpriteAfterSwitchOutAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
@@ -330,17 +330,17 @@ static void FreeMonSpriteAfterSwitchOutAnim(void)
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         HideBattlerShadowSprite(gActiveBattler);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
     u8 spriteId = gBattlerSpriteIds[gActiveBattler];
 
@@ -349,7 +349,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -359,7 +359,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void SwitchIn_ShowSubstitute(void)
+static void SwitchIn_ShowSubstitute(u32 battler)
 {
     if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
     {
@@ -369,16 +369,16 @@ static void SwitchIn_ShowSubstitute(void)
     }
 }
 
-static void SwitchIn_HandleSoundAndEnd(void)
+static void SwitchIn_HandleSoundAndEnd(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive && !IsCryPlayingOrClearCrySongs())
     {
         m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100);
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void SwitchIn_ShowHealthbox(void)
+static void SwitchIn_ShowHealthbox(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim)
     {
@@ -395,7 +395,7 @@ static void SwitchIn_ShowHealthbox(void)
     }
 }
 
-static void SwitchIn_TryShinyAnim(void)
+static void SwitchIn_TryShinyAnim(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
         TryShinyAnimation(gActiveBattler, &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]]);
@@ -408,25 +408,25 @@ static void SwitchIn_TryShinyAnim(void)
     }
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
 }
 
-void OpponentBufferExecCompleted(void)
+void OpponentBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = OpponentBufferRunCommand;
     gBattleControllerExecFlags &= ~gBitTable[gActiveBattler];
 }
 
-static void OpponentHandleGetMonData(void)
+static void OpponentHandleGetMonData(u32 battler)
 {
     u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data
     u32 size = 0;
@@ -448,7 +448,7 @@ static void OpponentHandleGetMonData(void)
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
 static u32 GetOpponentMonData(u8 monId, u8 *dst)
@@ -756,7 +756,7 @@ static u32 GetOpponentMonData(u8 monId, u8 *dst)
     return size;
 }
 
-static void OpponentHandleGetRawMonData(void)
+static void OpponentHandleGetRawMonData(u32 battler)
 {
     struct BattlePokemon battleMon;
     u8 *src = (u8 *)&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
@@ -766,10 +766,10 @@ static void OpponentHandleGetRawMonData(void)
     for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i)
         dst[i] = src[i];
     BtlController_EmitDataTransfer(BUFFER_B, gBattleBufferA[gActiveBattler][2], dst);
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleSetMonData(void)
+static void OpponentHandleSetMonData(u32 battler)
 {
     u8 monToCheck;
     u8 i;
@@ -788,7 +788,7 @@ static void OpponentHandleSetMonData(void)
             monToCheck >>= 1;
         }
     }
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
 static void SetOpponentMonData(u8 monId)
@@ -1007,17 +1007,17 @@ static void SetOpponentMonData(u8 monId)
     }
 }
 
-static void OpponentHandleSetRawMonData(void)
+static void OpponentHandleSetRawMonData(u32 battler)
 {
     u8 *dst = (u8 *)&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
     u8 i;
 
     for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i)
         dst[i] = gBattleBufferA[gActiveBattler][3 + i];
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleLoadMonSprite(void)
+static void OpponentHandleLoadMonSprite(u32 battler)
 {
     u16 species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
     u32 y;
@@ -1049,7 +1049,7 @@ static void OpponentHandleLoadMonSprite(void)
     gBattlerControllerFuncs[gActiveBattler] = TryShinyAnimAfterMonAnim;
 }
 
-static void OpponentHandleSwitchInAnim(void)
+static void OpponentHandleSwitchInAnim(u32 battler)
 {
     *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = 6;
     gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1];
@@ -1081,7 +1081,7 @@ static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
     gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_OPPONENT_SENDOUT);
 }
 
-static void OpponentHandleReturnMonToBall(void)
+static void OpponentHandleReturnMonToBall(u32 battler)
 {
     if (!gBattleBufferA[gActiveBattler][1])
     {
@@ -1094,11 +1094,11 @@ static void OpponentHandleReturnMonToBall(void)
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         HideBattlerShadowSprite(gActiveBattler);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
     switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
     {
@@ -1118,7 +1118,7 @@ static void DoSwitchOutAnimation(void)
     }
 }
 
-static void OpponentHandleDrawTrainerPic(void)
+static void OpponentHandleDrawTrainerPic(u32 battler)
 {
     u32 trainerPicId;
 
@@ -1148,7 +1148,7 @@ static void OpponentHandleDrawTrainerPic(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
-static void OpponentHandleTrainerSlide(void)
+static void OpponentHandleTrainerSlide(u32 battler)
 {
     u32 trainerPicId;
 
@@ -1179,7 +1179,7 @@ static void OpponentHandleTrainerSlide(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy2;
 }
 
-static void OpponentHandleTrainerSlideBack(void)
+static void OpponentHandleTrainerSlideBack(u32 battler)
 {
     SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
     gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 35;
@@ -1190,7 +1190,7 @@ static void OpponentHandleTrainerSlideBack(void)
     gBattlerControllerFuncs[gActiveBattler] = FreeTrainerSpriteAfterSlide;
 }
 
-static void OpponentHandleFaintAnimation(void)
+static void OpponentHandleFaintAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
     {
@@ -1210,27 +1210,27 @@ static void OpponentHandleFaintAnimation(void)
     }
 }
 
-static void OpponentHandlePaletteFade(void)
+static void OpponentHandlePaletteFade(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleSuccessBallThrowAnim(void)
+static void OpponentHandleSuccessBallThrowAnim(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleBallThrowAnim(void)
+static void OpponentHandleBallThrowAnim(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandlePause(void)
+static void OpponentHandlePause(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleMoveAnimation(void)
+static void OpponentHandleMoveAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1245,7 +1245,7 @@ static void OpponentHandleMoveAnimation(void)
         gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
         if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE
         {
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
         }
         else
         {
@@ -1255,7 +1255,7 @@ static void OpponentHandleMoveAnimation(void)
     }
 }
 
-static void OpponentDoMoveAnimation(void)
+static void OpponentDoMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
     u8 multihit = gBattleBufferA[gActiveBattler][11];
@@ -1298,13 +1298,13 @@ static void OpponentDoMoveAnimation(void)
             CopyAllBattleSpritesInvisibilities();
             TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void OpponentHandlePrintString(void)
+static void OpponentHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -1331,23 +1331,23 @@ static void OpponentHandlePrintString(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
-static void OpponentHandlePrintSelectionString(void)
+static void OpponentHandlePrintSelectionString(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleChooseAction(void)
+static void OpponentHandleChooseAction(u32 battler)
 {
     AI_TrySwitchOrUseItem();
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleUnknownYesNoBox(void)
+static void OpponentHandleUnknownYesNoBox(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleChooseMove(void)
+static void OpponentHandleChooseMove(u32 battler)
 {
     u8 chosenMoveId;
     struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
@@ -1378,7 +1378,7 @@ static void OpponentHandleChooseMove(void)
             BtlController_EmitTwoReturnValues(1, 10, (chosenMoveId) | (gBattlerTarget << 8));
             break;
         }
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -1397,17 +1397,17 @@ static void OpponentHandleChooseMove(void)
         else
             BtlController_EmitTwoReturnValues(1, 10, (chosenMoveId) | (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) << 8));
 
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void OpponentHandleChooseItem(void)
+static void OpponentHandleChooseItem(u32 battler)
 {
     BtlController_EmitOneReturnValue(1, *(gBattleStruct->chosenItem + (gActiveBattler / 2) * 2));
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleChoosePokemon(void)
+static void OpponentHandleChoosePokemon(u32 battler)
 {
     s32 chosenMonId;
 
@@ -1442,15 +1442,15 @@ static void OpponentHandleChoosePokemon(void)
     }
     *(gBattleStruct->monToSwitchIntoId + gActiveBattler) = chosenMonId;
     BtlController_EmitChosenMonReturnValue(1, chosenMonId, NULL);
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd23(void)
+static void OpponentHandleCmd23(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleHealthBarUpdate(void)
+static void OpponentHandleHealthBarUpdate(u32 battler)
 {
     s16 hpVal;
 
@@ -1473,12 +1473,12 @@ static void OpponentHandleHealthBarUpdate(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
 }
 
-static void OpponentHandleExpUpdate(void)
+static void OpponentHandleExpUpdate(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleStatusIconUpdate(void)
+static void OpponentHandleStatusIconUpdate(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1491,7 +1491,7 @@ static void OpponentHandleStatusIconUpdate(void)
     }
 }
 
-static void OpponentHandleStatusAnimation(void)
+static void OpponentHandleStatusAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1501,80 +1501,80 @@ static void OpponentHandleStatusAnimation(void)
     }
 }
 
-static void OpponentHandleStatusXor(void)
+static void OpponentHandleStatusXor(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleDataTransfer(void)
+static void OpponentHandleDataTransfer(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleDMA3Transfer(void)
+static void OpponentHandleDMA3Transfer(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandlePlayBGM(void)
+static void OpponentHandlePlayBGM(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd32(void)
+static void OpponentHandleCmd32(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleTwoReturnValues(void)
+static void OpponentHandleTwoReturnValues(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleChosenMonReturnValue(void)
+static void OpponentHandleChosenMonReturnValue(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleOneReturnValue(void)
+static void OpponentHandleOneReturnValue(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleOneReturnValue_Duplicate(void)
+static void OpponentHandleOneReturnValue_Duplicate(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd37(void)
+static void OpponentHandleCmd37(u32 battler)
 {
     gUnusedControllerStruct.unk = 0;
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd38(void)
+static void OpponentHandleCmd38(u32 battler)
 {
     gUnusedControllerStruct.unk = gBattleBufferA[gActiveBattler][1];
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd39(void)
+static void OpponentHandleCmd39(u32 battler)
 {
     gUnusedControllerStruct.flag = 0;
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd40(void)
+static void OpponentHandleCmd40(u32 battler)
 {
     gUnusedControllerStruct.flag ^= 1;
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleHitAnimation(void)
+static void OpponentHandleHitAnimation(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
     {
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -1585,12 +1585,12 @@ static void OpponentHandleHitAnimation(void)
     }
 }
 
-static void OpponentHandleCmd42(void)
+static void OpponentHandleCmd42(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandlePlaySE(void)
+static void OpponentHandlePlaySE(u32 battler)
 {
     s8 pan;
 
@@ -1599,31 +1599,31 @@ static void OpponentHandlePlaySE(void)
     else
         pan = SOUND_PAN_TARGET;
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandlePlayFanfare(void)
+static void OpponentHandlePlayFanfare(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleFaintingCry(void)
+static void OpponentHandleFaintingCry(u32 battler)
 {
     u16 species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry_ByMode(species, 25, CRY_MODE_FAINT);
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleIntroSlide(void)
+static void OpponentHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleIntroTrainerBallThrow(void)
+static void OpponentHandleIntroTrainerBallThrow(u32 battler)
 {
     u8 paletteNum;
     u8 taskId;
@@ -1674,11 +1674,11 @@ static void Task_StartSendOutAnim(u8 taskId)
     DestroyTask(taskId);
 }
 
-static void OpponentHandleDrawPartyStatusSummary(void)
+static void OpponentHandleDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
     else
     {
@@ -1706,38 +1706,38 @@ static void OpponentHandleDrawPartyStatusSummary(void)
     }
 }
 
-static void EndDrawPartyStatusSummary(void)
+static void EndDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer++ > 0x5C)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0;
-        OpponentBufferExecCompleted();
+        OpponentBufferExecCompleted(battler);
     }
 }
 
-static void OpponentHandleHidePartyStatusSummary(void)
+static void OpponentHandleHidePartyStatusSummary(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
         gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleEndBounceEffect(void)
+static void OpponentHandleEndBounceEffect(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleSpriteInvisibility(void)
+static void OpponentHandleSpriteInvisibility(u32 battler)
 {
     if (IsBattlerSpritePresent(gActiveBattler))
     {
         gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleBufferA[gActiveBattler][1];
         CopyBattleSpriteInvisibility(gActiveBattler);
     }
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleBattleAnimation(void)
+static void OpponentHandleBattleAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1745,23 +1745,23 @@ static void OpponentHandleBattleAnimation(void)
         u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
         if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-            OpponentBufferExecCompleted();
+            OpponentBufferExecCompleted(battler);
         else
             gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
     }
 }
 
-static void OpponentHandleLinkStandbyMsg(void)
+static void OpponentHandleLinkStandbyMsg(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleResetActionMoveSelection(void)
+static void OpponentHandleResetActionMoveSelection(u32 battler)
 {
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentHandleCmd55(void)
+static void OpponentHandleCmd55(u32 battler)
 {
     if (gBattleTypeFlags & BATTLE_TYPE_LINK && !(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER))
     {
@@ -1769,9 +1769,9 @@ static void OpponentHandleCmd55(void)
         gMain.callback1 = gPreBattleCallback1;
         SetMainCallback2(gMain.savedCallback);
     }
-    OpponentBufferExecCompleted();
+    OpponentBufferExecCompleted(battler);
 }
 
-static void OpponentCmdEnd(void)
+static void OpponentCmdEnd(u32 battler)
 {
 }
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
index 0b8abd55f..87803e996 100644
--- a/src/battle_controller_player.c
+++ b/src/battle_controller_player.c
@@ -81,31 +81,31 @@ static void PlayerHandleResetActionMoveSelection(u32 battler);
 static void PlayerHandleCmd55(u32 battler);
 static void PlayerCmdEnd(u32 battler);
 
-static void PlayerBufferRunCommand(void);
-static void HandleInputChooseTarget(void);
-static void MoveSelectionDisplayPpNumber(void);
+static void PlayerBufferRunCommand(u32 battler);
+static void HandleInputChooseTarget(u32 battler);
+static void MoveSelectionDisplayPpNumber(u32 battler);
 static void MoveSelectionDisplayPpString(void);
-static void MoveSelectionDisplayMoveType(void);
-static void MoveSelectionDisplayMoveNames(void);
-static void HandleMoveSwitching(void);
-static void WaitForMonSelection(void);
-static void CompleteWhenChoseItem(void);
+static void MoveSelectionDisplayMoveType(u32 battler);
+static void MoveSelectionDisplayMoveNames(u32 battler);
+static void HandleMoveSwitching(u32 battler);
+static void WaitForMonSelection(u32 battler);
+static void CompleteWhenChoseItem(u32 battler);
 static void Task_LaunchLvlUpAnim(u8 taskId);
 static void Task_PrepareToGiveExpWithExpBar(u8 taskId);
 static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId);
 static void Task_UpdateLvlInHealthbox(u8 taskId);
 static void PrintLinkStandbyMsg(void);
-static u32 CopyPlayerMonData(u8 monId, u8 *dst);
-static void SetPlayerMonData(u8 monId);
-static void DoSwitchOutAnimation(void);
-static void PlayerDoMoveAnimation(void);
+static u32 CopyPlayerMonData(u32 battler, u8 monId, u8 *dst);
+static void SetPlayerMonData(u32 battler, u8 monId);
+static void DoSwitchOutAnimation(u32 battler);
+static void PlayerDoMoveAnimation(u32 battler);
 static void Task_StartSendOutAnim(u8 taskId);
-static void PreviewDeterminativeMoveTargets(void);
-static void SwitchIn_HandleSoundAndEnd(void);
+static void PreviewDeterminativeMoveTargets(u32 battler);
+static void SwitchIn_HandleSoundAndEnd(u32 battler);
 static void Task_GiveExpWithExpBar(u8 taskId);
 static void Task_CreateLevelUpVerticalStripes(u8 taskId);
-static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit);
-static void EndDrawPartyStatusSummary(void);
+static void StartSendOutAnim(u32 battler, bool8 dontClearSubstituteBit);
+static void EndDrawPartyStatusSummary(u32 battler);
 
 static void (*const sPlayerBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
@@ -173,60 +173,60 @@ static const u8 sTargetIdentities[] = { B_POSITION_PLAYER_LEFT, B_POSITION_PLAYE
 // unknown unused data
 static const u8 sUnused[] = { 0x48, 0x48, 0x20, 0x5a, 0x50, 0x50, 0x50, 0x58 };
 
-void BattleControllerDummy(void)
+void BattleControllerDummy(u32 battler)
 {
 }
 
-void SetControllerToPlayer(void)
+void SetControllerToPlayer(u32 battler)
 {
-    gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand;
+    gBattlerControllerFuncs[battler] = PlayerBufferRunCommand;
     gDoingBattleAnim = FALSE;
 }
 
-static void PlayerBufferExecCompleted(void)
+static void PlayerBufferExecCompleted(u32 battler)
 {
-    gBattlerControllerFuncs[gActiveBattler] = PlayerBufferRunCommand;
+    gBattlerControllerFuncs[battler] = PlayerBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
     {
         u8 playerId = GetMultiplayerId();
 
         PrepareBufferDataTransferLink(2, 4, &playerId);
-        gBattleBufferA[gActiveBattler][0] = CONTROLLER_TERMINATOR_NOP;
+        gBattleBufferA[battler][0] = CONTROLLER_TERMINATOR_NOP;
     }
     else
     {
-        gBattleControllerExecFlags &= ~gBitTable[gActiveBattler];
+        gBattleControllerExecFlags &= ~gBitTable[battler];
     }
 }
 
-static void PlayerBufferRunCommand(void)
+static void PlayerBufferRunCommand(u32 battler)
 {
-    if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
+    if (gBattleControllerExecFlags & gBitTable[battler])
     {
-        if (gBattleBufferA[gActiveBattler][0] < NELEMS(sPlayerBufferCommands))
-            sPlayerBufferCommands[gBattleBufferA[gActiveBattler][0]](gActiveBattler);
+        if (gBattleBufferA[battler][0] < NELEMS(sPlayerBufferCommands))
+            sPlayerBufferCommands[gBattleBufferA[battler][0]](battler);
         else
-            PlayerBufferExecCompleted();
+            PlayerBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpritePosX_0(void)
+static void CompleteOnBattlerSpritePosX_0(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0)
-        PlayerBufferExecCompleted();
+    if (gSprites[gBattlerSpriteIds[battler]].x2 == 0)
+        PlayerBufferExecCompleted(battler);
 }
 
-static void HandleInputChooseAction(void)
+static void HandleInputChooseAction(u32 battler)
 {
-    u16 itemId = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
+    u16 itemId = gBattleBufferA[battler][2] | (gBattleBufferA[battler][3] << 8);
 
-    DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1);
-    DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1);
+    DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1);
+    DoBounceEffect(battler, BOUNCE_MON, 7, 1);
     if (JOY_NEW(A_BUTTON))
     {
         PlaySE(SE_SELECT);
 
-        switch (gActionSelectionCursor[gActiveBattler])
+        switch (gActionSelectionCursor[battler])
         {
         case 0:
             BtlController_EmitTwoReturnValues(1, B_ACTION_USE_MOVE, 0);
@@ -241,56 +241,56 @@ static void HandleInputChooseAction(void)
             BtlController_EmitTwoReturnValues(1, B_ACTION_RUN, 0);
             break;
         }
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else if (JOY_NEW(DPAD_LEFT))
     {
-        if (gActionSelectionCursor[gActiveBattler] & 1) // if is B_ACTION_USE_ITEM or B_ACTION_RUN
+        if (gActionSelectionCursor[battler] & 1) // if is B_ACTION_USE_ITEM or B_ACTION_RUN
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
-            gActionSelectionCursor[gActiveBattler] ^= 1;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]);
+            gActionSelectionCursor[battler] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0);
         }
     }
     else if (JOY_NEW(DPAD_RIGHT))
     {
-        if (!(gActionSelectionCursor[gActiveBattler] & 1)) // if is B_ACTION_USE_MOVE or B_ACTION_SWITCH
+        if (!(gActionSelectionCursor[battler] & 1)) // if is B_ACTION_USE_MOVE or B_ACTION_SWITCH
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
-            gActionSelectionCursor[gActiveBattler] ^= 1;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]);
+            gActionSelectionCursor[battler] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0);
         }
     }
     else if (JOY_NEW(DPAD_UP))
     {
-        if (gActionSelectionCursor[gActiveBattler] & 2) // if is B_ACTION_SWITCH or B_ACTION_RUN
+        if (gActionSelectionCursor[battler] & 2) // if is B_ACTION_SWITCH or B_ACTION_RUN
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
-            gActionSelectionCursor[gActiveBattler] ^= 2;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]);
+            gActionSelectionCursor[battler] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0);
         }
     }
     else if (JOY_NEW(DPAD_DOWN))
     {
-        if (!(gActionSelectionCursor[gActiveBattler] & 2)) // if is B_ACTION_USE_MOVE or B_ACTION_USE_ITEM
+        if (!(gActionSelectionCursor[battler] & 2)) // if is B_ACTION_USE_MOVE or B_ACTION_USE_ITEM
         {
             PlaySE(SE_SELECT);
-            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBattler]);
-            gActionSelectionCursor[gActiveBattler] ^= 2;
-            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[battler]);
+            gActionSelectionCursor[battler] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0);
         }
     }
     else if (JOY_NEW(B_BUTTON))
     {
         if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
-         && GetBattlerPosition(gActiveBattler) == B_POSITION_PLAYER_RIGHT
+         && GetBattlerPosition(battler) == B_POSITION_PLAYER_RIGHT
          && !(gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_LEFT)])
          && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
         {
-            if (gBattleBufferA[gActiveBattler][1] == B_ACTION_USE_ITEM)
+            if (gBattleBufferA[battler][1] == B_ACTION_USE_ITEM)
             {
                 // Add item to bag if it is a ball
                 if (itemId <= ITEM_PREMIER_BALL)
@@ -300,7 +300,7 @@ static void HandleInputChooseAction(void)
             }
             PlaySE(SE_SELECT);
             BtlController_EmitTwoReturnValues(1, B_ACTION_CANCEL_PARTNER, 0);
-            PlayerBufferExecCompleted();
+            PlayerBufferExecCompleted(battler);
         }
     }
     else if (JOY_NEW(START_BUTTON))
@@ -310,14 +310,14 @@ static void HandleInputChooseAction(void)
 }
 
 // Unused
-static void EndBounceEffect2(void)
+static void EndBounceEffect2(u32 battler)
 {
-    EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX);
-    EndBounceEffect(gActiveBattler, BOUNCE_MON);
-    gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseTarget;
+    EndBounceEffect(battler, BOUNCE_HEALTHBOX);
+    EndBounceEffect(battler, BOUNCE_MON);
+    gBattlerControllerFuncs[battler] = HandleInputChooseTarget;
 }
 
-static void HandleInputChooseTarget(void)
+static void HandleInputChooseTarget(u32 battler)
 {
     s32 i;
     u8 identities[4];
@@ -339,17 +339,17 @@ static void HandleInputChooseTarget(void)
     {
         PlaySE(SE_SELECT);
         gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget;
-        BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8));
+        BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
         EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX);
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else if (JOY_NEW(B_BUTTON))
     {
         PlaySE(SE_SELECT);
         gSprites[gBattlerSpriteIds[gMultiUsePlayerCursor]].callback = SpriteCB_HideAsMoveTarget;
-        gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove;
-        DoBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX, 7, 1);
-        DoBounceEffect(gActiveBattler, BOUNCE_MON, 7, 1);
+        gBattlerControllerFuncs[battler] = HandleInputChooseMove;
+        DoBounceEffect(battler, BOUNCE_HEALTHBOX, 7, 1);
+        DoBounceEffect(battler, BOUNCE_MON, 7, 1);
         EndBounceEffect(gMultiUsePlayerCursor, BOUNCE_HEALTHBOX);
     }
     else if (JOY_NEW(DPAD_LEFT | DPAD_UP))
@@ -376,9 +376,9 @@ static void HandleInputChooseTarget(void)
             {
             case B_POSITION_PLAYER_LEFT:
             case B_POSITION_PLAYER_RIGHT:
-                if (gActiveBattler != gMultiUsePlayerCursor)
+                if (battler != gMultiUsePlayerCursor)
                     ++i;
-                else if (gMovesInfo[GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBattler])].target & MOVE_TARGET_USER_OR_SELECTED)
+                else if (gMovesInfo[GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + gMoveSelectionCursor[battler])].target & MOVE_TARGET_USER_OR_SELECTED)
                     ++i;
                 break;
             case B_POSITION_OPPONENT_LEFT:
@@ -416,9 +416,9 @@ static void HandleInputChooseTarget(void)
             {
             case B_POSITION_PLAYER_LEFT:
             case B_POSITION_PLAYER_RIGHT:
-                if (gActiveBattler != gMultiUsePlayerCursor)
+                if (battler != gMultiUsePlayerCursor)
                     ++i;
-                else if (gMovesInfo[GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBattler])].target & MOVE_TARGET_USER_OR_SELECTED)
+                else if (gMovesInfo[GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + gMoveSelectionCursor[battler])].target & MOVE_TARGET_USER_OR_SELECTED)
                     ++i;
                 break;
             case B_POSITION_OPPONENT_LEFT:
@@ -434,18 +434,18 @@ static void HandleInputChooseTarget(void)
     }
 }
 
-void HandleInputChooseMove(void)
+void HandleInputChooseMove(u32 battler)
 {
     bool32 canSelectTarget = FALSE;
-    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
 
-    PreviewDeterminativeMoveTargets();
+    PreviewDeterminativeMoveTargets(battler);
     if (JOY_NEW(A_BUTTON))
     {
         u8 moveTarget;
 
         PlaySE(SE_SELECT);
-        if (moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] == MOVE_CURSE)
+        if (moveInfo->moves[gMoveSelectionCursor[battler]] == MOVE_CURSE)
         {
             if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST)
                 moveTarget = MOVE_TARGET_USER;
@@ -454,30 +454,30 @@ void HandleInputChooseMove(void)
         }
         else
         {
-            moveTarget = gMovesInfo[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].target;
+            moveTarget = gMovesInfo[moveInfo->moves[gMoveSelectionCursor[battler]]].target;
         }
 
         if (moveTarget & MOVE_TARGET_USER)
-            gMultiUsePlayerCursor = gActiveBattler;
+            gMultiUsePlayerCursor = battler;
         else
-            gMultiUsePlayerCursor = GetBattlerAtPosition((GetBattlerPosition(gActiveBattler) & BIT_SIDE) ^ BIT_SIDE);
+            gMultiUsePlayerCursor = GetBattlerAtPosition((GetBattlerPosition(battler) & BIT_SIDE) ^ BIT_SIDE);
 
-        if (!gBattleBufferA[gActiveBattler][1]) // not a double battle
+        if (!gBattleBufferA[battler][1]) // not a double battle
         {
-            if (moveTarget & MOVE_TARGET_USER_OR_SELECTED && !gBattleBufferA[gActiveBattler][2])
+            if (moveTarget & MOVE_TARGET_USER_OR_SELECTED && !gBattleBufferA[battler][2])
                 ++canSelectTarget;
         }
         else // double battle
         {
             if (!(moveTarget & (MOVE_TARGET_RANDOM | MOVE_TARGET_BOTH | MOVE_TARGET_DEPENDS | MOVE_TARGET_FOES_AND_ALLY | MOVE_TARGET_OPPONENTS_FIELD | MOVE_TARGET_USER)))
                 ++canSelectTarget; // either selected or user
-            if (moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] == 0)
+            if (moveInfo->currentPp[gMoveSelectionCursor[battler]] == 0)
             {
                 canSelectTarget = FALSE;
             }
-            else if (!(moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_BATTLER, gActiveBattler) <= 1)
+            else if (!(moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_BATTLER, battler) <= 1)
             {
-                gMultiUsePlayerCursor = GetDefaultMoveTarget(gActiveBattler);
+                gMultiUsePlayerCursor = GetDefaultMoveTarget(battler);
                 canSelectTarget = FALSE;
             }
         }
@@ -485,14 +485,14 @@ void HandleInputChooseMove(void)
         BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
         if (!canSelectTarget)
         {
-            BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[gActiveBattler] | (gMultiUsePlayerCursor << 8));
-            PlayerBufferExecCompleted();
+            BtlController_EmitTwoReturnValues(1, 10, gMoveSelectionCursor[battler] | (gMultiUsePlayerCursor << 8));
+            PlayerBufferExecCompleted(battler);
         }
         else
         {
-            gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseTarget;
+            gBattlerControllerFuncs[battler] = HandleInputChooseTarget;
             if (moveTarget & (MOVE_TARGET_USER | MOVE_TARGET_USER_OR_SELECTED))
-                gMultiUsePlayerCursor = gActiveBattler;
+                gMultiUsePlayerCursor = battler;
             else if (gAbsentBattlerFlags & gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)])
                 gMultiUsePlayerCursor = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT);
             else
@@ -504,61 +504,61 @@ void HandleInputChooseMove(void)
     {
         PlaySE(SE_SELECT);
         BtlController_EmitTwoReturnValues(1, 10, 0xFFFF);
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
         ResetPaletteFadeControl();
         BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
     }
     else if (JOY_NEW(DPAD_LEFT))
     {
-        if (gMoveSelectionCursor[gActiveBattler] & 1)
+        if (gMoveSelectionCursor[battler] & 1)
         {
-            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-            gMoveSelectionCursor[gActiveBattler] ^= 1;
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]);
+            gMoveSelectionCursor[battler] ^= 1;
             PlaySE(SE_SELECT);
-            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-            MoveSelectionDisplayPpNumber();
-            MoveSelectionDisplayMoveType();
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
+            MoveSelectionDisplayPpNumber(battler);
+            MoveSelectionDisplayMoveType(battler);
             BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
         }
     }
     else if (JOY_NEW(DPAD_RIGHT))
     {
-        if (!(gMoveSelectionCursor[gActiveBattler] & 1)
-         && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose)
+        if (!(gMoveSelectionCursor[battler] & 1)
+         && (gMoveSelectionCursor[battler] ^ 1) < gNumberOfMovesToChoose)
         {
-            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-            gMoveSelectionCursor[gActiveBattler] ^= 1;
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]);
+            gMoveSelectionCursor[battler] ^= 1;
             PlaySE(SE_SELECT);
-            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-            MoveSelectionDisplayPpNumber();
-            MoveSelectionDisplayMoveType();
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
+            MoveSelectionDisplayPpNumber(battler);
+            MoveSelectionDisplayMoveType(battler);
             BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
         }
     }
     else if (JOY_NEW(DPAD_UP))
     {
-        if (gMoveSelectionCursor[gActiveBattler] & 2)
+        if (gMoveSelectionCursor[battler] & 2)
         {
-            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-            gMoveSelectionCursor[gActiveBattler] ^= 2;
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]);
+            gMoveSelectionCursor[battler] ^= 2;
             PlaySE(SE_SELECT);
-            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-            MoveSelectionDisplayPpNumber();
-            MoveSelectionDisplayMoveType();
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
+            MoveSelectionDisplayPpNumber(battler);
+            MoveSelectionDisplayMoveType(battler);
             BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
         }
     }
     else if (JOY_NEW(DPAD_DOWN))
     {
-        if (!(gMoveSelectionCursor[gActiveBattler] & 2)
-         && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose)
+        if (!(gMoveSelectionCursor[battler] & 2)
+         && (gMoveSelectionCursor[battler] ^ 2) < gNumberOfMovesToChoose)
         {
-            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-            gMoveSelectionCursor[gActiveBattler] ^= 2;
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[battler]);
+            gMoveSelectionCursor[battler] ^= 2;
             PlaySE(SE_SELECT);
-            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-            MoveSelectionDisplayPpNumber();
-            MoveSelectionDisplayMoveType();
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
+            MoveSelectionDisplayPpNumber(battler);
+            MoveSelectionDisplayMoveType(battler);
             BeginNormalPaletteFade(0xF0000, 0, 0, 0, RGB_WHITE);
         }
     }
@@ -566,69 +566,19 @@ void HandleInputChooseMove(void)
     {
         if (gNumberOfMovesToChoose > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK))
         {
-            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29);
-            if (gMoveSelectionCursor[gActiveBattler] != 0)
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29);
+            if (gMoveSelectionCursor[battler] != 0)
                 gMultiUsePlayerCursor = 0;
             else
-                gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBattler] + 1;
+                gMultiUsePlayerCursor = gMoveSelectionCursor[battler] + 1;
             MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
             BattlePutTextOnWindow(gText_BattleSwitchWhich, B_WIN_SWITCH_PROMPT);
-            gBattlerControllerFuncs[gActiveBattler] = HandleMoveSwitching;
+            gBattlerControllerFuncs[battler] = HandleMoveSwitching;
         }
     }
 }
 
-// not used
-static u32 HandleMoveInputUnused(void)
-{
-    u32 var = 0;
-
-    if (JOY_NEW(A_BUTTON))
-    {
-        PlaySE(SE_SELECT);
-        var = 1;
-    }
-    if (JOY_NEW(B_BUTTON))
-    {
-        PlaySE(SE_SELECT);
-        gBattle_BG0_X = 0;
-        gBattle_BG0_Y = 0x140;
-        var = 0xFF;
-    }
-    if (JOY_NEW(DPAD_LEFT) && gMoveSelectionCursor[gActiveBattler] & 1)
-    {
-        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-        gMoveSelectionCursor[gActiveBattler] ^= 1;
-        PlaySE(SE_SELECT);
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-    }
-    if (JOY_NEW(DPAD_RIGHT) && !(gMoveSelectionCursor[gActiveBattler] & 1)
-        && (gMoveSelectionCursor[gActiveBattler] ^ 1) < gNumberOfMovesToChoose)
-    {
-        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-        gMoveSelectionCursor[gActiveBattler] ^= 1;
-        PlaySE(SE_SELECT);
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-    }
-    if (JOY_NEW(DPAD_UP) && gMoveSelectionCursor[gActiveBattler] & 2)
-    {
-        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-        gMoveSelectionCursor[gActiveBattler] ^= 2;
-        PlaySE(SE_SELECT);
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-    }
-    if (JOY_NEW(DPAD_DOWN) && !(gMoveSelectionCursor[gActiveBattler] & 2)
-        && (gMoveSelectionCursor[gActiveBattler] ^ 2) < gNumberOfMovesToChoose)
-    {
-        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBattler]);
-        gMoveSelectionCursor[gActiveBattler] ^= 2;
-        PlaySE(SE_SELECT);
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
-    }
-    return var;
-}
-
-static void HandleMoveSwitching(void)
+static void HandleMoveSwitching(u32 battler)
 {
     u8 perMovePPBonuses[4];
     struct ChooseMoveStruct moveStruct;
@@ -638,107 +588,107 @@ static void HandleMoveSwitching(void)
     {
         PlaySE(SE_SELECT);
 
-        if (gMoveSelectionCursor[gActiveBattler] != gMultiUsePlayerCursor)
+        if (gMoveSelectionCursor[battler] != gMultiUsePlayerCursor)
         {
-            struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
+            struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
             s32 i;
 
             // swap moves and pp
-            i = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]];
-            moveInfo->moves[gMoveSelectionCursor[gActiveBattler]] = moveInfo->moves[gMultiUsePlayerCursor];
+            i = moveInfo->moves[gMoveSelectionCursor[battler]];
+            moveInfo->moves[gMoveSelectionCursor[battler]] = moveInfo->moves[gMultiUsePlayerCursor];
             moveInfo->moves[gMultiUsePlayerCursor] = i;
-            i = moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]];
-            moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->currentPp[gMultiUsePlayerCursor];
+            i = moveInfo->currentPp[gMoveSelectionCursor[battler]];
+            moveInfo->currentPp[gMoveSelectionCursor[battler]] = moveInfo->currentPp[gMultiUsePlayerCursor];
             moveInfo->currentPp[gMultiUsePlayerCursor] = i;
-            i = moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]];
-            moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]] = moveInfo->maxPp[gMultiUsePlayerCursor];
+            i = moveInfo->maxPp[gMoveSelectionCursor[battler]];
+            moveInfo->maxPp[gMoveSelectionCursor[battler]] = moveInfo->maxPp[gMultiUsePlayerCursor];
             moveInfo->maxPp[gMultiUsePlayerCursor] = i;
-            if (gDisableStructs[gActiveBattler].mimickedMoves & gBitTable[gMoveSelectionCursor[gActiveBattler]])
+            if (gDisableStructs[battler].mimickedMoves & gBitTable[gMoveSelectionCursor[battler]])
             {
-                gDisableStructs[gActiveBattler].mimickedMoves &= (~gBitTable[gMoveSelectionCursor[gActiveBattler]]);
-                gDisableStructs[gActiveBattler].mimickedMoves |= gBitTable[gMultiUsePlayerCursor];
+                gDisableStructs[battler].mimickedMoves &= (~gBitTable[gMoveSelectionCursor[battler]]);
+                gDisableStructs[battler].mimickedMoves |= gBitTable[gMultiUsePlayerCursor];
             }
-            MoveSelectionDisplayMoveNames();
+            MoveSelectionDisplayMoveNames(battler);
             for (i = 0; i < MAX_MON_MOVES; ++i)
-                perMovePPBonuses[i] = (gBattleMons[gActiveBattler].ppBonuses & (3 << (i * 2))) >> (i * 2);
-            totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]];
-            perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor];
+                perMovePPBonuses[i] = (gBattleMons[battler].ppBonuses & (3 << (i * 2))) >> (i * 2);
+            totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[battler]];
+            perMovePPBonuses[gMoveSelectionCursor[battler]] = perMovePPBonuses[gMultiUsePlayerCursor];
             perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses;
             totalPPBonuses = 0;
             for (i = 0; i < MAX_MON_MOVES; ++i)
                 totalPPBonuses |= perMovePPBonuses[i] << (i * 2);
 
-            gBattleMons[gActiveBattler].ppBonuses = totalPPBonuses;
+            gBattleMons[battler].ppBonuses = totalPPBonuses;
             for (i = 0; i < MAX_MON_MOVES; ++i)
             {
-                gBattleMons[gActiveBattler].moves[i] = moveInfo->moves[i];
-                gBattleMons[gActiveBattler].pp[i] = moveInfo->currentPp[i];
+                gBattleMons[battler].moves[i] = moveInfo->moves[i];
+                gBattleMons[battler].pp[i] = moveInfo->currentPp[i];
             }
-            if (!(gBattleMons[gActiveBattler].status2 & STATUS2_TRANSFORMED))
+            if (!(gBattleMons[battler].status2 & STATUS2_TRANSFORMED))
             {
                 for (i = 0; i < MAX_MON_MOVES; ++i)
                 {
-                    moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + i);
-                    moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP1 + i);
+                    moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + i);
+                    moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + i);
                 }
 
-                totalPPBonuses = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES);
+                totalPPBonuses = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP_BONUSES);
                 for (i = 0; i < MAX_MON_MOVES; ++i)
                     perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2);
-                i = moveStruct.moves[gMoveSelectionCursor[gActiveBattler]];
-                moveStruct.moves[gMoveSelectionCursor[gActiveBattler]] = moveStruct.moves[gMultiUsePlayerCursor];
+                i = moveStruct.moves[gMoveSelectionCursor[battler]];
+                moveStruct.moves[gMoveSelectionCursor[battler]] = moveStruct.moves[gMultiUsePlayerCursor];
                 moveStruct.moves[gMultiUsePlayerCursor] = i;
-                i = moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]];
-                moveStruct.currentPp[gMoveSelectionCursor[gActiveBattler]] = moveStruct.currentPp[gMultiUsePlayerCursor];
+                i = moveStruct.currentPp[gMoveSelectionCursor[battler]];
+                moveStruct.currentPp[gMoveSelectionCursor[battler]] = moveStruct.currentPp[gMultiUsePlayerCursor];
                 moveStruct.currentPp[gMultiUsePlayerCursor] = i;
-                totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]];
-                perMovePPBonuses[gMoveSelectionCursor[gActiveBattler]] = perMovePPBonuses[gMultiUsePlayerCursor];
+                totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[battler]];
+                perMovePPBonuses[gMoveSelectionCursor[battler]] = perMovePPBonuses[gMultiUsePlayerCursor];
                 perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses;
                 totalPPBonuses = 0;
                 for (i = 0; i < MAX_MON_MOVES; ++i)
                     totalPPBonuses |= perMovePPBonuses[i] << (i * 2);
                 for (i = 0; i < MAX_MON_MOVES; ++i)
                 {
-                    SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]);
-                    SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]);
+                    SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]);
+                    SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]);
                 }
-                SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_PP_BONUSES, &totalPPBonuses);
+                SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_PP_BONUSES, &totalPPBonuses);
             }
         }
         if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
-            gBattlerControllerFuncs[gActiveBattler] = OakOldManHandleInputChooseMove;
+            gBattlerControllerFuncs[battler] = OakOldManHandleInputChooseMove;
         else
-            gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove;
-        gMoveSelectionCursor[gActiveBattler] = gMultiUsePlayerCursor;
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
+            gBattlerControllerFuncs[battler] = HandleInputChooseMove;
+        gMoveSelectionCursor[battler] = gMultiUsePlayerCursor;
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
         MoveSelectionDisplayPpString();
-        MoveSelectionDisplayPpNumber();
-        MoveSelectionDisplayMoveType();
+        MoveSelectionDisplayPpNumber(battler);
+        MoveSelectionDisplayMoveType(battler);
     }
     if (JOY_NEW(B_BUTTON))
     {
         PlaySE(SE_SELECT);
         MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
-        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
         if (gBattleTypeFlags & BATTLE_TYPE_FIRST_BATTLE)
-            gBattlerControllerFuncs[gActiveBattler] = OakOldManHandleInputChooseMove;
+            gBattlerControllerFuncs[battler] = OakOldManHandleInputChooseMove;
         else
-            gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove;
+            gBattlerControllerFuncs[battler] = HandleInputChooseMove;
         MoveSelectionDisplayPpString();
-        MoveSelectionDisplayPpNumber();
-        MoveSelectionDisplayMoveType();
+        MoveSelectionDisplayPpNumber(battler);
+        MoveSelectionDisplayMoveType(battler);
     }
     if (JOY_NEW(DPAD_LEFT))
     {
         if (gMultiUsePlayerCursor & 1)
         {
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
-                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29);
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29);
             else
                 MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
             gMultiUsePlayerCursor ^= 1;
             PlaySE(SE_SELECT);
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
             else
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
@@ -748,13 +698,13 @@ static void HandleMoveSwitching(void)
     {
         if (!(gMultiUsePlayerCursor & 1) && (gMultiUsePlayerCursor ^ 1) < gNumberOfMovesToChoose)
         {
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
-                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29);
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29);
             else
                 MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
             gMultiUsePlayerCursor ^= 1;
             PlaySE(SE_SELECT);
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
             else
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
@@ -764,13 +714,13 @@ static void HandleMoveSwitching(void)
     {
         if (gMultiUsePlayerCursor & 2)
         {
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
-                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29);
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29);
             else
                 MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
             gMultiUsePlayerCursor ^= 2;
             PlaySE(SE_SELECT);
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
             else
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
@@ -780,13 +730,13 @@ static void HandleMoveSwitching(void)
     {
         if (!(gMultiUsePlayerCursor & 2) && (gMultiUsePlayerCursor ^ 2) < gNumberOfMovesToChoose)
         {
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
-                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 29);
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 29);
             else
                 MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
             gMultiUsePlayerCursor ^= 2;
             PlaySE(SE_SELECT);
-            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBattler])
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[battler])
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
             else
                 MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
@@ -794,7 +744,7 @@ static void HandleMoveSwitching(void)
     }
 }
 
-static void SetLinkBattleEndCallbacks(void)
+static void SetLinkBattleEndCallbacks(u32 battler)
 {
     if (gWirelessCommType == 0)
     {
@@ -817,7 +767,7 @@ static void SetLinkBattleEndCallbacks(void)
     }
 }
 
-void SetBattleEndCallbacks(void)
+void SetBattleEndCallbacks(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -827,7 +777,7 @@ void SetBattleEndCallbacks(void)
                 SetCloseLinkCallback();
             else
                 SetLinkStandbyCallback();
-            gBattlerControllerFuncs[gActiveBattler] = SetLinkBattleEndCallbacks;
+            gBattlerControllerFuncs[battler] = SetLinkBattleEndCallbacks;
         }
         else
         {
@@ -839,146 +789,146 @@ void SetBattleEndCallbacks(void)
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        PlayerBufferExecCompleted();
+    if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy)
+        PlayerBufferExecCompleted(battler);
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy2(void)
+static void CompleteOnBattlerSpriteCallbackDummy2(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        PlayerBufferExecCompleted();
+    if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy)
+        PlayerBufferExecCompleted(battler);
 }
 
-static void FreeTrainerSpriteAfterSlide(void)
+static void FreeTrainerSpriteAfterSlide(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
+    if (gSprites[gBattlerSpriteIds[battler]].callback == SpriteCallbackDummy)
     {
         BattleGfxSfxDummy3(gSaveBlock2Ptr->playerGender);
-        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        PlayerBufferExecCompleted();
+        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[battler]]);
+        DestroySprite(&gSprites[gBattlerSpriteIds[battler]]);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void Intro_DelayAndEnd(void)
+static void Intro_DelayAndEnd(u32 battler)
 {
-    if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == (u8)-1)
+    if (--gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay == (u8)-1)
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0;
-        PlayerBufferExecCompleted();
+        gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 0;
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void Intro_WaitForShinyAnimAndHealthbox(void)
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler)
 {
     bool8 var = FALSE;
 
     if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI)))
     {
-        if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
+        if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy)
             var = TRUE;
     }
     else
     {
-        if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy
-         && gSprites[gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK]].callback == SpriteCallbackDummy)
+        if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy
+         && gSprites[gHealthboxSpriteIds[battler ^ BIT_FLANK]].callback == SpriteCallbackDummy)
             var = TRUE;
     }
     if (IsCryPlayingOrClearCrySongs())
         var = FALSE;
-    if (var && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim
-        && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].finishedShinyMonAnim)
+    if (var && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim
+        && gBattleSpritesDataPtr->healthBoxesData[battler ^ BIT_FLANK].finishedShinyMonAnim)
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE;
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE;
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].triedShinyMonAnim = FALSE;
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].finishedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler ^ BIT_FLANK].triedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler ^ BIT_FLANK].finishedShinyMonAnim = FALSE;
         FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS);
         FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS);
             if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
                 m4aMPlayContinue(&gMPlayInfo_BGM);
             else
                 m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 256);
-        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
         if (IsDoubleBattle())
-            HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]], gActiveBattler ^ BIT_FLANK);
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 3;
-        gBattlerControllerFuncs[gActiveBattler] = Intro_DelayAndEnd;
+            HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler ^ BIT_FLANK]], battler ^ BIT_FLANK);
+        gBattleSpritesDataPtr->healthBoxesData[battler].introEndDelay = 3;
+        gBattlerControllerFuncs[battler] = Intro_DelayAndEnd;
     }
 }
 
-static void Intro_TryShinyAnimShowHealthbox(void)
+static void Intro_TryShinyAnimShowHealthbox(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].ballAnimActive)
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive && !gBattleSpritesDataPtr->healthBoxesData[battler ^ BIT_FLANK].ballAnimActive)
     {
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim)
-            TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]);
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler ^ BIT_FLANK].triedShinyMonAnim)
-            TryShinyAnimation(gActiveBattler ^ BIT_FLANK, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]]);
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim)
+            TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]);
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler ^ BIT_FLANK].triedShinyMonAnim)
+            TryShinyAnimation(battler ^ BIT_FLANK, &gPlayerParty[gBattlerPartyIndexes[battler ^ BIT_FLANK]]);
         if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
         {
-            DestroySprite(&gSprites[gBattleControllerData[gActiveBattler ^ BIT_FLANK]]);
-            UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK],
-                                     &gPlayerParty[gBattlerPartyIndexes[gActiveBattler ^ BIT_FLANK]],
+            DestroySprite(&gSprites[gBattleControllerData[battler ^ BIT_FLANK]]);
+            UpdateHealthboxAttribute(gHealthboxSpriteIds[battler ^ BIT_FLANK],
+                                     &gPlayerParty[gBattlerPartyIndexes[battler ^ BIT_FLANK]],
                                      HEALTHBOX_ALL);
-            StartHealthboxSlideIn(gActiveBattler ^ BIT_FLANK);
-            SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler ^ BIT_FLANK]);
+            StartHealthboxSlideIn(battler ^ BIT_FLANK);
+            SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler ^ BIT_FLANK]);
         }
-        DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]);
-        UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler],
-                                 &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]],
+        DestroySprite(&gSprites[gBattleControllerData[battler]]);
+        UpdateHealthboxAttribute(gHealthboxSpriteIds[battler],
+                                 &gPlayerParty[gBattlerPartyIndexes[battler]],
                                  HEALTHBOX_ALL);
-        StartHealthboxSlideIn(gActiveBattler);
-        SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]);
+        StartHealthboxSlideIn(battler);
+        SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
         gBattleSpritesDataPtr->animationData->introAnimActive = FALSE;
-        gBattlerControllerFuncs[gActiveBattler] = Intro_WaitForShinyAnimAndHealthbox;
+        gBattlerControllerFuncs[battler] = Intro_WaitForShinyAnimAndHealthbox;
     }
 }
 
-static void SwitchIn_CleanShinyAnimShowSubstitute(void)
+static void SwitchIn_CleanShinyAnimShowSubstitute(u32 battler)
 {
-    if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy
-     && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim)
+    if (gSprites[gHealthboxSpriteIds[battler]].callback == SpriteCallbackDummy
+     && gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim)
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim = FALSE;
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim = FALSE;
+        gBattleSpritesDataPtr->healthBoxesData[battler].finishedShinyMonAnim = FALSE;
         FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS);
         FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS);
-        if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute)
-            InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE);
-        gBattlerControllerFuncs[gActiveBattler] = SwitchIn_HandleSoundAndEnd;
+        if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+            InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE);
+        gBattlerControllerFuncs[battler] = SwitchIn_HandleSoundAndEnd;
     }
 }
 
-static void SwitchIn_HandleSoundAndEnd(void)
+static void SwitchIn_HandleSoundAndEnd(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive
      && !IsCryPlayingOrClearCrySongs())
     {
         m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100);
-        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        PlayerBufferExecCompleted();
+        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void SwitchIn_TryShinyAnimShowHealthbox(void)
+static void SwitchIn_TryShinyAnimShowHealthbox(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim
-     && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
-        TryShinyAnimation(gActiveBattler, &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]]);
-    if (gSprites[gBattleControllerData[gActiveBattler]].callback == SpriteCallbackDummy
-     && !(gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive))
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].triedShinyMonAnim
+     && !gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive)
+        TryShinyAnimation(battler, &gPlayerParty[gBattlerPartyIndexes[battler]]);
+    if (gSprites[gBattleControllerData[battler]].callback == SpriteCallbackDummy
+     && !(gBattleSpritesDataPtr->healthBoxesData[battler].ballAnimActive))
     {
-        DestroySprite(&gSprites[gBattleControllerData[gActiveBattler]]);
-        UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler],
-                                 &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]],
+        DestroySprite(&gSprites[gBattleControllerData[battler]]);
+        UpdateHealthboxAttribute(gHealthboxSpriteIds[battler],
+                                 &gPlayerParty[gBattlerPartyIndexes[battler]],
                                  HEALTHBOX_ALL);
-        StartHealthboxSlideIn(gActiveBattler);
-        SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]);
-        CopyBattleSpriteInvisibility(gActiveBattler);
-        gBattlerControllerFuncs[gActiveBattler] = SwitchIn_CleanShinyAnimShowSubstitute;
+        StartHealthboxSlideIn(battler);
+        SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
+        CopyBattleSpriteInvisibility(battler);
+        gBattlerControllerFuncs[battler] = SwitchIn_CleanShinyAnimShowSubstitute;
     }
 }
 
@@ -991,26 +941,26 @@ void Task_PlayerController_RestoreBgmAfterCry(u8 taskId)
     }
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
-    s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
+    s16 hpValue = MoveBattleBar(battler, gHealthboxSpriteIds[battler], HEALTH_BAR, 0);
 
-    SetHealthboxSpriteVisible(gHealthboxSpriteIds[gActiveBattler]);
+    SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
     if (hpValue != -1)
     {
-        UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], hpValue, HP_CURRENT);
+        UpdateHpTextInHealthbox(gHealthboxSpriteIds[battler], hpValue, HP_CURRENT);
     }
     else
     {
-        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        PlayerBufferExecCompleted();
+        HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-void CompleteOnInactiveTextPrinter(void)
+void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
 }
 
 #define tExpTask_monId      data[0]
@@ -1022,10 +972,10 @@ void CompleteOnInactiveTextPrinter(void)
 static void Task_GiveExpToMon(u8 taskId)
 {
     u32 monId = (u8)(gTasks[taskId].tExpTask_monId);
-    u8 battlerId = gTasks[taskId].tExpTask_battler;
+    u32 battler = gTasks[taskId].tExpTask_battler;
     s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
 
-    if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battlerId]) // Give exp without moving the expbar.
+    if (IsDoubleBattle() == TRUE || monId != gBattlerPartyIndexes[battler]) // Give exp without moving the expbar.
     {
         struct Pokemon *mon = &gPlayerParty[monId];
         u16 species = GetMonData(mon, MON_DATA_SPECIES);
@@ -1041,11 +991,11 @@ static void Task_GiveExpToMon(u8 taskId)
             CalculateMonStats(mon);
             gainedExp -= nextLvlExp - currExp;
             savedActiveBattler = gActiveBattler;
-            gActiveBattler = battlerId;
+            gActiveBattler = battler;
             BtlController_EmitTwoReturnValues(1, RET_VALUE_LEVELED_UP, gainedExp);
             gActiveBattler = savedActiveBattler;
             if (IsDoubleBattle() == TRUE
-             && ((u16)(monId) == gBattlerPartyIndexes[battlerId] || (u16)(monId) == gBattlerPartyIndexes[battlerId ^ BIT_FLANK]))
+             && ((u16)(monId) == gBattlerPartyIndexes[battler] || (u16)(monId) == gBattlerPartyIndexes[battler ^ BIT_FLANK]))
                 gTasks[taskId].func = Task_LaunchLvlUpAnim;
             else
                 gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
@@ -1054,7 +1004,7 @@ static void Task_GiveExpToMon(u8 taskId)
         {
             currExp += gainedExp;
             SetMonData(mon, MON_DATA_EXP, &currExp);
-            gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
+            gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
             DestroyTask(taskId);
         }
     }
@@ -1093,11 +1043,11 @@ static void Task_GiveExpWithExpBar(u8 taskId)
     {
         u8 monId = gTasks[taskId].tExpTask_monId;
         s16 gainedExp = gTasks[taskId].tExpTask_gainedExp;
-        u8 battlerId = gTasks[taskId].tExpTask_battler;
+        u32 battler = gTasks[taskId].tExpTask_battler;
         s16 newExpPoints;
 
-        newExpPoints = MoveBattleBar(battlerId, gHealthboxSpriteIds[battlerId], EXP_BAR, 0);
-        SetHealthboxSpriteVisible(gHealthboxSpriteIds[battlerId]);
+        newExpPoints = MoveBattleBar(battler, gHealthboxSpriteIds[battler], EXP_BAR, 0);
+        SetHealthboxSpriteVisible(gHealthboxSpriteIds[battler]);
         if (newExpPoints == -1) // The bar has been filled with given exp points.
         {
             u8 level;
@@ -1118,7 +1068,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
                 CalculateMonStats(&gPlayerParty[monId]);
                 gainedExp -= expOnNextLvl - currExp;
                 savedActiveBattler = gActiveBattler;
-                gActiveBattler = battlerId;
+                gActiveBattler = battler;
                 BtlController_EmitTwoReturnValues(1, RET_VALUE_LEVELED_UP, gainedExp);
                 gActiveBattler = savedActiveBattler;
                 gTasks[taskId].func = Task_LaunchLvlUpAnim;
@@ -1127,7 +1077,7 @@ static void Task_GiveExpWithExpBar(u8 taskId)
             {
                 currExp += gainedExp;
                 SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp);
-                gBattlerControllerFuncs[battlerId] = CompleteOnInactiveTextPrinter;
+                gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter;
                 DestroyTask(taskId);
             }
         }
@@ -1260,49 +1210,49 @@ static void Task_CreateLevelUpVerticalStripes(u8 taskId)
     }
 }
 
-static void FreeMonSpriteAfterFaintAnim(void)
+static void FreeMonSpriteAfterFaintAnim(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].y + gSprites[gBattlerSpriteIds[gActiveBattler]].y2 > DISPLAY_HEIGHT)
+    if (gSprites[gBattlerSpriteIds[battler]].y + gSprites[gBattlerSpriteIds[battler]].y2 > DISPLAY_HEIGHT)
     {
-        FreeOamMatrix(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.matrixNum);
-        DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        PlayerBufferExecCompleted();
+        FreeOamMatrix(gSprites[gBattlerSpriteIds[battler]].oam.matrixNum);
+        DestroySprite(&gSprites[gBattlerSpriteIds[battler]]);
+        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void FreeMonSpriteAfterSwitchOutAnim(void)
+static void FreeMonSpriteAfterSwitchOutAnim(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
     {
-        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        PlayerBufferExecCompleted();
+        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[battler]]);
+        DestroySprite(&gSprites[gBattlerSpriteIds[battler]]);
+        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter2(void)
+static void CompleteOnInactiveTextPrinter2(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
 }
 
-static void OpenPartyMenuToChooseMon(void)
+static void OpenPartyMenuToChooseMon(u32 battler)
 {
     if (!gPaletteFade.active)
     {
         u8 caseId;
 
-        gBattlerControllerFuncs[gActiveBattler] = WaitForMonSelection;
-        caseId = gTasks[gBattleControllerData[gActiveBattler]].data[0];
-        DestroyTask(gBattleControllerData[gActiveBattler]);
+        gBattlerControllerFuncs[battler] = WaitForMonSelection;
+        caseId = gTasks[gBattleControllerData[battler]].data[0];
+        DestroyTask(gBattleControllerData[battler]);
         FreeAllWindowBuffers();
         OpenPartyMenuInTutorialBattle(caseId);
     }
 }
 
-static void WaitForMonSelection(void)
+static void WaitForMonSelection(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
@@ -1310,48 +1260,48 @@ static void WaitForMonSelection(void)
             BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder);
         else
             BtlController_EmitChosenMonReturnValue(1, 6, NULL);
-        if ((gBattleBufferA[gActiveBattler][1] & 0xF) == 1)
+        if ((gBattleBufferA[battler][1] & 0xF) == 1)
             PrintLinkStandbyMsg();
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void OpenBagAndChooseItem(void)
+static void OpenBagAndChooseItem(u32 battler)
 {
     if (!gPaletteFade.active)
     {
-        gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChoseItem;
+        gBattlerControllerFuncs[battler] = CompleteWhenChoseItem;
         ReshowBattleScreenDummy();
         FreeAllWindowBuffers();
         CB2_BagMenuFromBattle();
     }
 }
 
-static void CompleteWhenChoseItem(void)
+static void CompleteWhenChoseItem(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
         BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnSpecialAnimDone(void)
+static void CompleteOnSpecialAnimDone(u32 battler)
 {
-    if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
-        PlayerBufferExecCompleted();
+    if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
+        PlayerBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
-    u8 spriteId = gBattlerSpriteIds[gActiveBattler];
+    u8 spriteId = gBattlerSpriteIds[battler];
 
     if (gSprites[spriteId].data[1] == 32)
     {
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else
     {
@@ -1361,10 +1311,10 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void MoveSelectionDisplayMoveNames(void)
+static void MoveSelectionDisplayMoveNames(u32 battler)
 {
     s32 i;
-    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
     gNumberOfMovesToChoose = 0;
 
     for (i = 0; i < MAX_MON_MOVES; ++i)
@@ -1384,32 +1334,32 @@ static void MoveSelectionDisplayPpString(void)
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP);
 }
 
-static void MoveSelectionDisplayPpNumber(void)
+static void MoveSelectionDisplayPpNumber(u32 battler)
 {
     u8 *txtPtr;
     struct ChooseMoveStruct *moveInfo;
 
-    if (gBattleBufferA[gActiveBattler][2] == TRUE) // check if we didn't want to display pp number
+    if (gBattleBufferA[battler][2] == TRUE) // check if we didn't want to display pp number
         return;
     SetPpNumbersPaletteInMoveSelection();
-    moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
-    txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2);
+    moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
+    txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[battler]], STR_CONV_MODE_RIGHT_ALIGN, 2);
     *txtPtr = CHAR_SLASH;
-    ConvertIntToDecimalStringN(++txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBattler]], STR_CONV_MODE_RIGHT_ALIGN, 2);
+    ConvertIntToDecimalStringN(++txtPtr, moveInfo->maxPp[gMoveSelectionCursor[battler]], STR_CONV_MODE_RIGHT_ALIGN, 2);
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_PP_REMAINING);
 }
 
-static void MoveSelectionDisplayMoveType(void)
+static void MoveSelectionDisplayMoveType(u32 battler)
 {
     u8 *txtPtr;
-    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
 
     txtPtr = StringCopy(gDisplayedStringBattle, gText_MoveInterfaceType);
     *txtPtr++ = EXT_CTRL_CODE_BEGIN;
     *txtPtr++ = 6;
     *txtPtr++ = 1;
     txtPtr = StringCopy(txtPtr, gText_MoveInterfaceDynamicColors);
-    StringCopy(txtPtr, gTypeNames[gMovesInfo[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].type]);
+    StringCopy(txtPtr, gTypeNames[gMovesInfo[moveInfo->moves[gMoveSelectionCursor[battler]]].type]);
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MOVE_TYPE);
 }
 
@@ -1463,16 +1413,16 @@ void SetCB2ToReshowScreenAfterMenu2(void)
     SetMainCallback2(ReshowBattleScreenAfterMenu);
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        PlayerBufferExecCompleted();
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].statusAnimActive)
+        PlayerBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        PlayerBufferExecCompleted();
+    if (!gBattleSpritesDataPtr->healthBoxesData[battler].animFromTableActive)
+        PlayerBufferExecCompleted(battler);
 }
 
 static void PrintLinkStandbyMsg(void)
@@ -1492,25 +1442,25 @@ static void PlayerHandleGetMonData(u32 battler)
     u8 monToCheck;
     s32 i;
 
-    if (gBattleBufferA[gActiveBattler][2] == 0)
+    if (gBattleBufferA[battler][2] == 0)
     {
-        size += CopyPlayerMonData(gBattlerPartyIndexes[gActiveBattler], monData);
+        size += CopyPlayerMonData(battler, gBattlerPartyIndexes[battler], monData);
     }
     else
     {
-        monToCheck = gBattleBufferA[gActiveBattler][2];
+        monToCheck = gBattleBufferA[battler][2];
         for (i = 0; i < PARTY_SIZE; ++i)
         {
             if (monToCheck & 1)
-                size += CopyPlayerMonData(i, monData + size);
+                size += CopyPlayerMonData(battler, i, monData + size);
             monToCheck >>= 1;
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
-static u32 CopyPlayerMonData(u8 monId, u8 *dst)
+static u32 CopyPlayerMonData(u32 battler, u8 monId, u8 *dst)
 {
     struct BattlePokemon battleMon;
     struct MovePpInfo moveData;
@@ -1520,7 +1470,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst)
     u32 data32;
     s32 size = 0;
 
-    switch (gBattleBufferA[gActiveBattler][1])
+    switch (gBattleBufferA[battler][1])
     {
     case REQUEST_ALL_BATTLE:
         battleMon.species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES);
@@ -1586,7 +1536,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst)
     case REQUEST_MOVE2_BATTLE:
     case REQUEST_MOVE3_BATTLE:
     case REQUEST_MOVE4_BATTLE:
-        data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBattler][1] - REQUEST_MOVE1_BATTLE);
+        data16 = GetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[battler][1] - REQUEST_MOVE1_BATTLE);
         dst[0] = data16;
         dst[1] = data16 >> 8;
         size = 2;
@@ -1601,7 +1551,7 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst)
     case REQUEST_PPMOVE2_BATTLE:
     case REQUEST_PPMOVE3_BATTLE:
     case REQUEST_PPMOVE4_BATTLE:
-        dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBattler][1] - REQUEST_PPMOVE1_BATTLE);
+        dst[0] = GetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[battler][1] - REQUEST_PPMOVE1_BATTLE);
         size = 1;
         break;
     case REQUEST_OTID_BATTLE:
@@ -1818,15 +1768,15 @@ static u32 CopyPlayerMonData(u8 monId, u8 *dst)
 void PlayerHandleGetRawMonData(u32 battler)
 {
     struct BattlePokemon battleMon;
-    u8 *src = (u8 *)&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
-    u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBattler][1];
+    u8 *src = (u8 *)&gPlayerParty[gBattlerPartyIndexes[battler]] + gBattleBufferA[battler][1];
+    u8 *dst = (u8 *)&battleMon + gBattleBufferA[battler][1];
     u8 i;
 
-    for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i)
+    for (i = 0; i < gBattleBufferA[battler][2]; ++i)
         dst[i] = src[i];
 
-    BtlController_EmitDataTransfer(BUFFER_B, gBattleBufferA[gActiveBattler][2], dst);
-    PlayerBufferExecCompleted();
+    BtlController_EmitDataTransfer(BUFFER_B, gBattleBufferA[battler][2], dst);
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleSetMonData(u32 battler)
@@ -1834,30 +1784,30 @@ static void PlayerHandleSetMonData(u32 battler)
     u8 monToCheck;
     u8 i;
 
-    if (gBattleBufferA[gActiveBattler][2] == 0)
+    if (gBattleBufferA[battler][2] == 0)
     {
-        SetPlayerMonData(gBattlerPartyIndexes[gActiveBattler]);
+        SetPlayerMonData(battler, gBattlerPartyIndexes[battler]);
     }
     else
     {
-        monToCheck = gBattleBufferA[gActiveBattler][2];
+        monToCheck = gBattleBufferA[battler][2];
         for (i = 0; i < PARTY_SIZE; ++i)
         {
             if (monToCheck & 1)
-                SetPlayerMonData(i);
+                SetPlayerMonData(battler, i);
             monToCheck >>= 1;
         }
     }
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
-static void SetPlayerMonData(u8 monId)
+static void SetPlayerMonData(u32 battler, u8 monId)
 {
-    struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBattler][3];
-    struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[gActiveBattler][3];
+    struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[battler][3];
+    struct MovePpInfo *moveData = (struct MovePpInfo *)&gBattleBufferA[battler][3];
     s32 i;
 
-    switch (gBattleBufferA[gActiveBattler][1])
+    switch (gBattleBufferA[battler][1])
     {
     case REQUEST_ALL_BATTLE:
         {
@@ -1898,10 +1848,10 @@ static void SetPlayerMonData(u8 monId)
         }
         break;
     case REQUEST_SPECIES_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPECIES, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_HELDITEM_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_HELD_ITEM, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_MOVES_PP_BATTLE:
         for (i = 0; i < MAX_MON_MOVES; ++i)
@@ -1915,241 +1865,241 @@ static void SetPlayerMonData(u8 monId)
     case REQUEST_MOVE2_BATTLE:
     case REQUEST_MOVE3_BATTLE:
     case REQUEST_MOVE4_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[gActiveBattler][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_MOVE1 + gBattleBufferA[battler][1] - REQUEST_MOVE1_BATTLE, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_PP_DATA_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[gActiveBattler][3]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[gActiveBattler][4]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[gActiveBattler][5]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[gActiveBattler][6]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBattler][7]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP1, &gBattleBufferA[battler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP2, &gBattleBufferA[battler][4]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP3, &gBattleBufferA[battler][5]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP4, &gBattleBufferA[battler][6]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP_BONUSES, &gBattleBufferA[battler][7]);
         break;
     case REQUEST_PPMOVE1_BATTLE:
     case REQUEST_PPMOVE2_BATTLE:
     case REQUEST_PPMOVE3_BATTLE:
     case REQUEST_PPMOVE4_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[gActiveBattler][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PP1 + gBattleBufferA[battler][1] - REQUEST_PPMOVE1_BATTLE, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_OTID_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_OT_ID, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_EXP_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_HP_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_HP_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_ATK_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_DEF_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPEED_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPATK_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPDEF_EV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_EV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_FRIENDSHIP_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_FRIENDSHIP, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_POKERUS_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_POKERUS, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_MET_LOCATION_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_MET_LOCATION, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_MET_LEVEL_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_MET_LEVEL, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_MET_GAME_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_MET_GAME, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_POKEBALL_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_POKEBALL, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_ALL_IVS_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][4]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][5]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][6]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][7]);
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][8]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[battler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[battler][4]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[battler][5]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[battler][6]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[battler][7]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[battler][8]);
         break;
     case REQUEST_HP_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_HP_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_ATK_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_ATK_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_DEF_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_DEF_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPEED_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPATK_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPDEF_IV_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF_IV, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_PERSONALITY_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_PERSONALITY, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_CHECKSUM_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_CHECKSUM, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_STATUS_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_STATUS, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_LEVEL_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_LEVEL, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_HP_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_HP, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_MAX_HP_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_MAX_HP, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_ATK_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_ATK, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_DEF_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_DEF, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPEED_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPEED, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPATK_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPATK, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SPDEF_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SPDEF, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_COOL_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_COOL, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_BEAUTY_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_CUTE_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_CUTE, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SMART_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SMART, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_TOUGH_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SHEEN_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SHEEN, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_COOL_RIBBON_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_COOL_RIBBON, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_BEAUTY_RIBBON_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_CUTE_RIBBON_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_CUTE_RIBBON, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_SMART_RIBBON_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_SMART_RIBBON, &gBattleBufferA[battler][3]);
         break;
     case REQUEST_TOUGH_RIBBON_BATTLE:
-        SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBattler][3]);
+        SetMonData(&gPlayerParty[monId], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[battler][3]);
         break;
     }
-    HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+    HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
 }
 
 static void PlayerHandleSetRawMonData(u32 battler)
 {
-    u8 *dst = (u8 *)&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]] + gBattleBufferA[gActiveBattler][1];
+    u8 *dst = (u8 *)&gPlayerParty[gBattlerPartyIndexes[battler]] + gBattleBufferA[battler][1];
     u8 i;
 
-    for (i = 0; i < gBattleBufferA[gActiveBattler][2]; ++i)
-        dst[i] = gBattleBufferA[gActiveBattler][3 + i];
-    PlayerBufferExecCompleted();
+    for (i = 0; i < gBattleBufferA[battler][2]; ++i)
+        dst[i] = gBattleBufferA[battler][3 + i];
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleLoadMonSprite(u32 battler)
 {
-    BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-    gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpritePosX_0;
+    BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
+    gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+    gBattlerControllerFuncs[battler] = CompleteOnBattlerSpritePosX_0;
 }
 
 static void PlayerHandleSwitchInAnim(u32 battler)
 {
-    ClearTemporarySpeciesSpriteData(gActiveBattler, gBattleBufferA[gActiveBattler][2]);
-    gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1];
-    BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-    gActionSelectionCursor[gActiveBattler] = 0;
-    gMoveSelectionCursor[gActiveBattler] = 0;
-    StartSendOutAnim(gActiveBattler, gBattleBufferA[gActiveBattler][2]);
-    gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnimShowHealthbox;
+    ClearTemporarySpeciesSpriteData(battler, gBattleBufferA[battler][2]);
+    gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
+    BattleLoadPlayerMonSpriteGfx(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
+    gActionSelectionCursor[battler] = 0;
+    gMoveSelectionCursor[battler] = 0;
+    StartSendOutAnim(battler, gBattleBufferA[battler][2]);
+    gBattlerControllerFuncs[battler] = SwitchIn_TryShinyAnimShowHealthbox;
 }
 
-static void StartSendOutAnim(u8 battlerId, bool8 dontClearSubstituteBit)
+static void StartSendOutAnim(u32 battler, bool8 dontClearSubstituteBit)
 {
     u16 species;
 
-    ClearTemporarySpeciesSpriteData(battlerId, dontClearSubstituteBit);
-    gBattlerPartyIndexes[battlerId] = gBattleBufferA[battlerId][1];
-    species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES);
-    gBattleControllerData[battlerId] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
-    SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battlerId));
-    gBattlerSpriteIds[battlerId] = CreateSprite(&gMultiuseSpriteTemplate,
-                                                GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2),
-                                                GetBattlerSpriteDefault_Y(battlerId),
-                                                GetBattlerSpriteSubpriority(battlerId));
-    gSprites[gBattleControllerData[battlerId]].data[1] = gBattlerSpriteIds[battlerId];
-    gSprites[gBattlerSpriteIds[battlerId]].data[0] = battlerId;
-    gSprites[gBattlerSpriteIds[battlerId]].data[2] = species;
-    gSprites[gBattlerSpriteIds[battlerId]].oam.paletteNum = battlerId;
-    StartSpriteAnim(&gSprites[gBattlerSpriteIds[battlerId]], gBattleMonForms[battlerId]);
-    gSprites[gBattlerSpriteIds[battlerId]].invisible = TRUE;
-    gSprites[gBattlerSpriteIds[battlerId]].callback = SpriteCallbackDummy;
-    gSprites[gBattleControllerData[battlerId]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
+    ClearTemporarySpeciesSpriteData(battler, dontClearSubstituteBit);
+    gBattlerPartyIndexes[battler] = gBattleBufferA[battler][1];
+    species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES);
+    gBattleControllerData[battler] = CreateInvisibleSpriteWithCallback(SpriteCB_WaitForBattlerBallReleaseAnim);
+    SetMultiuseSpriteTemplateToPokemon(species, GetBattlerPosition(battler));
+    gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
+                                                GetBattlerSpriteCoord(battler, BATTLER_COORD_X_2),
+                                                GetBattlerSpriteDefault_Y(battler),
+                                                GetBattlerSpriteSubpriority(battler));
+    gSprites[gBattleControllerData[battler]].data[1] = gBattlerSpriteIds[battler];
+    gSprites[gBattlerSpriteIds[battler]].data[0] = battler;
+    gSprites[gBattlerSpriteIds[battler]].data[2] = species;
+    gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+    StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], gBattleMonForms[battler]);
+    gSprites[gBattlerSpriteIds[battler]].invisible = TRUE;
+    gSprites[gBattlerSpriteIds[battler]].callback = SpriteCallbackDummy;
+    gSprites[gBattleControllerData[battler]].data[0] = DoPokeballSendOutAnimation(0, POKEBALL_PLAYER_SENDOUT);
 }
 
 static void PlayerHandleReturnMonToBall(u32 battler)
 {
-    if (gBattleBufferA[gActiveBattler][1] == 0)
+    if (gBattleBufferA[battler][1] == 0)
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-        gBattlerControllerFuncs[gActiveBattler] = DoSwitchOutAnimation;
+        gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0;
+        gBattlerControllerFuncs[battler] = DoSwitchOutAnimation;
     }
     else
     {
-        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        PlayerBufferExecCompleted();
+        FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[battler]]);
+        DestroySprite(&gSprites[gBattlerSpriteIds[battler]]);
+        SetHealthboxSpriteInvisible(gHealthboxSpriteIds[battler]);
+        PlayerBufferExecCompleted(battler);
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
-    switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
+    switch (gBattleSpritesDataPtr->healthBoxesData[battler].animationState)
     {
     case 0:
-        if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute)
-            InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON);
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1;
+        if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+            InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SUBSTITUTE_TO_MON);
+        gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 1;
         break;
     case 1:
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
         {
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SWITCH_OUT_PLAYER_MON);
-            gBattlerControllerFuncs[gActiveBattler] = FreeMonSpriteAfterSwitchOutAnim;
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0;
+            InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SWITCH_OUT_PLAYER_MON);
+            gBattlerControllerFuncs[battler] = FreeMonSpriteAfterSwitchOutAnim;
         }
         break;
     }
@@ -2162,7 +2112,7 @@ static void PlayerHandleDrawTrainerPic(u32 battler)
 
     if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
     {
-        if ((GetBattlerPosition(gActiveBattler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right.
+        if ((GetBattlerPosition(battler) & BIT_FLANK) != B_FLANK_LEFT) // Second mon, on the right.
             xPos = 90;
         else // First mon, on the left.
             xPos = 32;
@@ -2185,17 +2135,17 @@ static void PlayerHandleDrawTrainerPic(u32 battler)
     {
         trainerPicId = gSaveBlock2Ptr->playerGender;
     }
-    DecompressTrainerBackPalette(trainerPicId, gActiveBattler);
-    SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(gActiveBattler));
-    gBattlerSpriteIds[gActiveBattler] = CreateSprite(&gMultiuseSpriteTemplate,
+    DecompressTrainerBackPalette(trainerPicId, battler);
+    SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(battler));
+    gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
                                                      xPos,
                                                      (8 - gTrainerBackPicCoords[trainerPicId].size) * 4 + 80,
-                                                     GetBattlerSpriteSubpriority(gActiveBattler));
-    gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].x2 = DISPLAY_WIDTH;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = -2;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_TrainerSlideIn;
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
+                                                     GetBattlerSpriteSubpriority(battler));
+    gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+    gSprites[gBattlerSpriteIds[battler]].x2 = DISPLAY_WIDTH;
+    gSprites[gBattlerSpriteIds[battler]].data[0] = -2;
+    gSprites[gBattlerSpriteIds[battler]].callback = SpriteCB_TrainerSlideIn;
+    gBattlerControllerFuncs[battler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
 static void PlayerHandleTrainerSlide(u32 battler)
@@ -2215,50 +2165,50 @@ static void PlayerHandleTrainerSlide(u32 battler)
     {
         trainerPicId = gSaveBlock2Ptr->playerGender + 0;
     }
-    DecompressTrainerBackPalette(trainerPicId, gActiveBattler);
-    SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(gActiveBattler));
-    gBattlerSpriteIds[gActiveBattler] = CreateSprite(&gMultiuseSpriteTemplate,
+    DecompressTrainerBackPalette(trainerPicId, battler);
+    SetMultiuseSpriteTemplateToTrainerBack(trainerPicId, GetBattlerPosition(battler));
+    gBattlerSpriteIds[battler] = CreateSprite(&gMultiuseSpriteTemplate,
                                                      80,
                                                      (8 - gTrainerBackPicCoords[trainerPicId].size) * 4 + 80,
                                                      30);
-    gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = gActiveBattler;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].x2 = -96;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 2;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_TrainerSlideIn;
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy2;
+    gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = battler;
+    gSprites[gBattlerSpriteIds[battler]].x2 = -96;
+    gSprites[gBattlerSpriteIds[battler]].data[0] = 2;
+    gSprites[gBattlerSpriteIds[battler]].callback = SpriteCB_TrainerSlideIn;
+    gBattlerControllerFuncs[battler] = CompleteOnBattlerSpriteCallbackDummy2;
 }
 
 static void PlayerHandleTrainerSlideBack(u32 battler)
 {
-    SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 50;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = -40;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[4] = gSprites[gBattlerSpriteIds[gActiveBattler]].y;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].callback = StartAnimLinearTranslation;
-    StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[gActiveBattler]], SpriteCallbackDummy);
-    StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 1);
-    gBattlerControllerFuncs[gActiveBattler] = FreeTrainerSpriteAfterSlide;
+    SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[battler]]);
+    gSprites[gBattlerSpriteIds[battler]].data[0] = 50;
+    gSprites[gBattlerSpriteIds[battler]].data[2] = -40;
+    gSprites[gBattlerSpriteIds[battler]].data[4] = gSprites[gBattlerSpriteIds[battler]].y;
+    gSprites[gBattlerSpriteIds[battler]].callback = StartAnimLinearTranslation;
+    StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[battler]], SpriteCallbackDummy);
+    StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 1);
+    gBattlerControllerFuncs[battler] = FreeTrainerSpriteAfterSlide;
 }
 
 static void PlayerHandleFaintAnimation(u32 battler)
 {
-    if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0)
+    if (gBattleSpritesDataPtr->healthBoxesData[battler].animationState == 0)
     {
-        if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute)
-            InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON);
-        ++gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState;
+        if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute)
+            InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SUBSTITUTE_TO_MON);
+        ++gBattleSpritesDataPtr->healthBoxesData[battler].animationState;
     }
     else
     {
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
         {
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0;
+            HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[battler]], battler);
             PlaySE12WithPanning(SE_FAINT, SOUND_PAN_ATTACKER);
-            gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0;
-            gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = 5;
-            gSprites[gBattlerSpriteIds[gActiveBattler]].callback = SpriteCB_FaintSlideAnim;
-            gBattlerControllerFuncs[gActiveBattler] = FreeMonSpriteAfterFaintAnim;
+            gSprites[gBattlerSpriteIds[battler]].data[1] = 0;
+            gSprites[gBattlerSpriteIds[battler]].data[2] = 5;
+            gSprites[gBattlerSpriteIds[battler]].callback = SpriteCB_FaintSlideAnim;
+            gBattlerControllerFuncs[battler] = FreeMonSpriteAfterFaintAnim;
         }
     }
 }
@@ -2266,83 +2216,83 @@ static void PlayerHandleFaintAnimation(u32 battler)
 static void PlayerHandlePaletteFade(u32 battler)
 {
     BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleSuccessBallThrowAnim(u32 battler)
 {
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS;
     gDoingBattleAnim = TRUE;
-    InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW);
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
+    InitAndLaunchSpecialAnimation(battler, battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW);
+    gBattlerControllerFuncs[battler] = CompleteOnSpecialAnimDone;
 }
 
 static void PlayerHandleBallThrowAnim(u32 battler)
 {
-    u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1];
+    u8 ballThrowCaseId = gBattleBufferA[battler][1];
 
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = ballThrowCaseId;
     gDoingBattleAnim = TRUE;
-    InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW);
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
+    InitAndLaunchSpecialAnimation(battler, battler, GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT), B_ANIM_BALL_THROW);
+    gBattlerControllerFuncs[battler] = CompleteOnSpecialAnimDone;
 }
 
 static void PlayerHandlePause(u32 battler)
 {
-    u8 var = gBattleBufferA[gActiveBattler][1];
+    u8 var = gBattleBufferA[battler][1];
 
     while (var)
         --var;
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleMoveAnimation(u32 battler)
 {
-    if (!IsBattleSEPlaying(gActiveBattler))
+    if (!IsBattleSEPlaying(battler))
     {
-        u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
+        u16 move = gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8);
 
-        gAnimMoveTurn = gBattleBufferA[gActiveBattler][3];
-        gAnimMovePower = gBattleBufferA[gActiveBattler][4] | (gBattleBufferA[gActiveBattler][5] << 8);
-        gAnimMoveDmg = gBattleBufferA[gActiveBattler][6] | (gBattleBufferA[gActiveBattler][7] << 8) | (gBattleBufferA[gActiveBattler][8] << 16) | (gBattleBufferA[gActiveBattler][9] << 24);
-        gAnimFriendship = gBattleBufferA[gActiveBattler][10];
-        gWeatherMoveAnim = gBattleBufferA[gActiveBattler][12] | (gBattleBufferA[gActiveBattler][13] << 8);
-        gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[gActiveBattler][16];
-        gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
+        gAnimMoveTurn = gBattleBufferA[battler][3];
+        gAnimMovePower = gBattleBufferA[battler][4] | (gBattleBufferA[battler][5] << 8);
+        gAnimMoveDmg = gBattleBufferA[battler][6] | (gBattleBufferA[battler][7] << 8) | (gBattleBufferA[battler][8] << 16) | (gBattleBufferA[battler][9] << 24);
+        gAnimFriendship = gBattleBufferA[battler][10];
+        gWeatherMoveAnim = gBattleBufferA[battler][12] | (gBattleBufferA[battler][13] << 8);
+        gAnimDisableStructPtr = (struct DisableStruct *)&gBattleBufferA[battler][16];
+        gTransformedPersonalities[battler] = gAnimDisableStructPtr->transformedMonPersonality;
         if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // Always returns FALSE.
         {
-            PlayerBufferExecCompleted();
+            PlayerBufferExecCompleted(battler);
         }
         else
         {
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            gBattlerControllerFuncs[gActiveBattler] = PlayerDoMoveAnimation;
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0;
+            gBattlerControllerFuncs[battler] = PlayerDoMoveAnimation;
         }
     }
 }
 
-static void PlayerDoMoveAnimation(void)
+static void PlayerDoMoveAnimation(u32 battler)
 {
-    u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
-    u8 multihit = gBattleBufferA[gActiveBattler][11];
+    u16 move = gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8);
+    u8 multihit = gBattleBufferA[battler][11];
 
-    switch (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState)
+    switch (gBattleSpritesDataPtr->healthBoxesData[battler].animationState)
     {
     case 0:
-        if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute
-         && !gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8)
+        if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute
+         && !gBattleSpritesDataPtr->battlerData[battler].flag_x8)
         {
-            gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 1;
-            InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_SUBSTITUTE_TO_MON);
+            gBattleSpritesDataPtr->battlerData[battler].flag_x8 = 1;
+            InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_SUBSTITUTE_TO_MON);
         }
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 1;
+        gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 1;
         break;
     case 1:
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
         {
             SetBattlerSpriteAffineMode(ST_OAM_AFFINE_OFF);
             DoMoveAnim(move);
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 2;
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 2;
         }
         break;
     case 2:
@@ -2350,21 +2300,21 @@ static void PlayerDoMoveAnimation(void)
         if (!gAnimScriptActive)
         {
             SetBattlerSpriteAffineMode(ST_OAM_AFFINE_NORMAL);
-            if (gBattleSpritesDataPtr->battlerData[gActiveBattler].behindSubstitute && multihit < 2)
+            if (gBattleSpritesDataPtr->battlerData[battler].behindSubstitute && multihit < 2)
             {
-                InitAndLaunchSpecialAnimation(gActiveBattler, gActiveBattler, gActiveBattler, B_ANIM_MON_TO_SUBSTITUTE);
-                gBattleSpritesDataPtr->battlerData[gActiveBattler].flag_x8 = 0;
+                InitAndLaunchSpecialAnimation(battler, battler, battler, B_ANIM_MON_TO_SUBSTITUTE);
+                gBattleSpritesDataPtr->battlerData[battler].flag_x8 = 0;
             }
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 3;
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 3;
         }
         break;
     case 3:
-        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
+        if (!gBattleSpritesDataPtr->healthBoxesData[battler].specialAnimActive)
         {
             CopyAllBattleSpritesInvisibilities();
-            TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            PlayerBufferExecCompleted();
+            TrySetBehindSubstituteSpriteBit(battler, gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8));
+            gBattleSpritesDataPtr->healthBoxesData[battler].animationState = 0;
+            PlayerBufferExecCompleted(battler);
         }
         break;
     }
@@ -2376,13 +2326,13 @@ static void PlayerHandlePrintString(u32 battler)
 
     gBattle_BG0_X = 0;
     gBattle_BG0_Y = 0;
-    stringId = (u16 *)(&gBattleBufferA[gActiveBattler][2]);
+    stringId = (u16 *)(&gBattleBufferA[battler][2]);
     BufferStringBattle(*stringId);
     if (BattleStringShouldBeColored(*stringId))
         BattlePutTextOnWindow(gDisplayedStringBattle, (B_WIN_MSG | B_TEXT_FLAG_NPC_CONTEXT_FONT));
     else
         BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_MSG);
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter2;
+    gBattlerControllerFuncs[battler] = CompleteOnInactiveTextPrinter2;
 }
 
 static void PlayerHandlePrintSelectionString(u32 battler)
@@ -2390,16 +2340,16 @@ static void PlayerHandlePrintSelectionString(u32 battler)
     if (GetBattlerSide(battler) == B_SIDE_PLAYER)
         PlayerHandlePrintString(battler);
     else
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
 }
 
-static void HandleChooseActionAfterDma3(void)
+static void HandleChooseActionAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
         gBattle_BG0_X = 0;
         gBattle_BG0_Y = 160;
-        gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseAction;
+        gBattlerControllerFuncs[battler] = HandleInputChooseAction;
     }
 }
 
@@ -2407,13 +2357,13 @@ static void PlayerHandleChooseAction(u32 battler)
 {
     s32 i;
 
-    gBattlerControllerFuncs[gActiveBattler] = HandleChooseActionAfterDma3;
+    gBattlerControllerFuncs[battler] = HandleChooseActionAfterDma3;
     BattlePutTextOnWindow(gText_EmptyString3, B_WIN_MSG);
     BattlePutTextOnWindow(gText_BattleMenu, B_WIN_ACTION_MENU);
     for (i = 0; i < 4; ++i)
         ActionSelectionDestroyCursorAt(i);
-    ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBattler], 0);
-    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, gActiveBattler, gBattlerPartyIndexes[gActiveBattler]);
+    ActionSelectionCreateCursorAt(gActionSelectionCursor[battler], 0);
+    PREPARE_MON_NICK_BUFFER(gBattleTextBuff1, battler, gBattlerPartyIndexes[battler]);
     BattleStringExpandPlaceholdersToDisplayedString(gText_WhatWillPkmnDo);
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT);
 }
@@ -2422,30 +2372,30 @@ static void PlayerHandleUnknownYesNoBox(u32 battler)
 {
 }
 
-static void HandleChooseMoveAfterDma3(void)
+static void HandleChooseMoveAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
         gBattle_BG0_X = 0;
         gBattle_BG0_Y = 320;
-        gBattlerControllerFuncs[gActiveBattler] = HandleInputChooseMove;
+        gBattlerControllerFuncs[battler] = HandleInputChooseMove;
     }
 }
 
 static void PlayerHandleChooseMove(u32 battler)
 {
-    InitMoveSelectionsVarsAndStrings();
-    gBattlerControllerFuncs[gActiveBattler] = HandleChooseMoveAfterDma3;
+    InitMoveSelectionsVarsAndStrings(battler);
+    gBattlerControllerFuncs[battler] = HandleChooseMoveAfterDma3;
 }
 
-void InitMoveSelectionsVarsAndStrings(void)
+void InitMoveSelectionsVarsAndStrings(u32 battler)
 {
-    MoveSelectionDisplayMoveNames();
+    MoveSelectionDisplayMoveNames(battler);
     gMultiUsePlayerCursor = 0xFF;
-    MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBattler], 0);
+    MoveSelectionCreateCursorAt(gMoveSelectionCursor[battler], 0);
     MoveSelectionDisplayPpString();
-    MoveSelectionDisplayPpNumber();
-    MoveSelectionDisplayMoveType();
+    MoveSelectionDisplayPpNumber(battler);
+    MoveSelectionDisplayMoveType(battler);
 }
 
 static void PlayerHandleChooseItem(u32 battler)
@@ -2453,33 +2403,33 @@ static void PlayerHandleChooseItem(u32 battler)
     s32 i;
 
     BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK);
-    gBattlerControllerFuncs[gActiveBattler] = OpenBagAndChooseItem;
-    gBattlerInMenuId = gActiveBattler;
+    gBattlerControllerFuncs[battler] = OpenBagAndChooseItem;
+    gBattlerInMenuId = battler;
     for (i = 0; i < 3; ++i)
-        gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][1 + i];
+        gBattlePartyCurrentOrder[i] = gBattleBufferA[battler][1 + i];
 }
 
 static void PlayerHandleChoosePokemon(u32 battler)
 {
     s32 i;
 
-    gBattleControllerData[gActiveBattler] = CreateTask(TaskDummy, 0xFF);
-    gTasks[gBattleControllerData[gActiveBattler]].data[0] = gBattleBufferA[gActiveBattler][1] & 0xF;
-    *(&gBattleStruct->battlerPreventingSwitchout) = gBattleBufferA[gActiveBattler][1] >> 4;
-    *(&gBattleStruct->playerPartyIdx) = gBattleBufferA[gActiveBattler][2];
-    *(&gBattleStruct->abilityPreventingSwitchout) = (gBattleBufferA[gActiveBattler][3] & 0xFF) | (gBattleBufferA[gActiveBattler][7] << 8);
+    gBattleControllerData[battler] = CreateTask(TaskDummy, 0xFF);
+    gTasks[gBattleControllerData[battler]].data[0] = gBattleBufferA[battler][1] & 0xF;
+    *(&gBattleStruct->battlerPreventingSwitchout) = gBattleBufferA[battler][1] >> 4;
+    *(&gBattleStruct->playerPartyIdx) = gBattleBufferA[battler][2];
+    *(&gBattleStruct->abilityPreventingSwitchout) = (gBattleBufferA[battler][3] & 0xFF) | (gBattleBufferA[battler][7] << 8);
     for (i = 0; i < 3; ++i)
-        gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][4 + i];
+        gBattlePartyCurrentOrder[i] = gBattleBufferA[battler][4 + i];
     BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK);
-    gBattlerControllerFuncs[gActiveBattler] = OpenPartyMenuToChooseMon;
-    gBattlerInMenuId = gActiveBattler;
+    gBattlerControllerFuncs[battler] = OpenPartyMenuToChooseMon;
+    gBattlerInMenuId = battler;
 }
 
 static void PlayerHandleCmd23(u32 battler)
 {
     BattleStopLowHpSound();
     BeginNormalPaletteFade(PALETTES_ALL, 2, 0, 16, RGB_BLACK);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleHealthBarUpdate(u32 battler)
@@ -2487,31 +2437,31 @@ static void PlayerHandleHealthBarUpdate(u32 battler)
     s16 hpVal;
 
     LoadBattleBarGfx(0);
-    hpVal = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
+    hpVal = gBattleBufferA[battler][2] | (gBattleBufferA[battler][3] << 8);
     if (hpVal != INSTANT_HP_BAR_DROP)
     {
-        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP);
-        u32 curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_HP);
+        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MAX_HP);
+        u32 curHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_HP);
 
-        SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, curHP, hpVal);
+        SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, curHP, hpVal);
     }
     else
     {
-        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_MAX_HP);
+        u32 maxHP = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_MAX_HP);
 
-        SetBattleBarStruct(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], maxHP, 0, hpVal);
-        UpdateHpTextInHealthbox(gHealthboxSpriteIds[gActiveBattler], 0, HP_CURRENT);
+        SetBattleBarStruct(battler, gHealthboxSpriteIds[battler], maxHP, 0, hpVal);
+        UpdateHpTextInHealthbox(gHealthboxSpriteIds[battler], 0, HP_CURRENT);
     }
-    gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
+    gBattlerControllerFuncs[battler] = CompleteOnHealthbarDone;
 }
 
 static void PlayerHandleExpUpdate(u32 battler)
 {
-    u8 monId = gBattleBufferA[gActiveBattler][1];
+    u8 monId = gBattleBufferA[battler][1];
 
     if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL)
     {
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else
     {
@@ -2520,59 +2470,59 @@ static void PlayerHandleExpUpdate(u32 battler)
 
         LoadBattleBarGfx(1);
         GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES);  // Unused return value.
-        expPointsToGive = T1_READ_16(&gBattleBufferA[gActiveBattler][2]);
+        expPointsToGive = T1_READ_16(&gBattleBufferA[battler][2]);
         taskId = CreateTask(Task_GiveExpToMon, 10);
         gTasks[taskId].tExpTask_monId = monId;
         gTasks[taskId].tExpTask_gainedExp = expPointsToGive;
-        gTasks[taskId].tExpTask_battler = gActiveBattler;
-        gBattlerControllerFuncs[gActiveBattler] = BattleControllerDummy;
+        gTasks[taskId].tExpTask_battler = battler;
+        gBattlerControllerFuncs[battler] = BattleControllerDummy;
     }
 }
 
 static void PlayerHandleStatusIconUpdate(u32 battler)
 {
-    if (!IsBattleSEPlaying(gActiveBattler))
+    if (!IsBattleSEPlaying(battler))
     {
         u8 battlerId;
 
-        UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_STATUS_ICON);
-        battlerId = gActiveBattler;
+        UpdateHealthboxAttribute(gHealthboxSpriteIds[battler], &gPlayerParty[gBattlerPartyIndexes[battler]], HEALTHBOX_STATUS_ICON);
+        battlerId = battler;
         gBattleSpritesDataPtr->healthBoxesData[battlerId].statusAnimActive = FALSE;
-        gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
+        gBattlerControllerFuncs[battler] = CompleteOnFinishedStatusAnimation;
     }
 }
 
 static void PlayerHandleStatusAnimation(u32 battler)
 {
-    if (!IsBattleSEPlaying(gActiveBattler))
+    if (!IsBattleSEPlaying(battler))
     {
-        InitAndLaunchChosenStatusAnimation(gBattleBufferA[gActiveBattler][1],
-                                           gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8) | (gBattleBufferA[gActiveBattler][4] << 16) | (gBattleBufferA[gActiveBattler][5] << 24));
-        gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedStatusAnimation;
+        InitAndLaunchChosenStatusAnimation(gBattleBufferA[battler][1],
+                                           gBattleBufferA[battler][2] | (gBattleBufferA[battler][3] << 8) | (gBattleBufferA[battler][4] << 16) | (gBattleBufferA[battler][5] << 24));
+        gBattlerControllerFuncs[battler] = CompleteOnFinishedStatusAnimation;
     }
 }
 
 static void PlayerHandleStatusXor(u32 battler)
 {
-    u8 val = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS) ^ gBattleBufferA[gActiveBattler][1];
+    u8 val = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS) ^ gBattleBufferA[battler][1];
 
-    SetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_STATUS, &val);
-    PlayerBufferExecCompleted();
+    SetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_STATUS, &val);
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleDataTransfer(u32 battler)
 {
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleDMA3Transfer(u32 battler)
 {
-    u32 dstArg = gBattleBufferA[gActiveBattler][1]
-               | (gBattleBufferA[gActiveBattler][2] << 8)
-               | (gBattleBufferA[gActiveBattler][3] << 16)
-               | (gBattleBufferA[gActiveBattler][4] << 24);
-    u16 sizeArg = gBattleBufferA[gActiveBattler][5] | (gBattleBufferA[gActiveBattler][6] << 8);
-    const u8 *src = &gBattleBufferA[gActiveBattler][7];
+    u32 dstArg = gBattleBufferA[battler][1]
+               | (gBattleBufferA[battler][2] << 8)
+               | (gBattleBufferA[battler][3] << 16)
+               | (gBattleBufferA[battler][4] << 24);
+    u16 sizeArg = gBattleBufferA[battler][5] | (gBattleBufferA[battler][6] << 8);
+    const u8 *src = &gBattleBufferA[battler][7];
     u8 *dst = (u8 *)(dstArg);
     u32 size = sizeArg;
 
@@ -2588,117 +2538,117 @@ static void PlayerHandleDMA3Transfer(u32 battler)
         dst += 0x1000;
         size -= 0x1000;
     }
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandlePlayBGM(u32 battler)
 {
-    PlayBGM(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    PlayerBufferExecCompleted();
+    PlayBGM(gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8));
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd32(u32 battler)
 {
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleTwoReturnValues(u32 battler)
 {
     BtlController_EmitTwoReturnValues(1, 0, 0);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleChosenMonReturnValue(u32 battler)
 {
     BtlController_EmitChosenMonReturnValue(1, 0, NULL);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleOneReturnValue(u32 battler)
 {
     BtlController_EmitOneReturnValue(1, 0);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleOneReturnValue_Duplicate(u32 battler)
 {
     BtlController_EmitOneReturnValue_Duplicate(1, 0);
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd37(u32 battler)
 {
     gUnusedControllerStruct.unk = 0;
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd38(u32 battler)
 {
-    gUnusedControllerStruct.unk = gBattleBufferA[gActiveBattler][1];
-    PlayerBufferExecCompleted();
+    gUnusedControllerStruct.unk = gBattleBufferA[battler][1];
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd39(u32 battler)
 {
     gUnusedControllerStruct.flag = 0;
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd40(u32 battler)
 {
     gUnusedControllerStruct.flag ^= 1;
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleHitAnimation(u32 battler)
 {
-    if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
+    if (gSprites[gBattlerSpriteIds[battler]].invisible == TRUE)
     {
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else
     {
         gDoingBattleAnim = TRUE;
-        gSprites[gBattlerSpriteIds[gActiveBattler]].data[1] = 0;
-        DoHitAnimHealthboxEffect(gActiveBattler);
-        gBattlerControllerFuncs[gActiveBattler] = DoHitAnimBlinkSpriteEffect;
+        gSprites[gBattlerSpriteIds[battler]].data[1] = 0;
+        DoHitAnimHealthboxEffect(battler);
+        gBattlerControllerFuncs[battler] = DoHitAnimBlinkSpriteEffect;
     }
 }
 
 static void PlayerHandleCmd42(u32 battler)
 {
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandlePlaySE(u32 battler)
 {
     s8 pan;
 
-    if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
+    if (GetBattlerSide(battler) == B_SIDE_PLAYER)
         pan = SOUND_PAN_ATTACKER;
     else
         pan = SOUND_PAN_TARGET;
-    PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
-    PlayerBufferExecCompleted();
+    PlaySE12WithPanning(gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8), pan);
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandlePlayFanfare(u32 battler)
 {
-    PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    PlayerBufferExecCompleted();
+    PlayFanfare(gBattleBufferA[battler][1] | (gBattleBufferA[battler][2] << 8));
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleFaintingCry(u32 battler)
 {
-    PlayCry_ByMode(GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES), -25, CRY_MODE_FAINT);
-    PlayerBufferExecCompleted();
+    PlayCry_ByMode(GetMonData(&gPlayerParty[gBattlerPartyIndexes[battler]], MON_DATA_SPECIES), -25, CRY_MODE_FAINT);
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleIntroSlide(u32 battler)
 {
-    HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
+    HandleIntroSlide(gBattleBufferA[battler][1]);
     gIntroSlideFlags |= 1;
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleIntroTrainerBallThrow(u32 battler)
@@ -2706,23 +2656,23 @@ static void PlayerHandleIntroTrainerBallThrow(u32 battler)
     u8 paletteNum;
     u8 taskId;
 
-    SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[0] = 50;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[2] = -40;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[4] = gSprites[gBattlerSpriteIds[gActiveBattler]].y;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].callback = PlayerThrowBall_StartAnimLinearTranslation;
-    gSprites[gBattlerSpriteIds[gActiveBattler]].data[5] = gActiveBattler;
-    StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[gActiveBattler]], SpriteCB_FreePlayerSpriteLoadMonSprite);
-    StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], 1);
+    SetSpritePrimaryCoordsFromSecondaryCoords(&gSprites[gBattlerSpriteIds[battler]]);
+    gSprites[gBattlerSpriteIds[battler]].data[0] = 50;
+    gSprites[gBattlerSpriteIds[battler]].data[2] = -40;
+    gSprites[gBattlerSpriteIds[battler]].data[4] = gSprites[gBattlerSpriteIds[battler]].y;
+    gSprites[gBattlerSpriteIds[battler]].callback = PlayerThrowBall_StartAnimLinearTranslation;
+    gSprites[gBattlerSpriteIds[battler]].data[5] = battler;
+    StoreSpriteCallbackInData6(&gSprites[gBattlerSpriteIds[battler]], SpriteCB_FreePlayerSpriteLoadMonSprite);
+    StartSpriteAnim(&gSprites[gBattlerSpriteIds[battler]], 1);
     paletteNum = AllocSpritePalette(0xD6F8);
     LoadCompressedPalette(gTrainerBackPicPaletteTable[gSaveBlock2Ptr->playerGender].data, OBJ_PLTT_ID(paletteNum), PLTT_SIZE_4BPP);
-    gSprites[gBattlerSpriteIds[gActiveBattler]].oam.paletteNum = paletteNum;
+    gSprites[gBattlerSpriteIds[battler]].oam.paletteNum = paletteNum;
     taskId = CreateTask(Task_StartSendOutAnim, 5);
-    gTasks[taskId].data[0] = gActiveBattler;
-    if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
-        gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
+    gTasks[taskId].data[0] = battler;
+    if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown)
+        gTasks[gBattlerStatusSummaryTaskId[battler]].func = Task_HidePartyStatusSummary;
     gBattleSpritesDataPtr->animationData->introAnimActive = TRUE;
-    gBattlerControllerFuncs[gActiveBattler] = BattleControllerDummy;
+    gBattlerControllerFuncs[battler] = BattleControllerDummy;
 }
 
 void SpriteCB_FreePlayerSpriteLoadMonSprite(struct Sprite *sprite)
@@ -2744,9 +2694,10 @@ static void Task_StartSendOutAnim(u8 taskId)
     }
     else
     {
+        u32 battler;
         u8 savedActiveBattler = gActiveBattler;
 
-        gActiveBattler = gTasks[taskId].data[0];
+        gActiveBattler = battler = gTasks[taskId].data[0];
         if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI))
         {
             gBattleBufferA[gActiveBattler][1] = gBattlerPartyIndexes[gActiveBattler];
@@ -2770,118 +2721,118 @@ static void Task_StartSendOutAnim(u8 taskId)
 
 static void PlayerHandleDrawPartyStatusSummary(u32 battler)
 {
-    if (gBattleBufferA[gActiveBattler][1] && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
+    if (gBattleBufferA[battler][1] && GetBattlerSide(battler) == B_SIDE_PLAYER)
     {
-        PlayerBufferExecCompleted();
+        PlayerBufferExecCompleted(battler);
     }
     else
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown = TRUE;
-        gBattlerStatusSummaryTaskId[gActiveBattler] = CreatePartyStatusSummarySprites(gActiveBattler, (struct HpAndStatus *)&gBattleBufferA[gActiveBattler][4], gBattleBufferA[gActiveBattler][1], gBattleBufferA[gActiveBattler][2]);
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0;
-        if (gBattleBufferA[gActiveBattler][2] != 0)
-            gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 93;
-        gBattlerControllerFuncs[gActiveBattler] = EndDrawPartyStatusSummary;
+        gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown = TRUE;
+        gBattlerStatusSummaryTaskId[battler] = CreatePartyStatusSummarySprites(battler, (struct HpAndStatus *)&gBattleBufferA[battler][4], gBattleBufferA[battler][1], gBattleBufferA[battler][2]);
+        gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer = 0;
+        if (gBattleBufferA[battler][2] != 0)
+            gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer = 93;
+        gBattlerControllerFuncs[battler] = EndDrawPartyStatusSummary;
     }
 }
 
-static void EndDrawPartyStatusSummary(void)
+static void EndDrawPartyStatusSummary(u32 battler)
 {
-    if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer++ > 0x5C)
+    if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer++ > 0x5C)
     {
-        gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusDelayTimer = 0;
-        PlayerBufferExecCompleted();
+        gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusDelayTimer = 0;
+        PlayerBufferExecCompleted(battler);
     }
 }
 
 static void PlayerHandleHidePartyStatusSummary(u32 battler)
 {
-    if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].partyStatusSummaryShown)
-        gTasks[gBattlerStatusSummaryTaskId[gActiveBattler]].func = Task_HidePartyStatusSummary;
-    PlayerBufferExecCompleted();
+    if (gBattleSpritesDataPtr->healthBoxesData[battler].partyStatusSummaryShown)
+        gTasks[gBattlerStatusSummaryTaskId[battler]].func = Task_HidePartyStatusSummary;
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleEndBounceEffect(u32 battler)
 {
-    EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX);
-    EndBounceEffect(gActiveBattler, BOUNCE_MON);
-    PlayerBufferExecCompleted();
+    EndBounceEffect(battler, BOUNCE_HEALTHBOX);
+    EndBounceEffect(battler, BOUNCE_MON);
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleSpriteInvisibility(u32 battler)
 {
-    if (IsBattlerSpritePresent(gActiveBattler))
+    if (IsBattlerSpritePresent(battler))
     {
-        gSprites[gBattlerSpriteIds[gActiveBattler]].invisible = gBattleBufferA[gActiveBattler][1];
-        CopyBattleSpriteInvisibility(gActiveBattler);
+        gSprites[gBattlerSpriteIds[battler]].invisible = gBattleBufferA[battler][1];
+        CopyBattleSpriteInvisibility(battler);
     }
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleBattleAnimation(u32 battler)
 {
-    if (!IsBattleSEPlaying(gActiveBattler))
+    if (!IsBattleSEPlaying(battler))
     {
-        u8 animationId = gBattleBufferA[gActiveBattler][1];
-        u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
+        u8 animationId = gBattleBufferA[battler][1];
+        u16 argument = gBattleBufferA[battler][2] | (gBattleBufferA[battler][3] << 8);
 
-        if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-            PlayerBufferExecCompleted();
+        if (TryHandleLaunchBattleTableAnimation(battler, battler, battler, animationId, argument))
+            PlayerBufferExecCompleted(battler);
         else
-            gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
+            gBattlerControllerFuncs[battler] = CompleteOnFinishedBattleAnimation;
     }
 }
 
 static void PlayerHandleLinkStandbyMsg(u32 battler)
 {
-    switch (gBattleBufferA[gActiveBattler][1])
+    switch (gBattleBufferA[battler][1])
     {
     case 0:
         PrintLinkStandbyMsg();
         // fall through
     case 1:
-        EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX);
-        EndBounceEffect(gActiveBattler, BOUNCE_MON);
+        EndBounceEffect(battler, BOUNCE_HEALTHBOX);
+        EndBounceEffect(battler, BOUNCE_MON);
         break;
     case 2:
         PrintLinkStandbyMsg();
         break;
     }
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleResetActionMoveSelection(u32 battler)
 {
-    switch (gBattleBufferA[gActiveBattler][1])
+    switch (gBattleBufferA[battler][1])
     {
     case RESET_ACTION_MOVE_SELECTION:
-        gActionSelectionCursor[gActiveBattler] = 0;
-        gMoveSelectionCursor[gActiveBattler] = 0;
+        gActionSelectionCursor[battler] = 0;
+        gMoveSelectionCursor[battler] = 0;
         break;
     case RESET_ACTION_SELECTION:
-        gActionSelectionCursor[gActiveBattler] = 0;
+        gActionSelectionCursor[battler] = 0;
         break;
     case RESET_MOVE_SELECTION:
-        gMoveSelectionCursor[gActiveBattler] = 0;
+        gMoveSelectionCursor[battler] = 0;
         break;
     }
-    PlayerBufferExecCompleted();
+    PlayerBufferExecCompleted(battler);
 }
 
 static void PlayerHandleCmd55(u32 battler)
 {
-    gBattleOutcome = gBattleBufferA[gActiveBattler][1];
+    gBattleOutcome = gBattleBufferA[battler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
-    PlayerBufferExecCompleted();
-    gBattlerControllerFuncs[gActiveBattler] = SetBattleEndCallbacks;
+    PlayerBufferExecCompleted(battler);
+    gBattlerControllerFuncs[battler] = SetBattleEndCallbacks;
 }
 
 static void PlayerCmdEnd(u32 battler)
 {
 }
 
-static void PreviewDeterminativeMoveTargets(void)
+static void PreviewDeterminativeMoveTargets(u32 battler)
 {
     u32 bitMask = 0;
     u8 startY = 0;
@@ -2889,8 +2840,8 @@ static void PreviewDeterminativeMoveTargets(void)
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
     {
         u8 moveTarget;
-        struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[gActiveBattler][4]);
-        u16 move = moveInfo->moves[gMoveSelectionCursor[gActiveBattler]];
+        struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct *)(&gBattleBufferA[battler][4]);
+        u16 move = moveInfo->moves[gMoveSelectionCursor[battler]];
 
         if (move == MOVE_CURSE)
         {
@@ -2901,7 +2852,7 @@ static void PreviewDeterminativeMoveTargets(void)
         }
         else
         {
-            moveTarget = gMovesInfo[moveInfo->moves[gMoveSelectionCursor[gActiveBattler]]].target;
+            moveTarget = gMovesInfo[moveInfo->moves[gMoveSelectionCursor[battler]]].target;
         }
         switch (moveTarget)
         {
@@ -2941,17 +2892,17 @@ static void PreviewDeterminativeMoveTargets(void)
                          | gBitTable[GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT)]) << 16;
                 break;
             case MOVE_HELPING_HAND:
-                bitMask = (gBitTable[GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK)]) << 16;
+                bitMask = (gBitTable[GetBattlerAtPosition(GetBattlerPosition(battler) ^ BIT_FLANK)]) << 16;
                 break;
             default:
-                bitMask = (gBitTable[gActiveBattler]) << 16;
+                bitMask = (gBitTable[battler]) << 16;
                 break;
             }
             startY = 8;
             break;
         case MOVE_TARGET_FOES_AND_ALLY:
             bitMask = (gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT)]
-                     | gBitTable[GetBattlerAtPosition(GetBattlerPosition(gActiveBattler) ^ BIT_FLANK)]
+                     | gBitTable[GetBattlerAtPosition(GetBattlerPosition(battler) ^ BIT_FLANK)]
                      | gBitTable[GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT)]) << 16;
             startY = 8;
             break;
diff --git a/src/battle_controller_pokedude.c b/src/battle_controller_pokedude.c
index acd6e838c..71bafc78f 100644
--- a/src/battle_controller_pokedude.c
+++ b/src/battle_controller_pokedude.c
@@ -26,7 +26,7 @@ struct PokedudeTextScriptHeader
     u8 btlcmd;
     u8 side;
     u16 stringid;
-    void (*callback)(void);
+    void (*callback)(u32 battler);
 };
 
 struct PokedudeBattlePartyInfo
@@ -39,88 +39,88 @@ struct PokedudeBattlePartyInfo
     u8 gender;
 };
 
-static void PokedudeHandleGetMonData(void);
-static void PokedudeHandleGetRawMonData(void);
-static void PokedudeHandleSetMonData(void);
-static void PokedudeHandleSetRawMonData(void);
-static void PokedudeHandleLoadMonSprite(void);
-static void PokedudeHandleSwitchInAnim(void);
-static void PokedudeHandleReturnMonToBall(void);
-static void PokedudeHandleDrawTrainerPic(void);
-static void PokedudeHandleTrainerSlide(void);
-static void PokedudeHandleTrainerSlideBack(void);
-static void PokedudeHandleFaintAnimation(void);
-static void PokedudeHandlePaletteFade(void);
-static void PokedudeHandleSuccessBallThrowAnim(void);
-static void PokedudeHandleBallThrowAnim(void);
-static void PokedudeHandlePause(void);
-static void PokedudeHandleMoveAnimation(void);
-static void PokedudeHandlePrintString(void);
-static void PokedudeHandlePrintSelectionString(void);
-static void PokedudeHandleChooseAction(void);
-static void PokedudeHandleUnknownYesNoBox(void);
-static void PokedudeHandleChooseMove(void);
-static void PokedudeHandleChooseItem(void);
-static void PokedudeHandleChoosePokemon(void);
-static void PokedudeHandleCmd23(void);
-static void PokedudeHandleHealthBarUpdate(void);
-static void PokedudeHandleExpUpdate(void);
-static void PokedudeHandleStatusIconUpdate(void);
-static void PokedudeHandleStatusAnimation(void);
-static void PokedudeHandleStatusXor(void);
-static void PokedudeHandleDataTransfer(void);
-static void PokedudeHandleDMA3Transfer(void);
-static void PokedudeHandlePlayBGM(void);
-static void PokedudeHandleCmd32(void);
-static void PokedudeHandleTwoReturnValues(void);
-static void PokedudeHandleChosenMonReturnValue(void);
-static void PokedudeHandleOneReturnValue(void);
-static void PokedudeHandleOneReturnValue_Duplicate(void);
-static void PokedudeHandleCmd37(void);
-static void PokedudeHandleCmd38(void);
-static void PokedudeHandleCmd39(void);
-static void PokedudeHandleCmd40(void);
-static void PokedudeHandleHitAnimation(void);
-static void PokedudeHandleCmd42(void);
-static void PokedudeHandlePlaySE(void);
-static void PokedudeHandlePlayFanfare(void);
-static void PokedudeHandleFaintingCry(void);
-static void PokedudeHandleIntroSlide(void);
-static void PokedudeHandleIntroTrainerBallThrow(void);
-static void PokedudeHandleDrawPartyStatusSummary(void);
-static void PokedudeHandleHidePartyStatusSummary(void);
-static void PokedudeHandleEndBounceEffect(void);
-static void PokedudeHandleSpriteInvisibility(void);
-static void PokedudeHandleBattleAnimation(void);
-static void PokedudeHandleLinkStandbyMsg(void);
-static void PokedudeHandleResetActionMoveSelection(void);
-static void PokedudeHandleCmd55(void);
-static void PokedudeCmdEnd(void);
+static void PokedudeHandleGetMonData(u32 battler);
+static void PokedudeHandleGetRawMonData(u32 battler);
+static void PokedudeHandleSetMonData(u32 battler);
+static void PokedudeHandleSetRawMonData(u32 battler);
+static void PokedudeHandleLoadMonSprite(u32 battler);
+static void PokedudeHandleSwitchInAnim(u32 battler);
+static void PokedudeHandleReturnMonToBall(u32 battler);
+static void PokedudeHandleDrawTrainerPic(u32 battler);
+static void PokedudeHandleTrainerSlide(u32 battler);
+static void PokedudeHandleTrainerSlideBack(u32 battler);
+static void PokedudeHandleFaintAnimation(u32 battler);
+static void PokedudeHandlePaletteFade(u32 battler);
+static void PokedudeHandleSuccessBallThrowAnim(u32 battler);
+static void PokedudeHandleBallThrowAnim(u32 battler);
+static void PokedudeHandlePause(u32 battler);
+static void PokedudeHandleMoveAnimation(u32 battler);
+static void PokedudeHandlePrintString(u32 battler);
+static void PokedudeHandlePrintSelectionString(u32 battler);
+static void PokedudeHandleChooseAction(u32 battler);
+static void PokedudeHandleUnknownYesNoBox(u32 battler);
+static void PokedudeHandleChooseMove(u32 battler);
+static void PokedudeHandleChooseItem(u32 battler);
+static void PokedudeHandleChoosePokemon(u32 battler);
+static void PokedudeHandleCmd23(u32 battler);
+static void PokedudeHandleHealthBarUpdate(u32 battler);
+static void PokedudeHandleExpUpdate(u32 battler);
+static void PokedudeHandleStatusIconUpdate(u32 battler);
+static void PokedudeHandleStatusAnimation(u32 battler);
+static void PokedudeHandleStatusXor(u32 battler);
+static void PokedudeHandleDataTransfer(u32 battler);
+static void PokedudeHandleDMA3Transfer(u32 battler);
+static void PokedudeHandlePlayBGM(u32 battler);
+static void PokedudeHandleCmd32(u32 battler);
+static void PokedudeHandleTwoReturnValues(u32 battler);
+static void PokedudeHandleChosenMonReturnValue(u32 battler);
+static void PokedudeHandleOneReturnValue(u32 battler);
+static void PokedudeHandleOneReturnValue_Duplicate(u32 battler);
+static void PokedudeHandleCmd37(u32 battler);
+static void PokedudeHandleCmd38(u32 battler);
+static void PokedudeHandleCmd39(u32 battler);
+static void PokedudeHandleCmd40(u32 battler);
+static void PokedudeHandleHitAnimation(u32 battler);
+static void PokedudeHandleCmd42(u32 battler);
+static void PokedudeHandlePlaySE(u32 battler);
+static void PokedudeHandlePlayFanfare(u32 battler);
+static void PokedudeHandleFaintingCry(u32 battler);
+static void PokedudeHandleIntroSlide(u32 battler);
+static void PokedudeHandleIntroTrainerBallThrow(u32 battler);
+static void PokedudeHandleDrawPartyStatusSummary(u32 battler);
+static void PokedudeHandleHidePartyStatusSummary(u32 battler);
+static void PokedudeHandleEndBounceEffect(u32 battler);
+static void PokedudeHandleSpriteInvisibility(u32 battler);
+static void PokedudeHandleBattleAnimation(u32 battler);
+static void PokedudeHandleLinkStandbyMsg(u32 battler);
+static void PokedudeHandleResetActionMoveSelection(u32 battler);
+static void PokedudeHandleCmd55(u32 battler);
+static void PokedudeCmdEnd(u32 battler);
 
-static void PokedudeAction_PrintVoiceoverMessage(void);
-static void PokedudeAction_PrintMessageWithHealthboxPals(void);
-static void PokedudeBufferExecCompleted(void);
-static void PokedudeSimulateInputChooseAction(void);
-static void PokedudeBufferRunCommand(void);
-static bool8 HandlePokedudeVoiceoverEtc(void);
-static void PokedudeSimulateInputChooseMove(void);
-static void WaitForMonSelection(void);
-static void CompleteWhenChoseItem(void);
-static void Intro_WaitForShinyAnimAndHealthbox(void);
+static void PokedudeAction_PrintVoiceoverMessage(u32 battler);
+static void PokedudeAction_PrintMessageWithHealthboxPals(u32 battler);
+static void PokedudeBufferExecCompleted(u32 battler);
+static void PokedudeSimulateInputChooseAction(u32 battler);
+static void PokedudeBufferRunCommand(u32 battler);
+static bool8 HandlePokedudeVoiceoverEtc(u32 battler);
+static void PokedudeSimulateInputChooseMove(u32 battler);
+static void WaitForMonSelection(u32 battler);
+static void CompleteWhenChoseItem(u32 battler);
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler);
 static void Task_LaunchLvlUpAnim(u8 taskId);
 static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId);
-static void CompleteOnInactiveTextPrinter2(void);
+static void CompleteOnInactiveTextPrinter2(u32 battler);
 static void Task_PrepareToGiveExpWithExpBar(u8 taskId);
 static void Task_GiveExpWithExpBar(u8 taskId);
 static void Task_UpdateLvlInHealthbox(u8 taskId);
 static u32 CopyPokedudeMonData(u8 monId, u8 *dst);
 static void SetPokedudeMonData(u8 monId);
 static void StartSendOutAnim(u8 battlerId);
-static void PokedudeDoMoveAnimation(void);
+static void PokedudeDoMoveAnimation(u32 battler);
 static void Task_StartSendOutAnim(u8 taskId);
 static const u8 *GetPokedudeText(void);
 
-static void (*const sPokedudeBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sPokedudeBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = PokedudeHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = PokedudeHandleGetRawMonData,
@@ -166,7 +166,7 @@ static void (*const sPokedudeBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_HITANIMATION]             = PokedudeHandleHitAnimation,
     [CONTROLLER_CANTSWITCH]               = PokedudeHandleCmd42,
     [CONTROLLER_PLAYSE]                   = PokedudeHandlePlaySE,
-    [CONTROLLER_PLAYFANFAREORBGM]              = PokedudeHandlePlayFanfare,
+    [CONTROLLER_PLAYFANFAREORBGM]         = PokedudeHandlePlayFanfare,
     [CONTROLLER_FAINTINGCRY]              = PokedudeHandleFaintingCry,
     [CONTROLLER_INTROSLIDE]               = PokedudeHandleIntroSlide,
     [CONTROLLER_INTROTRAINERBALLTHROW]    = PokedudeHandleIntroTrainerBallThrow,
@@ -189,45 +189,45 @@ static const u8 sUnused[] = { 0x48, 0x48, 0x20, 0x5a, 0x50, 0x50, 0x50, 0x58 };
 #define pdScriptNum      simulatedInputState[2]
 #define pdMessageNo      simulatedInputState[3]
 
-static void PokedudeDummy(void)
+static void PokedudeDummy(u32 battler)
 {
 }
 
-void SetControllerToPokedude(void)
+void SetControllerToPokedude(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = PokedudeBufferRunCommand;
     *(&gBattleStruct->pdScriptNum) = gSpecialVar_0x8004;
     gBattleStruct->pdMessageNo = 0;
 }
 
-static void PokedudeBufferRunCommand(void)
+static void PokedudeBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < NELEMS(sPokedudeBufferCommands))
         {
-            if (!HandlePokedudeVoiceoverEtc())
-                sPokedudeBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            if (!HandlePokedudeVoiceoverEtc(battler))
+                sPokedudeBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         }
         else
         {
-            PokedudeBufferExecCompleted();
+            PokedudeBufferExecCompleted(battler);
         }
     }
 }
 
-static void HandleInputChooseAction(void)
+static void HandleInputChooseAction(u32 battler)
 {
-    PokedudeSimulateInputChooseAction();
+    PokedudeSimulateInputChooseAction(battler);
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void CompleteOnBattlerSpritePosX_0(void)
+static void CompleteOnBattlerSpritePosX_0(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].animEnded == TRUE
         && gSprites[gBattlerSpriteIds[gActiveBattler]].x2 == 0)
@@ -242,18 +242,18 @@ static void CompleteOnBattlerSpritePosX_0(void)
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim = FALSE;
             FreeSpriteTilesByTag(ANIM_TAG_GOLD_STARS);
             FreeSpritePaletteByTag(ANIM_TAG_GOLD_STARS);
-            PokedudeBufferExecCompleted();
+            PokedudeBufferExecCompleted(battler);
         }
     }
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void Pokedude_SetBattleEndCallbacks(void)
+static void Pokedude_SetBattleEndCallbacks(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -263,17 +263,17 @@ static void Pokedude_SetBattleEndCallbacks(void)
     }
 }
 
-static void SwitchIn_HandleSoundAndEnd(void)
+static void SwitchIn_HandleSoundAndEnd(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
         CreateTask(Task_PlayerController_RestoreBgmAfterCry, 10);
         HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void SwitchIn_CleanShinyAnimShowSubstitute(void)
+static void SwitchIn_CleanShinyAnimShowSubstitute(u32 battler)
 {
     if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy
         && gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].finishedShinyMonAnim)
@@ -288,7 +288,7 @@ static void SwitchIn_CleanShinyAnimShowSubstitute(void)
     }
 }
 
-static void SwitchIn_TryShinyAnimShowHealthbox(void)
+static void SwitchIn_TryShinyAnimShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim
         && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
@@ -307,27 +307,27 @@ static void SwitchIn_TryShinyAnimShowHealthbox(void)
     }
 }
 
-static void CompleteOnSpecialAnimDone(void)
+static void CompleteOnSpecialAnimDone(u32 battler)
 {
     if (!gDoingBattleAnim)
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void Intro_DelayAndEnd(void)
+static void Intro_DelayAndEnd(u32 battler)
 {
     if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay == 255)
     {
         gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].introEndDelay = 0;
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void PokedudeHandleInputChooseMove(void)
+static void PokedudeHandleInputChooseMove(u32 battler)
 {
-    PokedudeSimulateInputChooseMove();
+    PokedudeSimulateInputChooseMove(battler);
 }
 
-static void OpenPartyMenuToChooseMon(void)
+static void OpenPartyMenuToChooseMon(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -338,7 +338,7 @@ static void OpenPartyMenuToChooseMon(void)
     }
 }
 
-static void WaitForMonSelection(void)
+static void WaitForMonSelection(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
@@ -346,11 +346,11 @@ static void WaitForMonSelection(void)
             BtlController_EmitChosenMonReturnValue(1, gSelectedMonPartyId, gBattlePartyCurrentOrder);
         else
             BtlController_EmitChosenMonReturnValue(1, 6, NULL);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void OpenBagAndChooseItem(void)
+static void OpenBagAndChooseItem(u32 battler)
 {
     u8 callbackId;
 
@@ -373,16 +373,16 @@ static void OpenBagAndChooseItem(void)
     }
 }
 
-static void CompleteWhenChoseItem(void)
+static void CompleteWhenChoseItem(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
         BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void Intro_TryShinyAnimShowHealthbox(void)
+static void Intro_TryShinyAnimShowHealthbox(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].triedShinyMonAnim
         && !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].ballAnimActive)
@@ -412,7 +412,7 @@ static void Intro_TryShinyAnimShowHealthbox(void)
     }
 }
 
-static void Intro_WaitForShinyAnimAndHealthbox(void)
+static void Intro_WaitForShinyAnimAndHealthbox(u32 battler)
 {
     bool32 r4 = FALSE;
 
@@ -593,7 +593,7 @@ static void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId)
     DestroyTask(taskId);
 }
 
-static void FreeMonSpriteAfterFaintAnim(void)
+static void FreeMonSpriteAfterFaintAnim(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
@@ -602,7 +602,7 @@ static void FreeMonSpriteAfterFaintAnim(void)
             FreeOamMatrix(gSprites[gBattlerSpriteIds[gActiveBattler]].oam.matrixNum);
             DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
             SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-            PokedudeBufferExecCompleted();
+            PokedudeBufferExecCompleted(battler);
         }
     }
     else
@@ -610,12 +610,12 @@ static void FreeMonSpriteAfterFaintAnim(void)
         if (!gSprites[gBattlerSpriteIds[gActiveBattler]].inUse)
         {
             SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-            PokedudeBufferExecCompleted();
+            PokedudeBufferExecCompleted(battler);
         }
     }
 }
 
-static void CompleteOnHealthbarDone(void)
+static void CompleteOnHealthbarDone(u32 battler)
 {
     s16 hpValue = MoveBattleBar(gActiveBattler, gHealthboxSpriteIds[gActiveBattler], HEALTH_BAR, 0);
 
@@ -627,17 +627,17 @@ static void CompleteOnHealthbarDone(void)
     else
     {
         HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnInactiveTextPrinter2(void)
+static void CompleteOnInactiveTextPrinter2(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void DoHitAnimBlinkSpriteEffect(void)
+static void DoHitAnimBlinkSpriteEffect(u32 battler)
 {
     u8 spriteId = gBattlerSpriteIds[gActiveBattler];
 
@@ -646,7 +646,7 @@ static void DoHitAnimBlinkSpriteEffect(void)
         gSprites[spriteId].data[1] = 0;
         gSprites[spriteId].invisible = FALSE;
         gDoingBattleAnim = FALSE;
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
     else
     {
@@ -656,36 +656,36 @@ static void DoHitAnimBlinkSpriteEffect(void)
     }
 }
 
-static void DoSwitchOutAnimation(void)
+static void DoSwitchOutAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
     {
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy2(void)
+static void CompleteOnBattlerSpriteCallbackDummy2(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeBufferExecCompleted(void)
+static void PokedudeBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = PokedudeBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -701,14 +701,7 @@ static void PokedudeBufferExecCompleted(void)
     }
 }
 
-// not used
-static void CompleteOnFinishedStatusAnimation2(void)
-{
-    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        PokedudeBufferExecCompleted();
-}
-
-static void PokedudeHandleGetMonData(void)
+static void PokedudeHandleGetMonData(u32 battler)
 {
     u8 monData[sizeof(struct Pokemon) * 2 + 56]; // this allows to get full data of two pokemon, trying to get more will result in overwriting data
     u32 size = 0;
@@ -730,7 +723,7 @@ static void PokedudeHandleGetMonData(void)
         }
     }
     BtlController_EmitDataTransfer(BUFFER_B, size, monData);
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
 static u32 CopyPokedudeMonData(u8 monId, u8 *dst)
@@ -1043,12 +1036,12 @@ static u32 CopyPokedudeMonData(u8 monId, u8 *dst)
     return size;
 }
 
-static void PokedudeHandleGetRawMonData(void)
+static void PokedudeHandleGetRawMonData(u32 battler)
 {
     PlayerHandleGetRawMonData(gActiveBattler);
 }
 
-static void PokedudeHandleSetMonData(void)
+static void PokedudeHandleSetMonData(u32 battler)
 {
     u8 monToCheck;
     u8 i;
@@ -1067,7 +1060,7 @@ static void PokedudeHandleSetMonData(void)
             monToCheck >>= 1;
         }
     }
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
 static void SetPokedudeMonData(u8 monId)
@@ -1292,12 +1285,12 @@ static void SetPokedudeMonData(u8 monId)
     HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
 }
 
-static void PokedudeHandleSetRawMonData(void)
+static void PokedudeHandleSetRawMonData(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleLoadMonSprite(void)
+static void PokedudeHandleLoadMonSprite(u32 battler)
 {
     u32 y;
     u16 species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
@@ -1316,10 +1309,10 @@ static void PokedudeHandleLoadMonSprite(void)
     StartSpriteAnim(&gSprites[gBattlerSpriteIds[gActiveBattler]], gBattleMonForms[gActiveBattler]);
     SetBattlerShadowSpriteCallback(gActiveBattler, GetMonData(&gEnemyParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES));
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpritePosX_0;
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleSwitchInAnim(void)
+static void PokedudeHandleSwitchInAnim(u32 battler)
 {
     ClearTemporarySpeciesSpriteData(gActiveBattler, gBattleBufferA[gActiveBattler][2]);
     gBattlerPartyIndexes[gActiveBattler] = gBattleBufferA[gActiveBattler][1];
@@ -1330,7 +1323,7 @@ static void PokedudeHandleSwitchInAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = SwitchIn_TryShinyAnimShowHealthbox;
 }
 
-static void PokedudeHandleReturnMonToBall(void)
+static void PokedudeHandleReturnMonToBall(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] == 0)
     {
@@ -1342,11 +1335,11 @@ static void PokedudeHandleReturnMonToBall(void)
         FreeSpriteOamMatrix(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         DestroySprite(&gSprites[gBattlerSpriteIds[gActiveBattler]]);
         SetHealthboxSpriteInvisible(gHealthboxSpriteIds[gActiveBattler]);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void PokedudeHandleDrawTrainerPic(void)
+static void PokedudeHandleDrawTrainerPic(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
@@ -1381,7 +1374,7 @@ static void PokedudeHandleDrawTrainerPic(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
-static void PokedudeHandleTrainerSlide(void)
+static void PokedudeHandleTrainerSlide(u32 battler)
 {
     DecompressTrainerBackPalette(TRAINER_BACK_PIC_POKEDUDE, gActiveBattler);
     SetMultiuseSpriteTemplateToTrainerBack(TRAINER_BACK_PIC_POKEDUDE, GetBattlerPosition(gActiveBattler));
@@ -1396,12 +1389,12 @@ static void PokedudeHandleTrainerSlide(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy2;
 }
 
-static void PokedudeHandleTrainerSlideBack(void)
+static void PokedudeHandleTrainerSlideBack(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleFaintAnimation(void)
+static void PokedudeHandleFaintAnimation(u32 battler)
 {
     if (gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState == 0)
     {
@@ -1432,12 +1425,12 @@ static void PokedudeHandleFaintAnimation(void)
     }
 }
 
-static void PokedudeHandlePaletteFade(void)
+static void PokedudeHandlePaletteFade(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleSuccessBallThrowAnim(void)
+static void PokedudeHandleSuccessBallThrowAnim(u32 battler)
 {
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS;
     gDoingBattleAnim = TRUE;
@@ -1445,7 +1438,7 @@ static void PokedudeHandleSuccessBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void PokedudeHandleBallThrowAnim(void)
+static void PokedudeHandleBallThrowAnim(u32 battler)
 {
     u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1];
 
@@ -1455,12 +1448,12 @@ static void PokedudeHandleBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void PokedudeHandlePause(void)
+static void PokedudeHandlePause(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleMoveAnimation(void)
+static void PokedudeHandleMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
 
@@ -1473,7 +1466,7 @@ static void PokedudeHandleMoveAnimation(void)
     gTransformedPersonalities[gActiveBattler] = gAnimDisableStructPtr->transformedMonPersonality;
     if (IsMoveWithoutAnimation(move, gAnimMoveTurn)) // always returns FALSE
     {
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
     else
     {
@@ -1482,7 +1475,7 @@ static void PokedudeHandleMoveAnimation(void)
     }
 }
 
-static void PokedudeDoMoveAnimation(void)
+static void PokedudeDoMoveAnimation(u32 battler)
 {
     u16 move = gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8);
 
@@ -1517,13 +1510,13 @@ static void PokedudeDoMoveAnimation(void)
             CopyAllBattleSpritesInvisibilities();
             TrySetBehindSubstituteSpriteBit(gActiveBattler, gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
             gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animationState = 0;
-            PokedudeBufferExecCompleted();
+            PokedudeBufferExecCompleted(battler);
         }
         break;
     }
 }
 
-static void PokedudeHandlePrintString(void)
+static void PokedudeHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -1538,15 +1531,15 @@ static void PokedudeHandlePrintString(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
-static void PokedudeHandlePrintSelectionString(void)
+static void PokedudeHandlePrintSelectionString(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        PokedudeHandlePrintString();
+        PokedudeHandlePrintString(battler);
     else
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
 }
 
-static void HandleChooseActionAfterDma3(void)
+static void HandleChooseActionAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -1556,7 +1549,7 @@ static void HandleChooseActionAfterDma3(void)
     }
 }
 
-static void PokedudeHandleChooseAction(void)
+static void PokedudeHandleChooseAction(u32 battler)
 {
     s32 i;
 
@@ -1577,12 +1570,12 @@ static void PokedudeHandleChooseAction(void)
     }
 }
 
-static void PokedudeHandleUnknownYesNoBox(void)
+static void PokedudeHandleUnknownYesNoBox(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleChooseMoveAfterDma3(void)
+static void PokedudeHandleChooseMoveAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -1592,11 +1585,11 @@ static void PokedudeHandleChooseMoveAfterDma3(void)
     }
 }
 
-static void PokedudeHandleChooseMove(void)
+static void PokedudeHandleChooseMove(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        InitMoveSelectionsVarsAndStrings();
+        InitMoveSelectionsVarsAndStrings(battler);
         gBattlerControllerFuncs[gActiveBattler] = PokedudeHandleChooseMoveAfterDma3;
     }
     else
@@ -1605,7 +1598,7 @@ static void PokedudeHandleChooseMove(void)
     }
 }
 
-static void PokedudeHandleChooseItem(void)
+static void PokedudeHandleChooseItem(u32 battler)
 {
     s32 i;
 
@@ -1616,7 +1609,7 @@ static void PokedudeHandleChooseItem(void)
         gBattlePartyCurrentOrder[i] = gBattleBufferA[gActiveBattler][i + 1];
 }
 
-static void PokedudeHandleChoosePokemon(void)
+static void PokedudeHandleChoosePokemon(u32 battler)
 {
     s32 i;
 
@@ -1632,12 +1625,12 @@ static void PokedudeHandleChoosePokemon(void)
     gBattlerInMenuId = gActiveBattler;
 }
 
-static void PokedudeHandleCmd23(void)
+static void PokedudeHandleCmd23(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleHealthBarUpdate(void)
+static void PokedudeHandleHealthBarUpdate(u32 battler)
 {
     s16 hpVal;
     struct Pokemon *mon;
@@ -1665,13 +1658,13 @@ static void PokedudeHandleHealthBarUpdate(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthbarDone;
 }
 
-static void PokedudeHandleExpUpdate(void)
+static void PokedudeHandleExpUpdate(u32 battler)
 {
     u8 monId = gBattleBufferA[gActiveBattler][1];
 
     if (GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL) >= MAX_LEVEL)
     {
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
     else
     {
@@ -1689,7 +1682,7 @@ static void PokedudeHandleExpUpdate(void)
     }
 }
 
-static void PokedudeHandleStatusIconUpdate(void)
+static void PokedudeHandleStatusIconUpdate(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1707,7 +1700,7 @@ static void PokedudeHandleStatusIconUpdate(void)
     }
 }
 
-static void PokedudeHandleStatusAnimation(void)
+static void PokedudeHandleStatusAnimation(u32 battler)
 {
     if (!IsBattleSEPlaying(gActiveBattler))
     {
@@ -1717,7 +1710,7 @@ static void PokedudeHandleStatusAnimation(void)
     }
 }
 
-static void PokedudeHandleStatusXor(void)
+static void PokedudeHandleStatusXor(u32 battler)
 {
     struct Pokemon *mon;
     u8 val;
@@ -1728,74 +1721,74 @@ static void PokedudeHandleStatusXor(void)
         mon = &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]];
     val = GetMonData(mon, MON_DATA_STATUS) ^ gBattleBufferA[gActiveBattler][1];
     SetMonData(mon, MON_DATA_STATUS, &val);
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleDataTransfer(void)
+static void PokedudeHandleDataTransfer(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleDMA3Transfer(void)
+static void PokedudeHandleDMA3Transfer(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandlePlayBGM(void)
+static void PokedudeHandlePlayBGM(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd32(void)
+static void PokedudeHandleCmd32(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleTwoReturnValues(void)
+static void PokedudeHandleTwoReturnValues(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleChosenMonReturnValue(void)
+static void PokedudeHandleChosenMonReturnValue(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleOneReturnValue(void)
+static void PokedudeHandleOneReturnValue(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleOneReturnValue_Duplicate(void)
+static void PokedudeHandleOneReturnValue_Duplicate(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd37(void)
+static void PokedudeHandleCmd37(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd38(void)
+static void PokedudeHandleCmd38(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd39(void)
+static void PokedudeHandleCmd39(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd40(void)
+static void PokedudeHandleCmd40(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleHitAnimation(void)
+static void PokedudeHandleHitAnimation(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].invisible == TRUE)
     {
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
     else
     {
@@ -1806,24 +1799,24 @@ static void PokedudeHandleHitAnimation(void)
     }
 }
 
-static void PokedudeHandleCmd42(void)
+static void PokedudeHandleCmd42(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandlePlaySE(void)
+static void PokedudeHandlePlaySE(u32 battler)
 {
     PlaySE(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandlePlayFanfare(void)
+static void PokedudeHandlePlayFanfare(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleFaintingCry(void)
+static void PokedudeHandleFaintingCry(u32 battler)
 {
     struct Pokemon *mon;
     u16 species;
@@ -1834,17 +1827,17 @@ static void PokedudeHandleFaintingCry(void)
         mon = &gEnemyParty[gBattlerPartyIndexes[gActiveBattler]];
     species = GetMonData(mon, MON_DATA_SPECIES);
     PlayCry_Normal(species, 25);
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleIntroSlide(void)
+static void PokedudeHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleIntroTrainerBallThrow(void)
+static void PokedudeHandleIntroTrainerBallThrow(u32 battler)
 {
     u8 paletteNum;
     u8 taskId;
@@ -1910,12 +1903,12 @@ static void Task_StartSendOutAnim(u8 taskId)
     }
 }
 
-static void PokedudeHandleDrawPartyStatusSummary(void)
+static void PokedudeHandleDrawPartyStatusSummary(u32 battler)
 {
     if (gBattleBufferA[gActiveBattler][1] != 0
         && GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
     {
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
     else
     {
@@ -1924,39 +1917,39 @@ static void PokedudeHandleDrawPartyStatusSummary(void)
                                                                                       (struct HpAndStatus *)&gBattleBufferA[gActiveBattler][4],
                                                                                       gBattleBufferA[gActiveBattler][1],
                                                                                       gBattleBufferA[gActiveBattler][2]);
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     }
 }
 
-static void PokedudeHandleHidePartyStatusSummary(void)
+static void PokedudeHandleHidePartyStatusSummary(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleEndBounceEffect(void)
+static void PokedudeHandleEndBounceEffect(u32 battler)
 {
     EndBounceEffect(gActiveBattler, BOUNCE_HEALTHBOX);
     EndBounceEffect(gActiveBattler, BOUNCE_MON);
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleSpriteInvisibility(void)
+static void PokedudeHandleSpriteInvisibility(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleBattleAnimation(void)
+static void PokedudeHandleBattleAnimation(u32 battler)
 {
     u8 animationId = gBattleBufferA[gActiveBattler][1];
     u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
     if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
     else
         gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
 }
 
-static void PokedudeHandleLinkStandbyMsg(void)
+static void PokedudeHandleLinkStandbyMsg(u32 battler)
 {
     switch (gBattleBufferA[gActiveBattler][1])
     {
@@ -1968,25 +1961,25 @@ static void PokedudeHandleLinkStandbyMsg(void)
     case 2:
         break;
     }
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleResetActionMoveSelection(void)
+static void PokedudeHandleResetActionMoveSelection(u32 battler)
 {
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
 }
 
-static void PokedudeHandleCmd55(void)
+static void PokedudeHandleCmd55(u32 battler)
 {
     gBattleOutcome = gBattleBufferA[gActiveBattler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(FAST_FADE_OUT_TO_BLACK);
-    PokedudeBufferExecCompleted();
+    PokedudeBufferExecCompleted(battler);
     if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER) && gBattleTypeFlags & BATTLE_TYPE_LINK)
         gBattlerControllerFuncs[gActiveBattler] = Pokedude_SetBattleEndCallbacks;
 }
 
-static void PokedudeCmdEnd(void)
+static void PokedudeCmdEnd(u32 battler)
 {
 }
 
@@ -2426,7 +2419,7 @@ static const struct PokedudeBattlePartyInfo *const sPokedudeBattlePartyPointers[
 
 struct PokedudeBattlerState *gPokedudeBattlerStates[MAX_BATTLERS_COUNT];
 
-static void PokedudeSimulateInputChooseAction(void)
+static void PokedudeSimulateInputChooseAction(u32 battler)
 {
     const struct PokedudeInputScript *script_p = sInputScripts_ChooseAction[gBattleStruct->pdScriptNum];
 
@@ -2455,7 +2448,7 @@ static void PokedudeSimulateInputChooseAction(void)
             BtlController_EmitTwoReturnValues(1, B_ACTION_RUN, 0);
             break;
         }
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
         ++gPokedudeBattlerStates[gActiveBattler]->action_idx;
         if (script_p[gPokedudeBattlerStates[gActiveBattler]->action_idx].cursorPos[gActiveBattler] == 4)
             gPokedudeBattlerStates[gActiveBattler]->action_idx = 0;
@@ -2474,7 +2467,7 @@ static void PokedudeSimulateInputChooseAction(void)
     }
 }
 
-static void PokedudeSimulateInputChooseMove(void)
+static void PokedudeSimulateInputChooseMove(u32 battler)
 {
     const struct PokedudeInputScript *script_p = sInputScripts_ChooseMove[gBattleStruct->pdScriptNum];
 
@@ -2486,7 +2479,7 @@ static void PokedudeSimulateInputChooseMove(void)
         BtlController_EmitTwoReturnValues(1,
                                           B_ACTION_EXEC_SCRIPT,
                                           script_p[gPokedudeBattlerStates[gActiveBattler]->move_idx].cursorPos[gActiveBattler] | ((gActiveBattler ^ BIT_SIDE) << 8));
-        PokedudeBufferExecCompleted();
+        PokedudeBufferExecCompleted(battler);
         ++gPokedudeBattlerStates[gActiveBattler]->move_idx;
         if (script_p[gPokedudeBattlerStates[gActiveBattler]->move_idx].cursorPos[gActiveBattler] == 255)
             gPokedudeBattlerStates[gActiveBattler]->move_idx = 0;
@@ -2505,7 +2498,7 @@ static void PokedudeSimulateInputChooseMove(void)
     }
 }
 
-static bool8 HandlePokedudeVoiceoverEtc(void)
+static bool8 HandlePokedudeVoiceoverEtc(u32 battler)
 {
     const struct PokedudeTextScriptHeader *header_p = sPokedudeTextScripts[gBattleStruct->pdScriptNum];
     const u16 * bstringid_p = (const u16 *)&gBattleBufferA[gActiveBattler][2];
@@ -2528,13 +2521,13 @@ static bool8 HandlePokedudeVoiceoverEtc(void)
     return TRUE;
 }
 
-static void ReturnFromPokedudeAction(void)
+static void ReturnFromPokedudeAction(u32 battler)
 {
     gPokedudeBattlerStates[gActiveBattler]->timer = 0;
     gBattlerControllerFuncs[gActiveBattler] = PokedudeBufferRunCommand;
 }
 
-static void PokedudeAction_PrintVoiceoverMessage(void)
+static void PokedudeAction_PrintVoiceoverMessage(u32 battler)
 {
     switch (gPokedudeBattlerStates[gActiveBattler]->timer)
     {
@@ -2577,13 +2570,13 @@ static void PokedudeAction_PrintVoiceoverMessage(void)
             }
             gBattle_BG0_Y = gPokedudeBattlerStates[gActiveBattler]->saved_bg0y;
             BtlCtrl_RemoveVoiceoverMessageFrame();
-            ReturnFromPokedudeAction();
+            ReturnFromPokedudeAction(battler);
         }
         break;
     }
 }
 
-static void PokedudeAction_PrintMessageWithHealthboxPals(void)
+static void PokedudeAction_PrintMessageWithHealthboxPals(u32 battler)
 {
     switch (gPokedudeBattlerStates[gActiveBattler]->timer)
     {
@@ -2650,7 +2643,7 @@ static void PokedudeAction_PrintMessageWithHealthboxPals(void)
             }
             DoFreeHealthboxPalsForLevelUp(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT));
             BtlCtrl_RemoveVoiceoverMessageFrame();
-            ReturnFromPokedudeAction();
+            ReturnFromPokedudeAction(battler);
         }
         break;
     }
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 9622899bf..8ae4bdb68 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -15,69 +15,69 @@
 #include "constants/songs.h"
 #include "constants/battle_anim.h"
 
-static void SafariHandleGetMonData(void);
-static void SafariHandleGetRawMonData(void);
-static void SafariHandleSetMonData(void);
-static void SafariHandleSetRawMonData(void);
-static void SafariHandleLoadMonSprite(void);
-static void SafariHandleSwitchInAnim(void);
-static void SafariHandleReturnMonToBall(void);
-static void SafariHandleDrawTrainerPic(void);
-static void SafariHandleTrainerSlide(void);
-static void SafariHandleTrainerSlideBack(void);
-static void SafariHandleFaintAnimation(void);
-static void SafariHandlePaletteFade(void);
-static void SafariHandleSuccessBallThrowAnim(void);
-static void SafariHandleBallThrowAnim(void);
-static void SafariHandlePause(void);
-static void SafariHandleMoveAnimation(void);
-static void SafariHandlePrintString(void);
-static void SafariHandlePrintSelectionString(void);
-static void SafariHandleChooseAction(void);
-static void SafariHandleUnknownYesNoBox(void);
-static void SafariHandleChooseMove(void);
-static void SafariHandleChooseItem(void);
-static void SafariHandleChoosePokemon(void);
-static void SafariHandleCmd23(void);
-static void SafariHandleHealthBarUpdate(void);
-static void SafariHandleExpUpdate(void);
-static void SafariHandleStatusIconUpdate(void);
-static void SafariHandleStatusAnimation(void);
-static void SafariHandleStatusXor(void);
-static void SafariHandleDataTransfer(void);
-static void SafariHandleDMA3Transfer(void);
-static void SafariHandlePlayBGM(void);
-static void SafariHandleCmd32(void);
-static void SafariHandleTwoReturnValues(void);
-static void SafariHandleChosenMonReturnValue(void);
-static void SafariHandleOneReturnValue(void);
-static void SafariHandleOneReturnValue_Duplicate(void);
-static void SafariHandleCmd37(void);
-static void SafariHandleCmd38(void);
-static void SafariHandleCmd39(void);
-static void SafariHandleCmd40(void);
-static void SafariHandleHitAnimation(void);
-static void SafariHandleCmd42(void);
-static void SafariHandlePlaySE(void);
-static void SafariHandlePlayFanfareOrBGM(void);
-static void SafariHandleFaintingCry(void);
-static void SafariHandleIntroSlide(void);
-static void SafariHandleIntroTrainerBallThrow(void);
-static void SafariHandleDrawPartyStatusSummary(void);
-static void SafariHandleHidePartyStatusSummary(void);
-static void SafariHandleEndBounceEffect(void);
-static void SafariHandleSpriteInvisibility(void);
-static void SafariHandleBattleAnimation(void);
-static void SafariHandleLinkStandbyMsg(void);
-static void SafariHandleResetActionMoveSelection(void);
-static void SafariHandleCmd55(void);
-static void SafariCmdEnd(void);
+static void SafariHandleGetMonData(u32 battler);
+static void SafariHandleGetRawMonData(u32 battler);
+static void SafariHandleSetMonData(u32 battler);
+static void SafariHandleSetRawMonData(u32 battler);
+static void SafariHandleLoadMonSprite(u32 battler);
+static void SafariHandleSwitchInAnim(u32 battler);
+static void SafariHandleReturnMonToBall(u32 battler);
+static void SafariHandleDrawTrainerPic(u32 battler);
+static void SafariHandleTrainerSlide(u32 battler);
+static void SafariHandleTrainerSlideBack(u32 battler);
+static void SafariHandleFaintAnimation(u32 battler);
+static void SafariHandlePaletteFade(u32 battler);
+static void SafariHandleSuccessBallThrowAnim(u32 battler);
+static void SafariHandleBallThrowAnim(u32 battler);
+static void SafariHandlePause(u32 battler);
+static void SafariHandleMoveAnimation(u32 battler);
+static void SafariHandlePrintString(u32 battler);
+static void SafariHandlePrintSelectionString(u32 battler);
+static void SafariHandleChooseAction(u32 battler);
+static void SafariHandleUnknownYesNoBox(u32 battler);
+static void SafariHandleChooseMove(u32 battler);
+static void SafariHandleChooseItem(u32 battler);
+static void SafariHandleChoosePokemon(u32 battler);
+static void SafariHandleCmd23(u32 battler);
+static void SafariHandleHealthBarUpdate(u32 battler);
+static void SafariHandleExpUpdate(u32 battler);
+static void SafariHandleStatusIconUpdate(u32 battler);
+static void SafariHandleStatusAnimation(u32 battler);
+static void SafariHandleStatusXor(u32 battler);
+static void SafariHandleDataTransfer(u32 battler);
+static void SafariHandleDMA3Transfer(u32 battler);
+static void SafariHandlePlayBGM(u32 battler);
+static void SafariHandleCmd32(u32 battler);
+static void SafariHandleTwoReturnValues(u32 battler);
+static void SafariHandleChosenMonReturnValue(u32 battler);
+static void SafariHandleOneReturnValue(u32 battler);
+static void SafariHandleOneReturnValue_Duplicate(u32 battler);
+static void SafariHandleCmd37(u32 battler);
+static void SafariHandleCmd38(u32 battler);
+static void SafariHandleCmd39(u32 battler);
+static void SafariHandleCmd40(u32 battler);
+static void SafariHandleHitAnimation(u32 battler);
+static void SafariHandleCmd42(u32 battler);
+static void SafariHandlePlaySE(u32 battler);
+static void SafariHandlePlayFanfareOrBGM(u32 battler);
+static void SafariHandleFaintingCry(u32 battler);
+static void SafariHandleIntroSlide(u32 battler);
+static void SafariHandleIntroTrainerBallThrow(u32 battler);
+static void SafariHandleDrawPartyStatusSummary(u32 battler);
+static void SafariHandleHidePartyStatusSummary(u32 battler);
+static void SafariHandleEndBounceEffect(u32 battler);
+static void SafariHandleSpriteInvisibility(u32 battler);
+static void SafariHandleBattleAnimation(u32 battler);
+static void SafariHandleLinkStandbyMsg(u32 battler);
+static void SafariHandleResetActionMoveSelection(u32 battler);
+static void SafariHandleCmd55(u32 battler);
+static void SafariCmdEnd(u32 battler);
 
-static void SafariBufferRunCommand(void);
-static void SafariBufferExecCompleted(void);
-static void CompleteWhenChosePokeblock(void);
+static void SafariBufferRunCommand(u32 battler);
+static void SafariBufferExecCompleted(u32 battler);
+static void CompleteWhenChosePokeblock(u32 battler);
 
-static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
+static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(u32 battler) =
 {
     [CONTROLLER_GETMONDATA]               = SafariHandleGetMonData,
     [CONTROLLER_GETRAWMONDATA]            = SafariHandleGetRawMonData,
@@ -123,7 +123,7 @@ static void (*const sSafariBufferCommands[CONTROLLER_CMDS_COUNT])(void) =
     [CONTROLLER_HITANIMATION]             = SafariHandleHitAnimation,
     [CONTROLLER_CANTSWITCH]               = SafariHandleCmd42,
     [CONTROLLER_PLAYSE]                   = SafariHandlePlaySE,
-    [CONTROLLER_PLAYFANFAREORBGM]              = SafariHandlePlayFanfareOrBGM,
+    [CONTROLLER_PLAYFANFAREORBGM]         = SafariHandlePlayFanfareOrBGM,
     [CONTROLLER_FAINTINGCRY]              = SafariHandleFaintingCry,
     [CONTROLLER_INTROSLIDE]               = SafariHandleIntroSlide,
     [CONTROLLER_INTROTRAINERBALLTHROW]    = SafariHandleIntroTrainerBallThrow,
@@ -143,23 +143,23 @@ static void SafariDummy(void)
 {
 }
 
-void SetControllerToSafari(void)
+void SetControllerToSafari(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand;
 }
 
-static void SafariBufferRunCommand(void)
+static void SafariBufferRunCommand(u32 battler)
 {
     if (gBattleControllerExecFlags & gBitTable[gActiveBattler])
     {
         if (gBattleBufferA[gActiveBattler][0] < NELEMS(sSafariBufferCommands))
-            sSafariBufferCommands[gBattleBufferA[gActiveBattler][0]]();
+            sSafariBufferCommands[gBattleBufferA[gActiveBattler][0]](battler);
         else
-            SafariBufferExecCompleted();
+            SafariBufferExecCompleted(battler);
     }
 }
 
-static void HandleInputChooseAction(void)
+static void HandleInputChooseAction(u32 battler)
 {
     if (JOY_NEW(A_BUTTON))
     {
@@ -180,7 +180,7 @@ static void HandleInputChooseAction(void)
             BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
             break;
         }
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
     }
     else if (JOY_NEW(DPAD_LEFT))
     {
@@ -224,25 +224,25 @@ static void HandleInputChooseAction(void)
     }
 }
 
-static void CompleteOnBattlerSpriteCallbackDummy(void)
+static void CompleteOnBattlerSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gBattlerSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void CompleteOnInactiveTextPrinter(void)
+static void CompleteOnInactiveTextPrinter(u32 battler)
 {
     if (!IsTextPrinterActive(0))
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void CompleteOnHealthboxSpriteCallbackDummy(void)
+static void CompleteOnHealthboxSpriteCallbackDummy(u32 battler)
 {
     if (gSprites[gHealthboxSpriteIds[gActiveBattler]].callback == SpriteCallbackDummy)
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void Safari_SetBattleEndCallbacks(void)
+static void Safari_SetBattleEndCallbacks(u32 battler)
 {
     if (!gPaletteFade.active)
     {
@@ -252,34 +252,34 @@ static void Safari_SetBattleEndCallbacks(void)
     }
 }
 
-static void CompleteOnSpecialAnimDone(void)
+static void CompleteOnSpecialAnimDone(u32 battler)
 {
     if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].specialAnimActive)
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void SafariOpenPokeblockCase(void)
+static void SafariOpenPokeblockCase(u32 battler)
 {
     if (!gPaletteFade.active)
         gBattlerControllerFuncs[gActiveBattler] = CompleteWhenChosePokeblock;
 }
 
-static void CompleteWhenChosePokeblock(void)
+static void CompleteWhenChosePokeblock(u32 battler)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
         BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
     }
 }
 
-static void CompleteOnFinishedBattleAnimation(void)
+static void CompleteOnFinishedBattleAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].animFromTableActive)
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void SafariBufferExecCompleted(void)
+static void SafariBufferExecCompleted(u32 battler)
 {
     gBattlerControllerFuncs[gActiveBattler] = SafariBufferRunCommand;
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
@@ -296,48 +296,48 @@ static void SafariBufferExecCompleted(void)
 }
 
 // not used
-static void CompleteOnFinishedStatusAnimation(void)
+static void CompleteOnFinishedStatusAnimation(u32 battler)
 {
     if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBattler].statusAnimActive)
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleGetMonData(void)
+static void SafariHandleGetMonData(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleGetRawMonData(void)
+static void SafariHandleGetRawMonData(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleSetMonData(void)
+static void SafariHandleSetMonData(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleSetRawMonData(void)
+static void SafariHandleSetRawMonData(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleLoadMonSprite(void)
+static void SafariHandleLoadMonSprite(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleSwitchInAnim(void)
+static void SafariHandleSwitchInAnim(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleReturnMonToBall(void)
+static void SafariHandleReturnMonToBall(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleDrawTrainerPic(void)
+static void SafariHandleDrawTrainerPic(u32 battler)
 {
     DecompressTrainerBackPalette(gSaveBlock2Ptr->playerGender, gActiveBattler);
     SetMultiuseSpriteTemplateToTrainerBack(gSaveBlock2Ptr->playerGender, GetBattlerPosition(gActiveBattler));
@@ -352,27 +352,27 @@ static void SafariHandleDrawTrainerPic(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnBattlerSpriteCallbackDummy;
 }
 
-static void SafariHandleTrainerSlide(void)
+static void SafariHandleTrainerSlide(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleTrainerSlideBack(void)
+static void SafariHandleTrainerSlideBack(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleFaintAnimation(void)
+static void SafariHandleFaintAnimation(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandlePaletteFade(void)
+static void SafariHandlePaletteFade(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleSuccessBallThrowAnim(void)
+static void SafariHandleSuccessBallThrowAnim(u32 battler)
 {
     gBattleSpritesDataPtr->animationData->ballThrowCaseId = BALL_3_SHAKES_SUCCESS;
     gDoingBattleAnim = TRUE;
@@ -380,7 +380,7 @@ static void SafariHandleSuccessBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void SafariHandleBallThrowAnim(void)
+static void SafariHandleBallThrowAnim(u32 battler)
 {
     u8 ballThrowCaseId = gBattleBufferA[gActiveBattler][1];
 
@@ -390,17 +390,17 @@ static void SafariHandleBallThrowAnim(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnSpecialAnimDone;
 }
 
-static void SafariHandlePause(void)
+static void SafariHandlePause(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleMoveAnimation(void)
+static void SafariHandleMoveAnimation(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandlePrintString(void)
+static void SafariHandlePrintString(u32 battler)
 {
     u16 *stringId;
 
@@ -415,15 +415,15 @@ static void SafariHandlePrintString(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnInactiveTextPrinter;
 }
 
-static void SafariHandlePrintSelectionString(void)
+static void SafariHandlePrintSelectionString(u32 battler)
 {
     if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER)
-        SafariHandlePrintString();
+        SafariHandlePrintString(battler);
     else
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
 }
 
-static void HandleChooseActionAfterDma3(void)
+static void HandleChooseActionAfterDma3(u32 battler)
 {
     if (!IsDma3ManagerBusyWithBgCopy())
     {
@@ -433,7 +433,7 @@ static void HandleChooseActionAfterDma3(void)
     }
 }
 
-static void SafariHandleChooseAction(void)
+static void SafariHandleChooseAction(u32 battler)
 {
     s32 i;
 
@@ -447,17 +447,17 @@ static void SafariHandleChooseAction(void)
     BattlePutTextOnWindow(gDisplayedStringBattle, B_WIN_ACTION_PROMPT);
 }
 
-static void SafariHandleUnknownYesNoBox(void)
+static void SafariHandleUnknownYesNoBox(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleChooseMove(void)
+static void SafariHandleChooseMove(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleChooseItem(void)
+static void SafariHandleChooseItem(u32 battler)
 {
     s32 i;
 
@@ -466,113 +466,113 @@ static void SafariHandleChooseItem(void)
     gBattlerInMenuId = gActiveBattler;
 }
 
-static void SafariHandleChoosePokemon(void)
+static void SafariHandleChoosePokemon(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd23(void)
+static void SafariHandleCmd23(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleHealthBarUpdate(void)
+static void SafariHandleHealthBarUpdate(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleExpUpdate(void)
+static void SafariHandleExpUpdate(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleStatusIconUpdate(void)
+static void SafariHandleStatusIconUpdate(u32 battler)
 {
     UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_BALLS_TEXT);
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleStatusAnimation(void)
+static void SafariHandleStatusAnimation(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleStatusXor(void)
+static void SafariHandleStatusXor(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleDataTransfer(void)
+static void SafariHandleDataTransfer(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleDMA3Transfer(void)
+static void SafariHandleDMA3Transfer(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandlePlayBGM(void)
+static void SafariHandlePlayBGM(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd32(void)
+static void SafariHandleCmd32(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleTwoReturnValues(void)
+static void SafariHandleTwoReturnValues(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleChosenMonReturnValue(void)
+static void SafariHandleChosenMonReturnValue(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleOneReturnValue(void)
+static void SafariHandleOneReturnValue(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleOneReturnValue_Duplicate(void)
+static void SafariHandleOneReturnValue_Duplicate(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd37(void)
+static void SafariHandleCmd37(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd38(void)
+static void SafariHandleCmd38(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd39(void)
+static void SafariHandleCmd39(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd40(void)
+static void SafariHandleCmd40(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleHitAnimation(void)
+static void SafariHandleHitAnimation(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd42(void)
+static void SafariHandleCmd42(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandlePlaySE(void)
+static void SafariHandlePlaySE(u32 battler)
 {
     s8 pan;
 
@@ -581,31 +581,31 @@ static void SafariHandlePlaySE(void)
     else
         pan = SOUND_PAN_TARGET;
     PlaySE12WithPanning(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8), pan);
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandlePlayFanfareOrBGM(void)
+static void SafariHandlePlayFanfareOrBGM(u32 battler)
 {
     PlayFanfare(gBattleBufferA[gActiveBattler][1] | (gBattleBufferA[gActiveBattler][2] << 8));
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleFaintingCry(void)
+static void SafariHandleFaintingCry(u32 battler)
 {
     u16 species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], MON_DATA_SPECIES);
 
     PlayCry_Normal(species, 25);
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleIntroSlide(void)
+static void SafariHandleIntroSlide(u32 battler)
 {
     HandleIntroSlide(gBattleBufferA[gActiveBattler][1]);
     gIntroSlideFlags |= 1;
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleIntroTrainerBallThrow(void)
+static void SafariHandleIntroTrainerBallThrow(u32 battler)
 {
     UpdateHealthboxAttribute(gHealthboxSpriteIds[gActiveBattler], &gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], HEALTHBOX_SAFARI_ALL_TEXT);
     StartHealthboxSlideIn(gActiveBattler);
@@ -613,57 +613,57 @@ static void SafariHandleIntroTrainerBallThrow(void)
     gBattlerControllerFuncs[gActiveBattler] = CompleteOnHealthboxSpriteCallbackDummy;
 }
 
-static void SafariHandleDrawPartyStatusSummary(void)
+static void SafariHandleDrawPartyStatusSummary(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleHidePartyStatusSummary(void)
+static void SafariHandleHidePartyStatusSummary(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleEndBounceEffect(void)
+static void SafariHandleEndBounceEffect(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleSpriteInvisibility(void)
+static void SafariHandleSpriteInvisibility(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleBattleAnimation(void)
+static void SafariHandleBattleAnimation(u32 battler)
 {
     u8 animationId = gBattleBufferA[gActiveBattler][1];
     u16 argument = gBattleBufferA[gActiveBattler][2] | (gBattleBufferA[gActiveBattler][3] << 8);
 
     if (TryHandleLaunchBattleTableAnimation(gActiveBattler, gActiveBattler, gActiveBattler, animationId, argument))
-        SafariBufferExecCompleted();
+        SafariBufferExecCompleted(battler);
     else
         gBattlerControllerFuncs[gActiveBattler] = CompleteOnFinishedBattleAnimation;
 }
 
-static void SafariHandleLinkStandbyMsg(void)
+static void SafariHandleLinkStandbyMsg(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleResetActionMoveSelection(void)
+static void SafariHandleResetActionMoveSelection(u32 battler)
 {
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
 }
 
-static void SafariHandleCmd55(void)
+static void SafariHandleCmd55(u32 battler)
 {
     gBattleOutcome = gBattleBufferA[gActiveBattler][1];
     FadeOutMapMusic(5);
     BeginFastPaletteFade(3);
-    SafariBufferExecCompleted();
+    SafariBufferExecCompleted(battler);
     if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER))
         gBattlerControllerFuncs[gActiveBattler] = Safari_SetBattleEndCallbacks;
 }
 
-static void SafariCmdEnd(void)
+static void SafariCmdEnd(u32 battler)
 {
 }
diff --git a/src/battle_main.c b/src/battle_main.c
index 894081ca8..1a81d5e92 100644
--- a/src/battle_main.c
+++ b/src/battle_main.c
@@ -237,7 +237,7 @@ void (*gPreBattleCallback1)(void);
 void (*gBattleMainFunc)(void);
 struct BattleResults gBattleResults;
 u8 gLeveledUpInBattle;
-void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void);
+void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(u32 battler);
 u8 gHealthboxSpriteIds[MAX_BATTLERS_COUNT];
 u8 gMultiUsePlayerCursor;
 u8 gNumberOfMovesToChoose;
@@ -2523,7 +2523,7 @@ static void BattleMainCB1(void)
     gBattleMainFunc();
 
     for (gActiveBattler = 0; gActiveBattler < gBattlersCount; gActiveBattler++)
-        gBattlerControllerFuncs[gActiveBattler]();
+        gBattlerControllerFuncs[gActiveBattler](gActiveBattler);
 }
 
 static void ClearSetBScriptingStruct(void)