start working on battle controllers, especially player

8 files changed, 2064 insertions, 34 deletions

diff --git a/src/battle_2.c b/src/battle_2.c
index 16c07114a..c50295eba 100644
--- a/src/battle_2.c
+++ b/src/battle_2.c
@@ -2257,7 +2257,7 @@ static void sub_803939C(void)
             sub_8056A3C(0x18, 8, 0x1D, 0xD, 0);
             sub_814F9EC(gText_BattleYesNoChoice, 0xC);
             gBattleCommunication[CURSOR_POSITION] = 1;
-            BattleCreateCursorAt(1);
+            BattleCreateYesNoCursorAt(1);
             gBattleCommunication[MULTIUSE_STATE]++;
         }
         break;
@@ -2267,9 +2267,9 @@ static void sub_803939C(void)
             if (gBattleCommunication[CURSOR_POSITION] != 0)
             {
                 PlaySE(SE_SELECT);
-                BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+                BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
                 gBattleCommunication[CURSOR_POSITION] = 0;
-                BattleCreateCursorAt(0);
+                BattleCreateYesNoCursorAt(0);
             }
         }
         else if (gMain.newKeys & DPAD_DOWN)
@@ -2277,9 +2277,9 @@ static void sub_803939C(void)
             if (gBattleCommunication[CURSOR_POSITION] == 0)
             {
                 PlaySE(SE_SELECT);
-                BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+                BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
                 gBattleCommunication[CURSOR_POSITION] = 1;
-                BattleCreateCursorAt(1);
+                BattleCreateYesNoCursorAt(1);
             }
         }
         else if (gMain.newKeys & A_BUTTON)
diff --git a/src/battle_controller_linkopponent.c b/src/battle_controller_linkopponent.c
new file mode 100644
index 000000000..fdb9ee10d
--- /dev/null
+++ b/src/battle_controller_linkopponent.c
@@ -0,0 +1,143 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "battle_interface.h"
+#include "battle_anim.h"
+#include "link.h"
+
+extern u8 gActiveBank;
+extern bool8 gDoingBattleAnim;
+extern u8 gUnknown_020244CC;
+extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+
+// this file's functions
+void LinkOpponentHandleGetMonData(void);
+void LinkOpponentHandleGetRawMonData(void);
+void LinkOpponentHandleSetMonData(void);
+void LinkOpponentHandleSetRawMonData(void);
+void LinkOpponentHandleLoadMonSprite(void);
+void LinkOpponentHandleSwitchInAnim(void);
+void LinkOpponentHandleReturnMonToBall(void);
+void LinkOpponentHandleDrawTrainerPic(void);
+void LinkOpponentHandleTrainerSlide(void);
+void LinkOpponentHandleTrainerSlideBack(void);
+void LinkOpponentHandleFaintAnimation(void);
+void LinkOpponentHandleCmd11(void);
+void LinkOpponentHandleCmd12(void);
+void LinkOpponentHandleBallThrow(void);
+void LinkOpponentHandlePause(void);
+void LinkOpponentHandleMoveAnimation(void);
+void LinkOpponentHandlePrintString(void);
+void LinkOpponentHandlePrintStringPlayerOnly(void);
+void LinkOpponentHandleChooseAction(void);
+void LinkOpponentHandleCmd19(void);
+void LinkOpponentHandleChooseMove(void);
+void LinkOpponentHandleOpenBag(void);
+void LinkOpponentHandleChoosePokemon(void);
+void LinkOpponentHandleCmd23(void);
+void LinkOpponentHandleHealthBarUpdate(void);
+void LinkOpponentHandleExpUpdate(void);
+void LinkOpponentHandleStatusIconUpdate(void);
+void LinkOpponentHandleStatusAnimation(void);
+void LinkOpponentHandleStatusXor(void);
+void LinkOpponentHandleDataTransfer(void);
+void LinkOpponentHandleDMA3Transfer(void);
+void LinkOpponentHandlePlayBGM(void);
+void LinkOpponentHandleCmd32(void);
+void LinkOpponentHandleCmd33(void);
+void LinkOpponentHandleCmd34(void);
+void LinkOpponentHandleCmd35(void);
+void LinkOpponentHandleCmd36(void);
+void LinkOpponentHandleCmd37(void);
+void LinkOpponentHandleCmd38(void);
+void LinkOpponentHandleCmd39(void);
+void LinkOpponentHandleCmd40(void);
+void LinkOpponentHandleHitAnimation(void);
+void LinkOpponentHandleCmd42(void);
+void LinkOpponentHandleEffectivenessSound(void);
+void LinkOpponentHandlePlayFanfareOrBGM(void);
+void LinkOpponentHandleFaintingCry(void);
+void LinkOpponentHandleIntroSlide(void);
+void LinkOpponentHandleIntroTrainerBallThrow(void);
+void LinkOpponentHandleDrawPartyStatusSummary(void);
+void LinkOpponentHandleCmd49(void);
+void LinkOpponentHandleCmd50(void);
+void LinkOpponentHandleSpriteInvisibility(void);
+void LinkOpponentHandleBattleAnimation(void);
+void LinkOpponentHandleLinkStandbyMsg(void);
+void LinkOpponentHandleResetActionMoveSelection(void);
+void LinkOpponentHandleCmd55(void);
+void nullsub_92(void);
+
+void LinkOpponentBufferRunCommand(void);
+
+void (*const gLinkOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) =
+{
+    LinkOpponentHandleGetMonData,
+    LinkOpponentHandleGetRawMonData,
+    LinkOpponentHandleSetMonData,
+    LinkOpponentHandleSetRawMonData,
+    LinkOpponentHandleLoadMonSprite,
+    LinkOpponentHandleSwitchInAnim,
+    LinkOpponentHandleReturnMonToBall,
+    LinkOpponentHandleDrawTrainerPic,
+    LinkOpponentHandleTrainerSlide,
+    LinkOpponentHandleTrainerSlideBack,
+    LinkOpponentHandleFaintAnimation,
+    LinkOpponentHandleCmd11,
+    LinkOpponentHandleCmd12,
+    LinkOpponentHandleBallThrow,
+    LinkOpponentHandlePause,
+    LinkOpponentHandleMoveAnimation,
+    LinkOpponentHandlePrintString,
+    LinkOpponentHandlePrintStringPlayerOnly,
+    LinkOpponentHandleChooseAction,
+    LinkOpponentHandleCmd19,
+    LinkOpponentHandleChooseMove,
+    LinkOpponentHandleOpenBag,
+    LinkOpponentHandleChoosePokemon,
+    LinkOpponentHandleCmd23,
+    LinkOpponentHandleHealthBarUpdate,
+    LinkOpponentHandleExpUpdate,
+    LinkOpponentHandleStatusIconUpdate,
+    LinkOpponentHandleStatusAnimation,
+    LinkOpponentHandleStatusXor,
+    LinkOpponentHandleDataTransfer,
+    LinkOpponentHandleDMA3Transfer,
+    LinkOpponentHandlePlayBGM,
+    LinkOpponentHandleCmd32,
+    LinkOpponentHandleCmd33,
+    LinkOpponentHandleCmd34,
+    LinkOpponentHandleCmd35,
+    LinkOpponentHandleCmd36,
+    LinkOpponentHandleCmd37,
+    LinkOpponentHandleCmd38,
+    LinkOpponentHandleCmd39,
+    LinkOpponentHandleCmd40,
+    LinkOpponentHandleHitAnimation,
+    LinkOpponentHandleCmd42,
+    LinkOpponentHandleEffectivenessSound,
+    LinkOpponentHandlePlayFanfareOrBGM,
+    LinkOpponentHandleFaintingCry,
+    LinkOpponentHandleIntroSlide,
+    LinkOpponentHandleIntroTrainerBallThrow,
+    LinkOpponentHandleDrawPartyStatusSummary,
+    LinkOpponentHandleCmd49,
+    LinkOpponentHandleCmd50,
+    LinkOpponentHandleSpriteInvisibility,
+    LinkOpponentHandleBattleAnimation,
+    LinkOpponentHandleLinkStandbyMsg,
+    LinkOpponentHandleResetActionMoveSelection,
+    LinkOpponentHandleCmd55,
+    nullsub_92
+};
+
+void nullsub_28(void)
+{
+}
+
+void SetBankFuncToLinkOpponentBufferRunCommand(void)
+{
+    gBattleBankFunc[gActiveBank] = LinkOpponentBufferRunCommand;
+}
diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c
new file mode 100644
index 000000000..9c72b19dc
--- /dev/null
+++ b/src/battle_controller_opponent.c
@@ -0,0 +1,146 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "battle_interface.h"
+#include "battle_anim.h"
+#include "link.h"
+
+extern u8 gActiveBank;
+extern bool8 gDoingBattleAnim;
+extern u8 gUnknown_020244CC;
+extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+
+// this file's functions
+void OpponentHandleGetMonData(void);
+void OpponentHandleGetRawMonData(void);
+void OpponentHandleSetMonData(void);
+void OpponentHandleSetRawMonData(void);
+void OpponentHandleLoadMonSprite(void);
+void OpponentHandleSwitchInAnim(void);
+void OpponentHandleReturnMonToBall(void);
+void OpponentHandleDrawTrainerPic(void);
+void OpponentHandleTrainerSlide(void);
+void OpponentHandleTrainerSlideBack(void);
+void OpponentHandleFaintAnimation(void);
+void OpponentHandleCmd11(void);
+void OpponentHandleCmd12(void);
+void OpponentHandleBallThrow(void);
+void OpponentHandlePause(void);
+void OpponentHandleMoveAnimation(void);
+void OpponentHandlePrintString(void);
+void OpponentHandlePrintStringPlayerOnly(void);
+void OpponentHandleChooseAction(void);
+void OpponentHandleCmd19(void);
+void OpponentHandleChooseMove(void);
+void OpponentHandleOpenBag(void);
+void OpponentHandleChoosePokemon(void);
+void OpponentHandleCmd23(void);
+void OpponentHandleHealthBarUpdate(void);
+void OpponentHandleExpUpdate(void);
+void OpponentHandleStatusIconUpdate(void);
+void OpponentHandleStatusAnimation(void);
+void OpponentHandleStatusXor(void);
+void OpponentHandleDataTransfer(void);
+void OpponentHandleDMA3Transfer(void);
+void OpponentHandlePlayBGM(void);
+void OpponentHandleCmd32(void);
+void OpponentHandleCmd33(void);
+void OpponentHandleCmd34(void);
+void OpponentHandleCmd35(void);
+void OpponentHandleCmd36(void);
+void OpponentHandleCmd37(void);
+void OpponentHandleCmd38(void);
+void OpponentHandleCmd39(void);
+void OpponentHandleCmd40(void);
+void OpponentHandleHitAnimation(void);
+void OpponentHandleCmd42(void);
+void OpponentHandleEffectivenessSound(void);
+void OpponentHandlePlayFanfareOrBGM(void);
+void OpponentHandleFaintingCry(void);
+void OpponentHandleIntroSlide(void);
+void OpponentHandleIntroTrainerBallThrow(void);
+void OpponentHandleDrawPartyStatusSummary(void);
+void OpponentHandleCmd49(void);
+void OpponentHandleCmd50(void);
+void OpponentHandleSpriteInvisibility(void);
+void OpponentHandleBattleAnimation(void);
+void OpponentHandleLinkStandbyMsg(void);
+void OpponentHandleResetActionMoveSelection(void);
+void OpponentHandleCmd55(void);
+void nullsub_91(void);
+
+void OpponentBufferRunCommand(void);
+
+void (*const gOpponentBufferCommands[CONTOLLER_CMDS_CONT])(void) =
+{
+    OpponentHandleGetMonData,
+    OpponentHandleGetRawMonData,
+    OpponentHandleSetMonData,
+    OpponentHandleSetRawMonData,
+    OpponentHandleLoadMonSprite,
+    OpponentHandleSwitchInAnim,
+    OpponentHandleReturnMonToBall,
+    OpponentHandleDrawTrainerPic,
+    OpponentHandleTrainerSlide,
+    OpponentHandleTrainerSlideBack,
+    OpponentHandleFaintAnimation,
+    OpponentHandleCmd11,
+    OpponentHandleCmd12,
+    OpponentHandleBallThrow,
+    OpponentHandlePause,
+    OpponentHandleMoveAnimation,
+    OpponentHandlePrintString,
+    OpponentHandlePrintStringPlayerOnly,
+    OpponentHandleChooseAction,
+    OpponentHandleCmd19,
+    OpponentHandleChooseMove,
+    OpponentHandleOpenBag,
+    OpponentHandleChoosePokemon,
+    OpponentHandleCmd23,
+    OpponentHandleHealthBarUpdate,
+    OpponentHandleExpUpdate,
+    OpponentHandleStatusIconUpdate,
+    OpponentHandleStatusAnimation,
+    OpponentHandleStatusXor,
+    OpponentHandleDataTransfer,
+    OpponentHandleDMA3Transfer,
+    OpponentHandlePlayBGM,
+    OpponentHandleCmd32,
+    OpponentHandleCmd33,
+    OpponentHandleCmd34,
+    OpponentHandleCmd35,
+    OpponentHandleCmd36,
+    OpponentHandleCmd37,
+    OpponentHandleCmd38,
+    OpponentHandleCmd39,
+    OpponentHandleCmd40,
+    OpponentHandleHitAnimation,
+    OpponentHandleCmd42,
+    OpponentHandleEffectivenessSound,
+    OpponentHandlePlayFanfareOrBGM,
+    OpponentHandleFaintingCry,
+    OpponentHandleIntroSlide,
+    OpponentHandleIntroTrainerBallThrow,
+    OpponentHandleDrawPartyStatusSummary,
+    OpponentHandleCmd49,
+    OpponentHandleCmd50,
+    OpponentHandleSpriteInvisibility,
+    OpponentHandleBattleAnimation,
+    OpponentHandleLinkStandbyMsg,
+    OpponentHandleResetActionMoveSelection,
+    OpponentHandleCmd55,
+    nullsub_91
+};
+
+// unknown unused data
+static const u8 gUnknown_0831C7AC[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20};
+
+void nullsub_26(void)
+{
+}
+
+void SetBankFuncToOpponentBufferRunCommand(void)
+{
+    gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand;
+}
diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c
new file mode 100644
index 000000000..33807b39a
--- /dev/null
+++ b/src/battle_controller_player.c
@@ -0,0 +1,1600 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "battle_interface.h"
+#include "battle_anim.h"
+#include "pokemon.h"
+#include "link.h"
+#include "util.h"
+#include "main.h"
+#include "item.h"
+#include "items.h"
+#include "songs.h"
+#include "sound.h"
+#include "moves.h"
+#include "window.h"
+#include "m4a.h"
+#include "palette.h"
+#include "task.h"
+#include "text.h"
+#include "string_util.h"
+#include "bg.h"
+#include "reshow_battle_screen.h"
+
+extern u32 gBattleExecBuffer;
+extern u8 gActiveBank;
+extern u8 gBankSpriteIds[BATTLE_BANKS_COUNT];
+extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT];
+extern u8 gAbsentBankFlags;
+extern u8 gNoOfAllBanks;
+extern bool8 gDoingBattleAnim;
+extern u8 gUnknown_020244CC;
+extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+extern void (*gPreBattleCallback1)(void);
+extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
+extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
+extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200];
+extern u8 gMultiUsePlayerCursor;
+extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern struct MusicPlayerInfo gMPlay_BGM;
+
+extern const struct BattleMove gBattleMoves[];
+
+extern void dp11b_obj_instanciate(u8, u8, s8, s8);
+extern void dp11b_obj_free(u8, u8);
+extern void sub_800AC34(void);
+
+// this file's functions
+void PlayerHandleGetMonData(void);
+void PlayerHandleGetRawMonData(void);
+void PlayerHandleSetMonData(void);
+void PlayerHandleSetRawMonData(void);
+void PlayerHandleLoadMonSprite(void);
+void PlayerHandleSwitchInAnim(void);
+void PlayerHandleReturnMonToBall(void);
+void PlayerHandleDrawTrainerPic(void);
+void PlayerHandleTrainerSlide(void);
+void PlayerHandleTrainerSlideBack(void);
+void PlayerHandleFaintAnimation(void);
+void PlayerHandleCmd11(void);
+void PlayerHandleCmd12(void);
+void PlayerHandleBallThrow(void);
+void PlayerHandlePause(void);
+void PlayerHandleMoveAnimation(void);
+void PlayerHandlePrintString(void);
+void PlayerHandlePrintStringPlayerOnly(void);
+void PlayerHandleChooseAction(void);
+void PlayerHandleCmd19(void);
+void PlayerHandleChooseMove(void);
+void PlayerHandleOpenBag(void);
+void PlayerHandleChoosePokemon(void);
+void PlayerHandleCmd23(void);
+void PlayerHandleHealthBarUpdate(void);
+void PlayerHandleExpUpdate(void);
+void PlayerHandleStatusIconUpdate(void);
+void PlayerHandleStatusAnimation(void);
+void PlayerHandleStatusXor(void);
+void PlayerHandleDataTransfer(void);
+void PlayerHandleDMA3Transfer(void);
+void PlayerHandlePlayBGM(void);
+void PlayerHandleCmd32(void);
+void PlayerHandleCmd33(void);
+void PlayerHandleCmd34(void);
+void PlayerHandleCmd35(void);
+void PlayerHandleCmd36(void);
+void PlayerHandleCmd37(void);
+void PlayerHandleCmd38(void);
+void PlayerHandleCmd39(void);
+void PlayerHandleCmd40(void);
+void PlayerHandleHitAnimation(void);
+void PlayerHandleCmd42(void);
+void PlayerHandleEffectivenessSound(void);
+void PlayerHandlePlayFanfareOrBGM(void);
+void PlayerHandleFaintingCry(void);
+void PlayerHandleIntroSlide(void);
+void PlayerHandleIntroTrainerBallThrow(void);
+void PlayerHandleDrawPartyStatusSummary(void);
+void PlayerHandleCmd49(void);
+void PlayerHandleCmd50(void);
+void PlayerHandleSpriteInvisibility(void);
+void PlayerHandleBattleAnimation(void);
+void PlayerHandleLinkStandbyMsg(void);
+void PlayerHandleResetActionMoveSelection(void);
+void PlayerHandleCmd55(void);
+void nullsub_22(void);
+
+void PlayerBufferRunCommand(void);
+void HandleInputChooseTarget(void);
+void HandleInputChooseMove(void);
+void MoveSelectionCreateCursorAt(u8 cursorPos, u8 arg1);
+void MoveSelectionDestroyCursorAt(u8 cursorPos);
+void MoveSelectionDisplayPpNumber(void);
+void MoveSelectionDisplayPpString(void);
+void MoveSelectionDisplayMoveType(void);
+void MoveSelectionDisplayMoveNames(void);
+void HandleMoveSwitchting(void);
+void sub_8058FC0(void);
+void sub_8059828(void);
+void sub_80598E0(void);
+void sub_8059544(u8 taskId);
+void sub_8059330(u8 taskId);
+void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId);
+void sub_8059400(u8 taskId);
+void sub_80595A4(u8 taskId);
+void PrintLinkStandbyMsg(void);
+
+void (*const gPlayerBufferCommands[CONTOLLER_CMDS_COUNT])(void) =
+{
+    PlayerHandleGetMonData,
+    PlayerHandleGetRawMonData,
+    PlayerHandleSetMonData,
+    PlayerHandleSetRawMonData,
+    PlayerHandleLoadMonSprite,
+    PlayerHandleSwitchInAnim,
+    PlayerHandleReturnMonToBall,
+    PlayerHandleDrawTrainerPic,
+    PlayerHandleTrainerSlide,
+    PlayerHandleTrainerSlideBack,
+    PlayerHandleFaintAnimation,
+    PlayerHandleCmd11,
+    PlayerHandleCmd12,
+    PlayerHandleBallThrow,
+    PlayerHandlePause,
+    PlayerHandleMoveAnimation,
+    PlayerHandlePrintString,
+    PlayerHandlePrintStringPlayerOnly,
+    PlayerHandleChooseAction,
+    PlayerHandleCmd19,
+    PlayerHandleChooseMove,
+    PlayerHandleOpenBag,
+    PlayerHandleChoosePokemon,
+    PlayerHandleCmd23,
+    PlayerHandleHealthBarUpdate,
+    PlayerHandleExpUpdate,
+    PlayerHandleStatusIconUpdate,
+    PlayerHandleStatusAnimation,
+    PlayerHandleStatusXor,
+    PlayerHandleDataTransfer,
+    PlayerHandleDMA3Transfer,
+    PlayerHandlePlayBGM,
+    PlayerHandleCmd32,
+    PlayerHandleCmd33,
+    PlayerHandleCmd34,
+    PlayerHandleCmd35,
+    PlayerHandleCmd36,
+    PlayerHandleCmd37,
+    PlayerHandleCmd38,
+    PlayerHandleCmd39,
+    PlayerHandleCmd40,
+    PlayerHandleHitAnimation,
+    PlayerHandleCmd42,
+    PlayerHandleEffectivenessSound,
+    PlayerHandlePlayFanfareOrBGM,
+    PlayerHandleFaintingCry,
+    PlayerHandleIntroSlide,
+    PlayerHandleIntroTrainerBallThrow,
+    PlayerHandleDrawPartyStatusSummary,
+    PlayerHandleCmd49,
+    PlayerHandleCmd50,
+    PlayerHandleSpriteInvisibility,
+    PlayerHandleBattleAnimation,
+    PlayerHandleLinkStandbyMsg,
+    PlayerHandleResetActionMoveSelection,
+    PlayerHandleCmd55,
+    nullsub_22
+};
+
+static const u8 sTargetIdentities[] = {IDENTITY_PLAYER_MON1, IDENTITY_PLAYER_MON2, IDENTITY_OPPONENT_MON2, IDENTITY_OPPONENT_MON1};
+
+// unknown unused data
+static const u8 gUnknown_0831C5FC[] = {0x48, 0x48, 0x20, 0x5a, 0x50, 0x50, 0x50, 0x58};
+
+void nullsub_21(void)
+{
+}
+
+void SetBankFuncToPlayerBufferRunCommand(void)
+{
+    gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand;
+    gDoingBattleAnim = FALSE;
+    gUnknown_020244CC = 0;
+}
+
+void PlayerBufferExecCompleted(void)
+{
+    gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand;
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        u8 playerId = GetMultiplayerId();
+
+        PrepareBufferDataTransferLink(2, 4, &playerId);
+        gBattleBufferA[gActiveBank][0] = CONTOLLER_CMDS_COUNT - 1;
+    }
+    else
+    {
+        gBattleExecBuffer &= ~gBitTable[gActiveBank];
+    }
+}
+
+void PlayerBufferRunCommand(void)
+{
+    if (gBattleExecBuffer & gBitTable[gActiveBank])
+    {
+        if (gBattleBufferA[gActiveBank][0] < ARRAY_COUNT(gPlayerBufferCommands))
+            gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]]();
+        else
+            PlayerBufferExecCompleted();
+    }
+}
+
+void CompleteOnBankSpritePosX_0(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBank]].pos2.x == 0)
+        PlayerBufferExecCompleted();
+}
+
+void HandleInputChooseAction(void)
+{
+    u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8);
+
+    dp11b_obj_instanciate(gActiveBank, 1, 7, 1);
+    dp11b_obj_instanciate(gActiveBank, 0, 7, 1);
+
+    if (gMain.newAndRepeatedKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2)
+        gUnknown_020244CC++;
+    else
+        gUnknown_020244CC = 0;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        PlaySE(SE_SELECT);
+
+        switch (gActionSelectionCursor[gActiveBank])
+        {
+        case ACTION_USE_MOVE:
+            EmitCmd33(1, ACTION_USE_MOVE, 0);
+            break;
+        case ACTION_USE_ITEM:
+            EmitCmd33(1, ACTION_USE_ITEM, 0);
+            break;
+        case ACTION_SWITCH:
+            EmitCmd33(1, ACTION_SWITCH, 0);
+            break;
+        case ACTION_RUN:
+            EmitCmd33(1, ACTION_RUN, 0);
+            break;
+        }
+        PlayerBufferExecCompleted();
+    }
+    else if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (gActionSelectionCursor[gActiveBank] & 1) // if is ACTION_USE_ITEM or ACTION_RUN
+        {
+            PlaySE(SE_SELECT);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
+            gActionSelectionCursor[gActiveBank] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+        }
+    }
+    else if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (!(gActionSelectionCursor[gActiveBank] & 1)) // if is ACTION_USE_MOVE or ACTION_SWITCH
+        {
+            PlaySE(SE_SELECT);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
+            gActionSelectionCursor[gActiveBank] ^= 1;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+        }
+    }
+    else if (gMain.newKeys & DPAD_UP)
+    {
+        if (gActionSelectionCursor[gActiveBank] & 2) // if is ACTION_SWITCH or ACTION_RUN
+        {
+            PlaySE(SE_SELECT);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
+            gActionSelectionCursor[gActiveBank] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+        }
+    }
+    else if (gMain.newKeys & DPAD_DOWN)
+    {
+        if (!(gActionSelectionCursor[gActiveBank] & 2)) // if is ACTION_USE_MOVE or ACTION_USE_ITEM
+        {
+            PlaySE(SE_SELECT);
+            ActionSelectionDestroyCursorAt(gActionSelectionCursor[gActiveBank]);
+            gActionSelectionCursor[gActiveBank] ^= 2;
+            ActionSelectionCreateCursorAt(gActionSelectionCursor[gActiveBank], 0);
+        }
+    }
+    else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59)
+    {
+        if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
+         && GetBankIdentity(gActiveBank) == IDENTITY_PLAYER_MON2
+         && !(gAbsentBankFlags & gBitTable[GetBankByIdentity(IDENTITY_PLAYER_MON1)])
+         && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+        {
+            if (gBattleBufferA[gActiveBank][1] == ACTION_USE_ITEM)
+            {
+                // Add item to bag if it is a ball
+                if (itemId <= ITEM_PREMIER_BALL)
+                    AddBagItem(itemId, 1);
+                else
+                    return;
+            }
+            PlaySE(SE_SELECT);
+            EmitCmd33(1, ACTION_CANCEL_PARTNER, 0);
+            PlayerBufferExecCompleted();
+        }
+    }
+    else if (gMain.newKeys & START_BUTTON)
+    {
+        SwapHpBarsWithHpText();
+    }
+}
+
+void sub_80577F0(void) // unused
+{
+    dp11b_obj_free(gActiveBank, 1);
+    dp11b_obj_free(gActiveBank, 0);
+    gBattleBankFunc[gActiveBank] = HandleInputChooseTarget;
+}
+
+void HandleInputChooseTarget(void)
+{
+    s32 i;
+    u8 identities[4];
+    memcpy(identities, sTargetIdentities, ARRAY_COUNT(sTargetIdentities));
+
+    dp11b_obj_instanciate(gMultiUsePlayerCursor, 1, 0xF, 1);
+
+    // what a weird loop
+    i = 0;
+    if (gNoOfAllBanks != 0)
+    {
+        do
+        {
+            if (i != gMultiUsePlayerCursor)
+                dp11b_obj_free(i, 1);
+            i++;
+        } while (i < gNoOfAllBanks);
+    }
+
+    if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2)
+        gUnknown_020244CC++;
+    else
+        gUnknown_020244CC = 0;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        PlaySE(SE_SELECT);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C;
+        EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8));
+        dp11b_obj_free(gMultiUsePlayerCursor, 1);
+        PlayerBufferExecCompleted();
+    }
+    else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59)
+    {
+        PlaySE(SE_SELECT);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C;
+        gBattleBankFunc[gActiveBank] = HandleInputChooseMove;
+        dp11b_obj_instanciate(gActiveBank, 1, 7, 1);
+        dp11b_obj_instanciate(gActiveBank, 0, 7, 1);
+        dp11b_obj_free(gMultiUsePlayerCursor, 1);
+    }
+    else if (gMain.newKeys & (DPAD_LEFT | DPAD_UP))
+    {
+        PlaySE(SE_SELECT);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C;
+
+        do
+        {
+            u8 currSelIdentity = GetBankIdentity(gMultiUsePlayerCursor);
+
+            for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+            {
+                if (currSelIdentity == identities[i])
+                    break;
+            }
+            do
+            {
+                if (--i < 0)
+                    i = 4; // UB: array out of range
+                gMultiUsePlayerCursor = GetBankByIdentity(identities[i]);
+            } while (gMultiUsePlayerCursor == gNoOfAllBanks);
+
+            i = 0;
+            switch (GetBankIdentity(gMultiUsePlayerCursor))
+            {
+            case IDENTITY_PLAYER_MON1:
+            case IDENTITY_PLAYER_MON2:
+                if (gActiveBank != gMultiUsePlayerCursor)
+                    i++;
+                else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank])].target & MOVE_TARGET_USER)
+                    i++;
+                break;
+            case IDENTITY_OPPONENT_MON1:
+            case IDENTITY_OPPONENT_MON2:
+                i++;
+                break;
+            }
+
+            if (gAbsentBankFlags & gBitTable[gMultiUsePlayerCursor])
+                i = 0;
+        } while (i == 0);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8;
+    }
+    else if (gMain.newKeys & (DPAD_RIGHT | DPAD_DOWN))
+    {
+        PlaySE(SE_SELECT);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039B2C;
+
+        do
+        {
+            u8 currSelIdentity = GetBankIdentity(gMultiUsePlayerCursor);
+
+            for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+            {
+                if (currSelIdentity == identities[i])
+                    break;
+            }
+            do
+            {
+                if (++i > 3)
+                    i = 0;
+                gMultiUsePlayerCursor = GetBankByIdentity(identities[i]);
+            } while (gMultiUsePlayerCursor == gNoOfAllBanks);
+
+            i = 0;
+            switch (GetBankIdentity(gMultiUsePlayerCursor))
+            {
+            case IDENTITY_PLAYER_MON1:
+            case IDENTITY_PLAYER_MON2:
+                if (gActiveBank != gMultiUsePlayerCursor)
+                    i++;
+                else if (gBattleMoves[GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank])].target & MOVE_TARGET_USER)
+                    i++;
+                break;
+            case IDENTITY_OPPONENT_MON1:
+            case IDENTITY_OPPONENT_MON2:
+                i++;
+                break;
+            }
+
+            if (gAbsentBankFlags & gBitTable[gMultiUsePlayerCursor])
+                i = 0;
+        } while (i == 0);
+        gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8;
+    }
+}
+
+extern u8 gNumberOfMovesToChoose;
+extern const u8 gText_BattleSwitchWhich[];
+
+void HandleInputChooseMove(void)
+{
+    bool32 canSelectTarget = FALSE;
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+
+    if (gMain.heldKeys & DPAD_ANY && gSaveBlock2Ptr->optionsButtonMode == 2)
+        gUnknown_020244CC++;
+    else
+        gUnknown_020244CC = 0;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        u8 moveTarget;
+
+        PlaySE(SE_SELECT);
+        if (moveInfo->moves[gMoveSelectionCursor[gActiveBank]] == MOVE_CURSE)
+        {
+            if (moveInfo->monType1 != TYPE_GHOST && moveInfo->monType2 != TYPE_GHOST)
+                moveTarget = MOVE_TARGET_x10;
+            else
+                moveTarget = MOVE_TARGET_SELECTED;
+        }
+        else
+        {
+            moveTarget = gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBank]]].target;
+        }
+
+        if (moveTarget & MOVE_TARGET_x10)
+            gMultiUsePlayerCursor = gActiveBank;
+        else
+            gMultiUsePlayerCursor = GetBankByIdentity((GetBankIdentity(gActiveBank) & BIT_SIDE) ^ BIT_SIDE);
+
+        if (!gBattleBufferA[gActiveBank][1]) // not a double battle
+        {
+            if (moveTarget & MOVE_TARGET_USER && !gBattleBufferA[gActiveBank][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_x10)))
+                canSelectTarget++; // either selected or user
+
+            if (moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]] == 0)
+            {
+                canSelectTarget = FALSE;
+            }
+            else if (!(moveTarget & (MOVE_TARGET_x10 | MOVE_TARGET_USER)) && CountAliveMonsInBattle(BATTLE_ALIVE_EXCEPT_ACTIVE) <= 1)
+            {
+                gMultiUsePlayerCursor = GetDefaultMoveTarget(gActiveBank);
+                canSelectTarget = FALSE;
+            }
+        }
+
+        if (!canSelectTarget)
+        {
+            EmitCmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gMultiUsePlayerCursor << 8));
+            PlayerBufferExecCompleted();
+        }
+        else
+        {
+            gBattleBankFunc[gActiveBank] = HandleInputChooseTarget;
+
+            if (moveTarget & (MOVE_TARGET_x10 | MOVE_TARGET_USER))
+                gMultiUsePlayerCursor = gActiveBank;
+            else if (gAbsentBankFlags & gBitTable[GetBankByIdentity(IDENTITY_OPPONENT_MON1)])
+                gMultiUsePlayerCursor = GetBankByIdentity(IDENTITY_OPPONENT_MON2);
+            else
+                gMultiUsePlayerCursor = GetBankByIdentity(IDENTITY_OPPONENT_MON1);
+
+            gSprites[gBankSpriteIds[gMultiUsePlayerCursor]].callback = sub_8039AD8;
+        }
+    }
+    else if (gMain.newKeys & B_BUTTON || gUnknown_020244CC > 59)
+    {
+        PlaySE(SE_SELECT);
+        EmitCmd33(1, 10, 0xFFFF);
+        PlayerBufferExecCompleted();
+    }
+    else if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (gMoveSelectionCursor[gActiveBank] & 1)
+        {
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+            gMoveSelectionCursor[gActiveBank] ^= 1;
+            PlaySE(SE_SELECT);
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+            MoveSelectionDisplayPpNumber();
+            MoveSelectionDisplayMoveType();
+        }
+    }
+    else if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (!(gMoveSelectionCursor[gActiveBank] & 1)
+         && (gMoveSelectionCursor[gActiveBank] ^ 1) < gNumberOfMovesToChoose)
+        {
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+            gMoveSelectionCursor[gActiveBank] ^= 1;
+            PlaySE(SE_SELECT);
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+            MoveSelectionDisplayPpNumber();
+            MoveSelectionDisplayMoveType();
+        }
+    }
+    else if (gMain.newKeys & DPAD_UP)
+    {
+        if (gMoveSelectionCursor[gActiveBank] & 2)
+        {
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+            gMoveSelectionCursor[gActiveBank] ^= 2;
+            PlaySE(SE_SELECT);
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+            MoveSelectionDisplayPpNumber();
+            MoveSelectionDisplayMoveType();
+        }
+    }
+    else if (gMain.newKeys & DPAD_DOWN)
+    {
+        if (!(gMoveSelectionCursor[gActiveBank] & 2)
+         && (gMoveSelectionCursor[gActiveBank] ^ 2) < gNumberOfMovesToChoose)
+        {
+            MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+            gMoveSelectionCursor[gActiveBank] ^= 2;
+            PlaySE(SE_SELECT);
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+            MoveSelectionDisplayPpNumber();
+            MoveSelectionDisplayMoveType();
+        }
+    }
+    else if (gMain.newKeys & SELECT_BUTTON)
+    {
+        if (gNumberOfMovesToChoose > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK))
+        {
+            MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29);
+
+            if (gMoveSelectionCursor[gActiveBank] != 0)
+                gMultiUsePlayerCursor = 0;
+            else
+                gMultiUsePlayerCursor = gMoveSelectionCursor[gActiveBank] + 1;
+
+            MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
+            sub_814F9EC(gText_BattleSwitchWhich, 0xB);
+            gBattleBankFunc[gActiveBank] = HandleMoveSwitchting;
+        }
+    }
+}
+
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG0_Y;
+
+u32 sub_8057FBC(void) // unused
+{
+    u32 var = 0;
+
+    if (gMain.newKeys & A_BUTTON)
+    {
+        PlaySE(SE_SELECT);
+        var = 1;
+    }
+    if (gMain.newKeys & B_BUTTON)
+    {
+        PlaySE(SE_SELECT);
+        gBattle_BG0_X = 0;
+        gBattle_BG0_Y = 0x140;
+        var = 0xFF;
+    }
+    if (gMain.newKeys & DPAD_LEFT && gMoveSelectionCursor[gActiveBank] & 1)
+    {
+        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+        gMoveSelectionCursor[gActiveBank] ^= 1;
+        PlaySE(SE_SELECT);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+    }
+    if (gMain.newKeys & DPAD_RIGHT && !(gMoveSelectionCursor[gActiveBank] & 1)
+        && (gMoveSelectionCursor[gActiveBank] ^ 1) < gNumberOfMovesToChoose)
+    {
+        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+        gMoveSelectionCursor[gActiveBank] ^= 1;
+        PlaySE(SE_SELECT);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+    }
+    if (gMain.newKeys & DPAD_UP && gMoveSelectionCursor[gActiveBank] & 2)
+    {
+        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+        gMoveSelectionCursor[gActiveBank] ^= 2;
+        PlaySE(SE_SELECT);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+    }
+    if (gMain.newKeys & DPAD_DOWN && !(gMoveSelectionCursor[gActiveBank] & 2)
+        && (gMoveSelectionCursor[gActiveBank] ^ 2) < gNumberOfMovesToChoose)
+    {
+        MoveSelectionDestroyCursorAt(gMoveSelectionCursor[gActiveBank]);
+        gMoveSelectionCursor[gActiveBank] ^= 2;
+        PlaySE(SE_SELECT);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+    }
+
+    return var;
+}
+
+void HandleMoveSwitchting(void)
+{
+    u8 perMovePPBonuses[4];
+    struct ChooseMoveStruct moveStruct;
+    u8 totalPPBonuses;
+
+    if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON))
+    {
+        PlaySE(SE_SELECT);
+
+        if (gMoveSelectionCursor[gActiveBank] != gMultiUsePlayerCursor)
+        {
+            struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+            s32 i;
+
+            // swap moves and pp
+            i = moveInfo->moves[gMoveSelectionCursor[gActiveBank]];
+            moveInfo->moves[gMoveSelectionCursor[gActiveBank]] = moveInfo->moves[gMultiUsePlayerCursor];
+            moveInfo->moves[gMultiUsePlayerCursor] = i;
+
+            i = moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]];
+            moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]] = moveInfo->currentPp[gMultiUsePlayerCursor];
+            moveInfo->currentPp[gMultiUsePlayerCursor] = i;
+
+            i = moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]];
+            moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]] = moveInfo->maxPp[gMultiUsePlayerCursor];
+            moveInfo->maxPp[gMultiUsePlayerCursor] = i;
+
+            if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]])
+            {
+                gDisableStructs[gActiveBank].unk18_b &= (~gBitTable[gMoveSelectionCursor[gActiveBank]]);
+                gDisableStructs[gActiveBank].unk18_b |= gBitTable[gMultiUsePlayerCursor];
+            }
+
+            MoveSelectionDisplayMoveNames();
+
+            for (i = 0; i < 4; i++)
+                perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2);
+
+            totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]];
+            perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gMultiUsePlayerCursor];
+            perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses;
+
+            totalPPBonuses = 0;
+            for (i = 0; i < 4; i++)
+                totalPPBonuses |= perMovePPBonuses[i] << (i * 2);
+
+            gBattleMons[gActiveBank].ppBonuses = totalPPBonuses;
+
+            for (i = 0; i < 4; i++)
+            {
+                gBattleMons[gActiveBank].moves[i] = moveInfo->moves[i];
+                gBattleMons[gActiveBank].pp[i] = moveInfo->currentPp[i];
+            }
+
+            if (!(gBattleMons[gActiveBank].status2 & STATUS2_TRANSFORMED))
+            {
+                for (i = 0; i < 4; i++)
+                {
+                    moveStruct.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i);
+                    moveStruct.currentPp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i);
+                }
+
+                totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES);
+                for (i = 0; i < 4; i++)
+                    perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2);
+
+                i = moveStruct.moves[gMoveSelectionCursor[gActiveBank]];
+                moveStruct.moves[gMoveSelectionCursor[gActiveBank]] = moveStruct.moves[gMultiUsePlayerCursor];
+                moveStruct.moves[gMultiUsePlayerCursor] = i;
+
+                i = moveStruct.currentPp[gMoveSelectionCursor[gActiveBank]];
+                moveStruct.currentPp[gMoveSelectionCursor[gActiveBank]] = moveStruct.currentPp[gMultiUsePlayerCursor];
+                moveStruct.currentPp[gMultiUsePlayerCursor] = i;
+
+                totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]];
+                perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gMultiUsePlayerCursor];
+                perMovePPBonuses[gMultiUsePlayerCursor] = totalPPBonuses;
+
+                totalPPBonuses = 0;
+                for (i = 0; i < 4; i++)
+                    totalPPBonuses |= perMovePPBonuses[i] << (i * 2);
+
+                for (i = 0; i < 4; i++)
+                {
+                    SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, &moveStruct.moves[i]);
+                    SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &moveStruct.currentPp[i]);
+                }
+
+                SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses);
+            }
+        }
+
+        gBattleBankFunc[gActiveBank] = HandleInputChooseMove;
+        gMoveSelectionCursor[gActiveBank] = gMultiUsePlayerCursor;
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+        MoveSelectionDisplayPpString();
+        MoveSelectionDisplayPpNumber();
+        MoveSelectionDisplayMoveType();
+    }
+    else if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON))
+    {
+        PlaySE(SE_SELECT);
+        MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
+        MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 0);
+        gBattleBankFunc[gActiveBank] = HandleInputChooseMove;
+        MoveSelectionDisplayPpString();
+        MoveSelectionDisplayPpNumber();
+        MoveSelectionDisplayMoveType();
+    }
+    else if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (gMultiUsePlayerCursor & 1)
+        {
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29);
+            else
+                MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
+
+            gMultiUsePlayerCursor ^= 1;
+            PlaySE(SE_SELECT);
+
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
+            else
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
+        }
+    }
+    else if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (!(gMultiUsePlayerCursor & 1) && (gMultiUsePlayerCursor ^ 1) < gNumberOfMovesToChoose)
+        {
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29);
+            else
+                MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
+
+            gMultiUsePlayerCursor ^= 1;
+            PlaySE(SE_SELECT);
+
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
+            else
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
+        }
+    }
+    else if (gMain.newKeys & DPAD_UP)
+    {
+        if (gMultiUsePlayerCursor & 2)
+        {
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29);
+            else
+                MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
+
+            gMultiUsePlayerCursor ^= 2;
+            PlaySE(SE_SELECT);
+
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
+            else
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
+        }
+    }
+    else if (gMain.newKeys & DPAD_DOWN)
+    {
+        if (!(gMultiUsePlayerCursor & 2) && (gMultiUsePlayerCursor ^ 2) < gNumberOfMovesToChoose)
+        {
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMoveSelectionCursor[gActiveBank], 29);
+            else
+                MoveSelectionDestroyCursorAt(gMultiUsePlayerCursor);
+
+            gMultiUsePlayerCursor ^= 2;
+            PlaySE(SE_SELECT);
+
+            if (gMultiUsePlayerCursor == gMoveSelectionCursor[gActiveBank])
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 0);
+            else
+                MoveSelectionCreateCursorAt(gMultiUsePlayerCursor, 27);
+        }
+    }
+}
+
+extern u8 gBattleOutcome;
+extern void sub_817E3F4(void); // battle_link_817C95C
+
+void sub_80586F8(void)
+{
+    if (gLinkVSyncDisabled == 0)
+    {
+        if (gReceivedRemoteLinkPlayers == 0)
+        {
+            m4aSongNumStop(SE_HINSI);
+            gMain.inBattle = 0;
+            gMain.callback1 = gPreBattleCallback1;
+            SetMainCallback2(sub_8038D64);
+            if (gBattleOutcome == BATTLE_WON)
+                sub_817E3F4();
+            FreeAllWindowBuffers();
+        }
+    }
+    else
+    {
+        if (sub_800A520())
+        {
+            m4aSongNumStop(SE_HINSI);
+            gMain.inBattle = 0;
+            gMain.callback1 = gPreBattleCallback1;
+            SetMainCallback2(sub_8038D64);
+            if (gBattleOutcome == BATTLE_WON)
+                sub_817E3F4();
+            FreeAllWindowBuffers();
+        }
+    }
+}
+
+void sub_80587B0(void)
+{
+    if (!gPaletteFade.active)
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        {
+            if (sub_800A520())
+            {
+                if (gLinkVSyncDisabled == 0)
+                    sub_800AC34();
+                else
+                    sub_800ADF8();
+
+                gBattleBankFunc[gActiveBank] = sub_80586F8;
+            }
+        }
+        else
+        {
+            m4aSongNumStop(SE_HINSI);
+            gMain.inBattle = 0;
+            gMain.callback1 = gPreBattleCallback1;
+            SetMainCallback2(gMain.savedCallback);
+        }
+    }
+}
+
+void CompleteOnBankSpriteCallbackDummy(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+        PlayerBufferExecCompleted();
+}
+
+void CompleteOnBankSpriteCallbackDummy2(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+        PlayerBufferExecCompleted();
+}
+
+void sub_80588B4(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+    {
+        nullsub_25(gSaveBlock2Ptr->playerGender);
+        FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]);
+        DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void sub_8058924(void)
+{
+    if (--gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 == 0xFF)
+    {
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 0;
+        PlayerBufferExecCompleted();
+    }
+}
+
+extern u8 gHealthBoxesIds[BATTLE_BANKS_COUNT];
+
+extern bool8 IsDoubleBattle(void);
+
+void sub_805896C(void)
+{
+    bool8 var = FALSE;
+
+    if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI)))
+    {
+        if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy)
+            var = TRUE;
+    }
+    else
+    {
+        if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy
+         && gSprites[gHealthBoxesIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy)
+            var = TRUE;
+    }
+
+    if (var && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1
+        && gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1)
+    {
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x1 = 0;
+        FreeSpriteTilesByTag(0x27F9);
+        FreeSpritePaletteByTag(0x27F9);
+
+        sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank);
+
+        if (IsDoubleBattle())
+            sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], gActiveBank ^ BIT_MON);
+
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_9 = 3;
+        gBattleBankFunc[gActiveBank] = sub_8058924;
+    }
+}
+
+extern void sub_8172EF0(u8 bank, struct Pokemon *mon);
+extern void sub_8076918(u8 bank);
+extern u8 gUnknown_03005D7C[];
+
+void sub_8058B40(void)
+{
+    bool32 r9 = FALSE;
+    bool32 r8 = FALSE;
+
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8)
+        sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]);
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x80 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8)
+        sub_8172EF0(gActiveBank ^ BIT_MON, &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]]);
+
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8 && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].flag_x8)
+    {
+        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80)
+        {
+            if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+            {
+                UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank ^ BIT_MON], &gPlayerParty[gBattlePartyID[gActiveBank ^ BIT_MON]], HEALTHBOX_ALL);
+                sub_8076918(gActiveBank ^ BIT_MON);
+                SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank ^ BIT_MON]);
+            }
+            UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL);
+            sub_8076918(gActiveBank);
+            SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]);
+        }
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 1;
+    }
+
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x40
+        && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80
+        && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank ^ BIT_MON].field_1_x40
+        && !IsCryPlayingOrClearCrySongs())
+    {
+        if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20)
+        {
+            if (gBattleTypeFlags & BATTLE_TYPE_MULTI && gBattleTypeFlags & BATTLE_TYPE_LINK)
+                m4aMPlayContinue(&gMPlay_BGM);
+            else
+                m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100);
+        }
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 1;
+        r9 = TRUE;
+    }
+
+    if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI)))
+    {
+        if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy
+            && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+        {
+            r8 = TRUE;
+        }
+    }
+    else
+    {
+        if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy
+            && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy
+            && gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy
+            && gSprites[gBankSpriteIds[gActiveBank ^ BIT_MON]].callback == SpriteCallbackDummy)
+        {
+            r8 = TRUE;
+        }
+    }
+
+    if (r9 && r8)
+    {
+        if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+            DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank ^ BIT_MON]]);
+        DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]);
+
+        gBattleSpritesDataPtr->animationData->field_9_x1 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x20 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x80 = 0;
+
+        gBattleBankFunc[gActiveBank] = sub_805896C;
+    }
+}
+
+extern void sub_805E408(u8 bank);
+extern void move_anim_start_t4(u8 arg0, u8 atkBank, u8 defBank, u8 tableId);
+
+void sub_8058EDC(void)
+{
+    if (gSprites[gHealthBoxesIds[gActiveBank]].callback == SpriteCallbackDummy
+     && gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1
+     && gSprites[gBankSpriteIds[gActiveBank]].callback == SpriteCallbackDummy)
+    {
+        sub_805E408(gActiveBank);
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80 = 0;
+        gBattleSpritesDataPtr->healthBoxesData[gActiveBank].field_1_x1 = 0;
+        FreeSpriteTilesByTag(0x27F9);
+        FreeSpritePaletteByTag(0x27F9);
+
+        if (gBattleSpritesDataPtr->bankData[gActiveBank].behindSubstitute)
+            move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6);
+
+        gBattleBankFunc[gActiveBank] = sub_8058FC0;
+    }
+}
+
+void sub_8058FC0(void)
+{
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40
+        && !IsCryPlayingOrClearCrySongs())
+    {
+        m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100);
+        sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void sub_805902C(void)
+{
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x80
+        && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8)
+    {
+        sub_8172EF0(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]);
+    }
+
+    if (gSprites[gUnknown_03005D7C[gActiveBank]].callback == SpriteCallbackDummy
+     && !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x8)
+    {
+        DestroySprite(&gSprites[gUnknown_03005D7C[gActiveBank]]);
+        UpdateHealthboxAttribute(gHealthBoxesIds[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], HEALTHBOX_ALL);
+        sub_8076918(gActiveBank);
+        SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]);
+        gBattleBankFunc[gActiveBank] = sub_8058EDC;
+    }
+}
+
+void c3_0802FDF4(u8 taskId)
+{
+    if (!IsCryPlayingOrClearCrySongs())
+    {
+        m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100);
+        DestroyTask(taskId);
+    }
+}
+
+void bx_t1_healthbar_update(void)
+{
+    s16 hpValue = sub_8074AA0(gActiveBank, gHealthBoxesIds[gActiveBank], 0, 0);
+
+    SetHealthboxSpriteVisible(gHealthBoxesIds[gActiveBank]);
+
+    if (hpValue != -1)
+    {
+        UpdateHpTextInHealthbox(gHealthBoxesIds[gActiveBank], hpValue, HP_CURRENT);
+    }
+    else
+    {
+        sub_805E990(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void CompleteOnInactiveTextPrinter(void)
+{
+    if (!IsTextPrinterActive(0))
+        PlayerBufferExecCompleted();
+}
+
+void sub_80591B8(u8 taskId)
+{
+    u32 monId = (u8)(gTasks[taskId].data[0]);
+    u8 bank = gTasks[taskId].data[2];
+    s16 gainedExp = gTasks[taskId].data[1];
+
+    if (IsDoubleBattle() == TRUE || monId != gBattlePartyID[bank])
+    {
+        struct Pokemon *mon = &gPlayerParty[monId];
+        u16 species = GetMonData(mon, MON_DATA_SPECIES);
+        u8 level = GetMonData(mon, MON_DATA_LEVEL);
+        u32 currExp = GetMonData(mon, MON_DATA_EXP);
+        u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1];
+
+        if (currExp + gainedExp >= nextLvlExp)
+        {
+            u8 savedActiveBank;
+
+            SetMonData(mon, MON_DATA_EXP, &nextLvlExp);
+            CalculateMonStats(mon);
+            gainedExp -= nextLvlExp - currExp;
+            savedActiveBank = gActiveBank;
+            gActiveBank = bank;
+            EmitCmd33(1, 11, gainedExp);
+            gActiveBank = savedActiveBank;
+
+            if (IsDoubleBattle() == TRUE
+             && ((u16)(monId) == gBattlePartyID[bank] || (u16)(monId) == gBattlePartyID[bank ^ BIT_MON]))
+                gTasks[taskId].func = sub_8059544;
+            else
+                gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
+        }
+        else
+        {
+            currExp += gainedExp;
+            SetMonData(mon, MON_DATA_EXP, &currExp);
+            gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter;
+            DestroyTask(taskId);
+        }
+    }
+    else
+    {
+        gTasks[taskId].func = sub_8059330;
+    }
+}
+
+void sub_8059330(u8 taskId)
+{
+    u8 monIndex = gTasks[taskId].data[0];
+    s32 gainedExp = gTasks[taskId].data[1];
+    u8 bank = gTasks[taskId].data[2];
+    struct Pokemon *mon = &gPlayerParty[monIndex];
+    u8 level = GetMonData(mon, MON_DATA_LEVEL);
+    u16 species = GetMonData(mon, MON_DATA_SPECIES);
+    u32 exp = GetMonData(mon, MON_DATA_EXP);
+    u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level];
+    u32 expToNextLvl;
+
+    exp -= currLvlExp;
+    expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp;
+    SetBattleBarStruct(bank, gHealthBoxesIds[bank], expToNextLvl, exp, -gainedExp);
+    PlaySE(SE_EXP);
+    gTasks[taskId].func = sub_8059400;
+}
+
+void sub_8059400(u8 taskId)
+{
+    if (gTasks[taskId].data[10] < 13)
+    {
+        gTasks[taskId].data[10]++;
+    }
+    else
+    {
+        u8 monId = gTasks[taskId].data[0];
+        s16 gainedExp = gTasks[taskId].data[1];
+        u8 bank = gTasks[taskId].data[2];
+        s16 r4;
+
+        r4 = sub_8074AA0(bank, gHealthBoxesIds[bank], 1, 0);
+        SetHealthboxSpriteVisible(gHealthBoxesIds[bank]);
+        if (r4 == -1)
+        {
+            u8 level;
+            s32 currExp;
+            u16 species;
+            s32 expOnNextLvl;
+
+            m4aSongNumStop(SE_EXP);
+            level = GetMonData(&gPlayerParty[monId], MON_DATA_LEVEL);
+            currExp = GetMonData(&gPlayerParty[monId], MON_DATA_EXP);
+            species = GetMonData(&gPlayerParty[monId], MON_DATA_SPECIES);
+            expOnNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1];
+
+            if (currExp + gainedExp >= expOnNextLvl)
+            {
+                u8 savedActiveBank;
+
+                SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &expOnNextLvl);
+                CalculateMonStats(&gPlayerParty[monId]);
+                gainedExp -= expOnNextLvl - currExp;
+                savedActiveBank = gActiveBank;
+                gActiveBank = bank;
+                EmitCmd33(1, 11, gainedExp);
+                gActiveBank = savedActiveBank;
+                gTasks[taskId].func = sub_8059544;
+            }
+            else
+            {
+                currExp += gainedExp;
+                SetMonData(&gPlayerParty[monId], MON_DATA_EXP, &currExp);
+                gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter;
+                DestroyTask(taskId);
+            }
+        }
+    }
+}
+
+void sub_8059544(u8 taskId)
+{
+    u8 bank = gTasks[taskId].data[2];
+    u8 monIndex = gTasks[taskId].data[0];
+
+    if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON])
+        bank ^= BIT_MON;
+
+    move_anim_start_t4(bank, bank, bank, 0);
+    gTasks[taskId].func = sub_80595A4;
+}
+
+void sub_80595A4(u8 taskId)
+{
+    u8 bank = gTasks[taskId].data[2];
+
+    if (!gBattleSpritesDataPtr->healthBoxesData[bank].flag_x40)
+    {
+        u8 monIndex = gTasks[taskId].data[0];
+
+        GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL);  // Unused return value
+
+        if (IsDoubleBattle() == TRUE && monIndex == gBattlePartyID[bank ^ BIT_MON])
+            UpdateHealthboxAttribute(gHealthBoxesIds[bank ^ BIT_MON], &gPlayerParty[monIndex], HEALTHBOX_ALL);
+        else
+            UpdateHealthboxAttribute(gHealthBoxesIds[bank], &gPlayerParty[monIndex], HEALTHBOX_ALL);
+
+        gTasks[taskId].func = DestroyExpTaskAndCompleteOnInactiveTextPrinter;
+    }
+}
+
+void DestroyExpTaskAndCompleteOnInactiveTextPrinter(u8 taskId)
+{
+    u8 monIndex;
+    u8 bank;
+
+    monIndex = gTasks[taskId].data[0];
+    GetMonData(&gPlayerParty[monIndex], MON_DATA_LEVEL);  // Unused return value
+    bank = gTasks[taskId].data[2];
+    gBattleBankFunc[bank] = CompleteOnInactiveTextPrinter;
+    DestroyTask(taskId);
+}
+
+void sub_80596A8(void)
+{
+    if (gSprites[gBankSpriteIds[gActiveBank]].pos1.y + gSprites[gBankSpriteIds[gActiveBank]].pos2.y > DISPLAY_HEIGHT)
+    {
+        u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES);
+
+        nullsub_24(species);
+        FreeOamMatrix(gSprites[gBankSpriteIds[gActiveBank]].oam.matrixNum);
+        DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]);
+        SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void sub_8059744(void)
+{
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40)
+    {
+        FreeSpriteOamMatrix(&gSprites[gBankSpriteIds[gActiveBank]]);
+        DestroySprite(&gSprites[gBankSpriteIds[gActiveBank]]);
+        SetHealthboxSpriteInvisible(gHealthBoxesIds[gActiveBank]);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void CompleteOnInactiveTextPrinter2(void)
+{
+    if (!IsTextPrinterActive(0))
+        PlayerBufferExecCompleted();
+}
+
+extern void sub_81B89AC(u8 arg0);
+
+void sub_80597CC(void)
+{
+    if (!gPaletteFade.active)
+    {
+        u8 r4;
+
+        gBattleBankFunc[gActiveBank] = sub_8059828;
+        r4 = gTasks[gUnknown_03005D7C[gActiveBank]].data[0];
+        DestroyTask(gUnknown_03005D7C[gActiveBank]);
+        FreeAllWindowBuffers();
+        sub_81B89AC(r4);
+    }
+}
+
+extern u8 gUnknown_0203CEE8;
+extern u8 gUnknown_0203CEE9;
+extern u8 gUnknown_0203CF00[];
+
+void sub_8059828(void)
+{
+    if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
+    {
+        if (gUnknown_0203CEE8 == 1)
+            EmitCmd34(1, gUnknown_0203CEE9, gUnknown_0203CF00);
+        else
+            EmitCmd34(1, 6, NULL);
+
+        if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1)
+            PrintLinkStandbyMsg();
+
+        PlayerBufferExecCompleted();
+    }
+}
+
+extern void sub_81AABB0(void);
+extern void nullsub_35(void);
+
+void sub_80598A4(void)
+{
+    if (!gPaletteFade.active)
+    {
+        gBattleBankFunc[gActiveBank] = sub_80598E0;
+        nullsub_35();
+        FreeAllWindowBuffers();
+        sub_81AABB0();
+    }
+}
+
+extern u16 gScriptItemId;
+
+void sub_80598E0(void)
+{
+    if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
+    {
+        EmitCmd35(1, gScriptItemId);
+        PlayerBufferExecCompleted();
+    }
+}
+
+void sub_805991C(void)
+{
+    if (!gDoingBattleAnim || !gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x40)
+        PlayerBufferExecCompleted();
+}
+
+void DoHitAnimBlinkEffect(void)
+{
+    u8 spriteId = gBankSpriteIds[gActiveBank];
+
+    if (gSprites[spriteId].data1 == 32)
+    {
+        gSprites[spriteId].data1 = 0;
+        gSprites[spriteId].invisible = 0;
+        gDoingBattleAnim = FALSE;
+        PlayerBufferExecCompleted();
+    }
+    else
+    {
+        if ((gSprites[spriteId].data1 % 4) == 0)
+            gSprites[spriteId].invisible ^= 1;
+        gSprites[spriteId].data1++;
+    }
+}
+
+void sub_80599D4(void)
+{
+    if (gMain.newKeys & DPAD_UP && gMultiUsePlayerCursor != 0)
+    {
+        PlaySE(SE_SELECT);
+        BattleDestroyYesNoCursorAt(gMultiUsePlayerCursor);
+        gMultiUsePlayerCursor = 0;
+        BattleCreateYesNoCursorAt(0);
+    }
+    if (gMain.newKeys & DPAD_DOWN && gMultiUsePlayerCursor == 0)
+    {
+        PlaySE(SE_SELECT);
+        BattleDestroyYesNoCursorAt(gMultiUsePlayerCursor);
+        gMultiUsePlayerCursor = 1;
+        BattleCreateYesNoCursorAt(1);
+    }
+    if (gMain.newKeys & A_BUTTON)
+    {
+        sub_8056A3C(0x18, 8, 0x1D, 0xD, 1);
+        PlaySE(SE_SELECT);
+
+        if (gMultiUsePlayerCursor != 0)
+            EmitCmd33(1, 0xE, 0);
+        else
+            EmitCmd33(1, 0xD, 0);
+
+        PlayerBufferExecCompleted();
+    }
+    if (gMain.newKeys & B_BUTTON)
+    {
+        sub_8056A3C(0x18, 8, 0x1D, 0xD, 1);
+        PlaySE(SE_SELECT);
+        PlayerBufferExecCompleted();
+    }
+}
+
+extern const u8 gText_MoveInterfacePP[];
+extern const u8 gText_MoveInterfaceType[];
+
+void MoveSelectionDisplayMoveNames(void)
+{
+    s32 i;
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+    gNumberOfMovesToChoose = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        MoveSelectionDestroyCursorAt(i);
+        StringCopy(gDisplayedStringBattle, gMoveNames[moveInfo->moves[i]]);
+        sub_814F9EC(gDisplayedStringBattle, i + 3);
+        if (moveInfo->moves[i] != MOVE_NONE)
+            gNumberOfMovesToChoose++;
+    }
+}
+
+void MoveSelectionDisplayPpString(void)
+{
+    StringCopy(gDisplayedStringBattle, gText_MoveInterfacePP);
+    sub_814F9EC(gDisplayedStringBattle, 7);
+}
+
+void MoveSelectionDisplayPpNumber(void)
+{
+    u8 *txtPtr;
+    struct ChooseMoveStruct *moveInfo;
+
+    if (gBattleBufferA[gActiveBank][2] == TRUE) // check if we didn't want to display pp number
+        return;
+
+    SetPpNumbersPaletteInMoveSelection();
+    moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+    txtPtr = ConvertIntToDecimalStringN(gDisplayedStringBattle, moveInfo->currentPp[gMoveSelectionCursor[gActiveBank]], STR_CONV_MODE_RIGHT_ALIGN, 2);
+    txtPtr[0] = CHAR_SLASH;
+    txtPtr++;
+    ConvertIntToDecimalStringN(txtPtr, moveInfo->maxPp[gMoveSelectionCursor[gActiveBank]], STR_CONV_MODE_RIGHT_ALIGN, 2);
+
+    sub_814F9EC(gDisplayedStringBattle, 9);
+}
+
+extern const u8 gTypeNames[][7];
+
+void MoveSelectionDisplayMoveType(void)
+{
+    u8 *txtPtr;
+    struct ChooseMoveStruct *moveInfo = (struct ChooseMoveStruct*)(&gBattleBufferA[gActiveBank][4]);
+
+    txtPtr = StringCopy(gDisplayedStringBattle, gText_MoveInterfaceType);
+    txtPtr[0] = EXT_CTRL_CODE_BEGIN;
+    txtPtr++;
+    txtPtr[0] = 6;
+    txtPtr++;
+    txtPtr[0] = 1;
+    txtPtr++;
+
+    StringCopy(txtPtr, gTypeNames[gBattleMoves[moveInfo->moves[gMoveSelectionCursor[gActiveBank]]].type]);
+    sub_814F9EC(gDisplayedStringBattle, 10);
+}
+
+void MoveSelectionCreateCursorAt(u8 cursorPosition, u8 arg1)
+{
+    u16 src[2];
+    src[0] = arg1 + 1;
+    src[1] = arg1 + 2;
+
+    CopyToBgTilemapBufferRect_ChangePalette(0, src, 9 * (cursorPosition & 1) + 1, 55 + (cursorPosition & 2), 1, 2, 0x11);
+    CopyBgTilemapBufferToVram(0);
+}
+
+void MoveSelectionDestroyCursorAt(u8 cursorPosition)
+{
+    u16 src[2];
+    src[0] = 0x1016;
+    src[1] = 0x1016;
+
+    CopyToBgTilemapBufferRect_ChangePalette(0, src, 9 * (cursorPosition & 1) + 1, 55 + (cursorPosition & 2), 1, 2, 0x11);
+    CopyBgTilemapBufferToVram(0);
+}
+
+void ActionSelectionCreateCursorAt(u8 cursorPosition, u8 arg1)
+{
+    u16 src[2];
+    src[0] = 1;
+    src[1] = 2;
+
+    CopyToBgTilemapBufferRect_ChangePalette(0, src, 7 * (cursorPosition & 1) + 16, 35 + (cursorPosition & 2), 1, 2, 0x11);
+    CopyBgTilemapBufferToVram(0);
+}
+
+void ActionSelectionDestroyCursorAt(u8 cursorPosition)
+{
+    u16 src[2];
+    src[0] = 0x1016;
+    src[1] = 0x1016;
+
+    CopyToBgTilemapBufferRect_ChangePalette(0, src, 7 * (cursorPosition & 1) + 16, 35 + (cursorPosition & 2), 1, 2, 0x11);
+    CopyBgTilemapBufferToVram(0);
+}
+
+void SetCB2ToReshowScreenAfterMenu(void)
+{
+    SetMainCallback2(ReshowBattleScreenAfterMenu);
+}
+
+void SetCB2ToReshowScreenAfterMenu2(void)
+{
+    SetMainCallback2(ReshowBattleScreenAfterMenu);
+}
+
+void sub_8059D60(void)
+{
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x10)
+        PlayerBufferExecCompleted();
+}
+
+void sub_8059D90(void)
+{
+    if (!gBattleSpritesDataPtr->healthBoxesData[gActiveBank].flag_x20)
+        PlayerBufferExecCompleted();
+}
+
+extern const u8 gText_LinkStandby[];
+
+void PrintLinkStandbyMsg(void)
+{
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        gBattle_BG0_X = 0;
+        gBattle_BG0_Y = 0;
+        sub_814F9EC(gText_LinkStandby, 0);
+    }
+}
diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c
new file mode 100644
index 000000000..e7594a2f0
--- /dev/null
+++ b/src/battle_controller_wally.c
@@ -0,0 +1,147 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "battle_interface.h"
+#include "battle_anim.h"
+#include "link.h"
+
+extern u8 gActiveBank;
+extern bool8 gDoingBattleAnim;
+extern u8 gUnknown_020244CC;
+extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
+
+// this file's functions
+void WallyHandleGetMonData(void);
+void WallyHandleGetRawMonData(void);
+void WallyHandleSetMonData(void);
+void WallyHandleSetRawMonData(void);
+void WallyHandleLoadMonSprite(void);
+void WallyHandleSwitchInAnim(void);
+void WallyHandleReturnMonToBall(void);
+void WallyHandleDrawTrainerPic(void);
+void WallyHandleTrainerSlide(void);
+void WallyHandleTrainerSlideBack(void);
+void WallyHandleFaintAnimation(void);
+void WallyHandleCmd11(void);
+void WallyHandleCmd12(void);
+void WallyHandleBallThrow(void);
+void WallyHandlePause(void);
+void WallyHandleMoveAnimation(void);
+void WallyHandlePrintString(void);
+void WallyHandlePrintStringPlayerOnly(void);
+void WallyHandleChooseAction(void);
+void WallyHandleCmd19(void);
+void WallyHandleChooseMove(void);
+void WallyHandleOpenBag(void);
+void WallyHandleChoosePokemon(void);
+void WallyHandleCmd23(void);
+void WallyHandleHealthBarUpdate(void);
+void WallyHandleExpUpdate(void);
+void WallyHandleStatusIconUpdate(void);
+void WallyHandleStatusAnimation(void);
+void WallyHandleStatusXor(void);
+void WallyHandleDataTransfer(void);
+void WallyHandleDMA3Transfer(void);
+void WallyHandlePlayBGM(void);
+void WallyHandleCmd32(void);
+void WallyHandleCmd33(void);
+void WallyHandleCmd34(void);
+void WallyHandleCmd35(void);
+void WallyHandleCmd36(void);
+void WallyHandleCmd37(void);
+void WallyHandleCmd38(void);
+void WallyHandleCmd39(void);
+void WallyHandleCmd40(void);
+void WallyHandleHitAnimation(void);
+void WallyHandleCmd42(void);
+void WallyHandleEffectivenessSound(void);
+void WallyHandlePlayFanfareOrBGM(void);
+void WallyHandleFaintingCry(void);
+void WallyHandleIntroSlide(void);
+void WallyHandleIntroTrainerBallThrow(void);
+void WallyHandleDrawPartyStatusSummary(void);
+void WallyHandleCmd49(void);
+void WallyHandleCmd50(void);
+void WallyHandleSpriteInvisibility(void);
+void WallyHandleBattleAnimation(void);
+void WallyHandleLinkStandbyMsg(void);
+void WallyHandleResetActionMoveSelection(void);
+void WallyHandleCmd55(void);
+void nullsub_118(void);
+
+void WallyBufferRunCommand(void);
+
+void (*const gWallyBufferCommands[CONTOLLER_CMDS_CONT])(void) =
+{
+    WallyHandleGetMonData,
+    WallyHandleGetRawMonData,
+    WallyHandleSetMonData,
+    WallyHandleSetRawMonData,
+    WallyHandleLoadMonSprite,
+    WallyHandleSwitchInAnim,
+    WallyHandleReturnMonToBall,
+    WallyHandleDrawTrainerPic,
+    WallyHandleTrainerSlide,
+    WallyHandleTrainerSlideBack,
+    WallyHandleFaintAnimation,
+    WallyHandleCmd11,
+    WallyHandleCmd12,
+    WallyHandleBallThrow,
+    WallyHandlePause,
+    WallyHandleMoveAnimation,
+    WallyHandlePrintString,
+    WallyHandlePrintStringPlayerOnly,
+    WallyHandleChooseAction,
+    WallyHandleCmd19,
+    WallyHandleChooseMove,
+    WallyHandleOpenBag,
+    WallyHandleChoosePokemon,
+    WallyHandleCmd23,
+    WallyHandleHealthBarUpdate,
+    WallyHandleExpUpdate,
+    WallyHandleStatusIconUpdate,
+    WallyHandleStatusAnimation,
+    WallyHandleStatusXor,
+    WallyHandleDataTransfer,
+    WallyHandleDMA3Transfer,
+    WallyHandlePlayBGM,
+    WallyHandleCmd32,
+    WallyHandleCmd33,
+    WallyHandleCmd34,
+    WallyHandleCmd35,
+    WallyHandleCmd36,
+    WallyHandleCmd37,
+    WallyHandleCmd38,
+    WallyHandleCmd39,
+    WallyHandleCmd40,
+    WallyHandleHitAnimation,
+    WallyHandleCmd42,
+    WallyHandleEffectivenessSound,
+    WallyHandlePlayFanfareOrBGM,
+    WallyHandleFaintingCry,
+    WallyHandleIntroSlide,
+    WallyHandleIntroTrainerBallThrow,
+    WallyHandleDrawPartyStatusSummary,
+    WallyHandleCmd49,
+    WallyHandleCmd50,
+    WallyHandleSpriteInvisibility,
+    WallyHandleBattleAnimation,
+    WallyHandleLinkStandbyMsg,
+    WallyHandleResetActionMoveSelection,
+    WallyHandleCmd55,
+    nullsub_118
+};
+
+void nullsub_117(void)
+{
+}
+
+void SetBankFuncToWallyBufferRunCommand(void)
+{
+    gBattleBankFunc[gActiveBank] = WallyBufferRunCommand;
+    gBattleStruct->field_94 = 0;
+    gBattleStruct->field_95 = 0;
+    gBattleStruct->field_96 = 0;
+    gBattleStruct->field_97 = 0;
+}
diff --git a/src/battle_interface.c b/src/battle_interface.c
index 9241db1d9..2318517f5 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -27,12 +27,6 @@ enum
     EXP_BAR
 };
 
-enum
-{
-    HP_CURRENT,
-    HP_MAX
-};
-
 struct TestingBar
 {
     s32 maxValue;
diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c
index a1e5767ad..4ba86775e 100644
--- a/src/battle_script_commands.c
+++ b/src/battle_script_commands.c
@@ -6118,22 +6118,22 @@ static void atk5A_yesnoboxlearnmove(void)
         sub_814F9EC(gText_BattleYesNoChoice, 0xC);
         gBattleScripting.learnMoveState++;
         gBattleCommunication[CURSOR_POSITION] = 0;
-        BattleCreateCursorAt(0);
+        BattleCreateYesNoCursorAt(0);
         break;
     case 1:
         if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 0;
-            BattleCreateCursorAt(0);
+            BattleCreateYesNoCursorAt(0);
         }
         if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 1;
-            BattleCreateCursorAt(1);
+            BattleCreateYesNoCursorAt(1);
         }
         if (gMain.newKeys & A_BUTTON)
         {
@@ -6235,22 +6235,22 @@ static void atk5B_yesnoboxstoplearningmove(void)
         sub_814F9EC(gText_BattleYesNoChoice, 0xC);
         gBattleScripting.learnMoveState++;
         gBattleCommunication[CURSOR_POSITION] = 0;
-        BattleCreateCursorAt(0);
+        BattleCreateYesNoCursorAt(0);
         break;
     case 1:
         if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 0;
-            BattleCreateCursorAt(0);
+            BattleCreateYesNoCursorAt(0);
         }
         if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 1;
-            BattleCreateCursorAt(1);
+            BattleCreateYesNoCursorAt(1);
         }
         if (gMain.newKeys & A_BUTTON)
         {
@@ -6531,22 +6531,22 @@ static void atk67_yesnobox(void)
         sub_814F9EC(gText_BattleYesNoChoice, 0xC);
         gBattleCommunication[0]++;
         gBattleCommunication[CURSOR_POSITION] = 0;
-        BattleCreateCursorAt(0);
+        BattleCreateYesNoCursorAt(0);
         break;
     case 1:
         if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 0;
-            BattleCreateCursorAt(0);
+            BattleCreateYesNoCursorAt(0);
         }
         if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 1;
-            BattleCreateCursorAt(1);
+            BattleCreateYesNoCursorAt(1);
         }
         if (gMain.newKeys & B_BUTTON)
         {
@@ -11286,7 +11286,7 @@ void sub_8056A3C(u8 xStart, u8 yStart, u8 xEnd, u8 yEnd, u8 flags)
     }
 }
 
-void BattleCreateCursorAt(u8 cursorPosition)
+void BattleCreateYesNoCursorAt(u8 cursorPosition)
 {
     u16 src[2];
     src[0] = 1;
@@ -11296,7 +11296,7 @@ void BattleCreateCursorAt(u8 cursorPosition)
     CopyBgTilemapBufferToVram(0);
 }
 
-void BattleDestroyCursorAt(u8 cursorPosition)
+void BattleDestroyYesNoCursorAt(u8 cursorPosition)
 {
     u16 src[2];
     src[0] = 0x1016;
@@ -11315,22 +11315,22 @@ static void atkF3_nickname_caught_poke(void)
         sub_814F9EC(gText_BattleYesNoChoice, 0xC);
         gBattleCommunication[MULTIUSE_STATE]++;
         gBattleCommunication[CURSOR_POSITION] = 0;
-        BattleCreateCursorAt(0);
+        BattleCreateYesNoCursorAt(0);
         break;
     case 1:
         if (gMain.newKeys & DPAD_UP && gBattleCommunication[CURSOR_POSITION] != 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 0;
-            BattleCreateCursorAt(0);
+            BattleCreateYesNoCursorAt(0);
         }
         if (gMain.newKeys & DPAD_DOWN && gBattleCommunication[CURSOR_POSITION] == 0)
         {
             PlaySE(SE_SELECT);
-            BattleDestroyCursorAt(gBattleCommunication[CURSOR_POSITION]);
+            BattleDestroyYesNoCursorAt(gBattleCommunication[CURSOR_POSITION]);
             gBattleCommunication[CURSOR_POSITION] = 1;
-            BattleCreateCursorAt(1);
+            BattleCreateYesNoCursorAt(1);
         }
         if (gMain.newKeys & A_BUTTON)
         {
diff --git a/src/pokemon_2.c b/src/pokemon_2.c
index 27441f952..972e1943a 100644
--- a/src/pokemon_2.c
+++ b/src/pokemon_2.c
@@ -84,7 +84,7 @@ bool8 ShouldGetStatBadgeBoost(u16 badgeFlag, u8 bank)
     return FALSE;
 }
 
-u8 sub_8069F34(u8 bank)
+u8 GetDefaultMoveTarget(u8 bank)
 {
     u8 status = GetBankIdentity(bank) & 1;