Merge branch 'master' of https://github.com/pret/pokeemerald into menu

1 files changed, 282 insertions, 282 deletions

diff --git a/src/battle_controllers.c b/src/battle_controllers.c
index c6d47e71e..4f523cfa0 100644
--- a/src/battle_controllers.c
+++ b/src/battle_controllers.c
@@ -13,36 +13,36 @@
 #include "battle_message.h"
 
 extern u32 gBattleTypeFlags;
-extern u32 gBattleExecBuffer;
+extern u32 gBattleControllerExecFlags;
 extern void (*gBattleMainFunc)(void);
-extern void (*gBattleBankFunc[BATTLE_BANKS_COUNT])(void);
-extern u8 gBanksByIdentity[BATTLE_BANKS_COUNT];
-extern u8 gActionSelectionCursor[BATTLE_BANKS_COUNT];
-extern u8 gMoveSelectionCursor[BATTLE_BANKS_COUNT];
-extern u8 gNoOfAllBanks;
-extern u8 gActiveBank;
+extern void (*gBattlerControllerFuncs[MAX_BATTLERS_COUNT])(void);
+extern u8 gBattlerPositions[MAX_BATTLERS_COUNT];
+extern u8 gActionSelectionCursor[MAX_BATTLERS_COUNT];
+extern u8 gMoveSelectionCursor[MAX_BATTLERS_COUNT];
+extern u8 gBattlersCount;
+extern u8 gActiveBattler;
 extern u8 gUnknown_0202428C;
 extern u32 gUnknown_02022FF4;
 extern u8 gUnknown_0203C7B4;
-extern u16 gBattlePartyID[BATTLE_BANKS_COUNT];
-extern u8 gBattleBufferA[BATTLE_BANKS_COUNT][0x200];
-extern u8 gBattleBufferB[BATTLE_BANKS_COUNT][0x200];
+extern u16 gBattlerPartyIndexes[MAX_BATTLERS_COUNT];
+extern u8 gBattleBufferA[MAX_BATTLERS_COUNT][0x200];
+extern u8 gBattleBufferB[MAX_BATTLERS_COUNT][0x200];
 extern u8 gBattleBuffersTransferData[0x100];
 extern u8 gUnknown_02022D08;
 extern u8 gUnknown_02022D09;
 extern u8 gUnknown_02022D0A;
-extern u8 gBankAttacker;
-extern u8 gBankTarget;
-extern u8 gAbsentBankFlags;
+extern u8 gBattlerAttacker;
+extern u8 gBattlerTarget;
+extern u8 gAbsentBattlerFlags;
 extern u8 gEffectBank;
 extern u16 gBattleWeather;
-extern struct BattlePokemon gBattleMons[BATTLE_BANKS_COUNT];
+extern struct BattlePokemon gBattleMons[MAX_BATTLERS_COUNT];
 extern u16 gCurrentMove;
 extern u16 gChosenMove;
 extern u16 gLastUsedItem;
 extern u8 gBattleOutcome;
 extern u8 gLastUsedAbility;
-extern u8 gStringBank;
+extern u8 gStringBattler;
 
 extern const struct BattleMove gBattleMoves[];
 
@@ -51,8 +51,8 @@ extern void sub_81B8D64(u8 bank, u8 arg1); // party_menu
 
 // this file's funcionts
 static void CreateTasksForSendRecvLinkBuffers(void);
-static void SetControllersVariablesInLinkBattle(void);
-static void SetControllersVariables(void);
+static void InitLinkBtlControllers(void);
+static void InitSinglePlayerBtlControllers(void);
 static void SetBattlePartyIds(void);
 static void Task_HandleSendLinkBuffersData(u8 taskId);
 static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId);
@@ -64,7 +64,7 @@ void HandleLinkBattleSetup(void)
         if (gLinkVSyncDisabled)
             sub_800B488();
         if (!gReceivedRemoteLinkPlayers)
-            sub_8009734();
+            OpenLink();
         CreateTask(task00_08081A90, 0);
         CreateTasksForSendRecvLinkBuffers();
     }
@@ -76,16 +76,16 @@ void SetUpBattleVarsAndBirchZigzagoon(void)
 
     gBattleMainFunc = nullsub_20;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
     {
-        gBattleBankFunc[i] = nullsub_21;
-        gBanksByIdentity[i] = 0xFF;
+        gBattlerControllerFuncs[i] = nullsub_21;
+        gBattlerPositions[i] = 0xFF;
         gActionSelectionCursor[i] = 0;
         gMoveSelectionCursor[i] = 0;
     }
 
     HandleLinkBattleSetup();
-    gBattleExecBuffer = 0;
+    gBattleControllerExecFlags = 0;
     ClearBattleAnimationVars();
     ClearBattleMonForms();
     BattleAI_HandleItemUseBeforeAISetup(0xF);
@@ -116,15 +116,15 @@ void sub_8032768(void)
         RecordedBattle_SaveParties();
 
     if (gBattleTypeFlags & BATTLE_TYPE_LINK)
-        SetControllersVariablesInLinkBattle();
+        InitLinkBtlControllers();
     else
-        SetControllersVariables();
+        InitSinglePlayerBtlControllers();
 
     SetBattlePartyIds();
 
     if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
     {
-        for (i = 0; i < gNoOfAllBanks; i++)
+        for (i = 0; i < gBattlersCount; i++)
             sub_81B8D64(i, 0);
     }
 
@@ -135,7 +135,7 @@ void sub_8032768(void)
         *(gBattleStruct->field_204 + i) = 0;
 }
 
-static void SetControllersVariables(void)
+static void InitSinglePlayerBtlControllers(void)
 {
     s32 i;
 
@@ -145,62 +145,62 @@ static void SetControllersVariables(void)
 
         if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
         {
-            gBattleBankFunc[0] = SetControllerToRecordedPlayer;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToRecordedPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[2] = SetControllerToPlayerPartner;
-            gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToPlayerPartner;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[3] = SetControllerToOpponent;
-            gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
         }
         else
         {
-            gBattleBankFunc[0] = SetControllerToPlayer;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[2] = SetControllerToPlayerPartner;
-            gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToPlayerPartner;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[3] = SetControllerToOpponent;
-            gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
         }
 
-        gNoOfAllBanks = 4;
+        gBattlersCount = 4;
 
         sub_81B8D64(0, 0);
         sub_81B8D64(1, 0);
         sub_81B8D64(2, 1);
         sub_81B8D64(3, 1);
 
-        gBattlePartyID[0] = 0;
-        gBattlePartyID[1] = 0;
-        gBattlePartyID[2] = 3;
-        gBattlePartyID[3] = 3;
+        gBattlerPartyIndexes[0] = 0;
+        gBattlerPartyIndexes[1] = 0;
+        gBattlerPartyIndexes[2] = 3;
+        gBattlerPartyIndexes[3] = 3;
     }
     else if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
     {
         gBattleMainFunc = BeginBattleIntro;
 
         if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
-            gBattleBankFunc[0] = SetControllerToSafari;
+            gBattlerControllerFuncs[0] = SetControllerToSafari;
         else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL)
-            gBattleBankFunc[0] = SetControllerToWally;
+            gBattlerControllerFuncs[0] = SetControllerToWally;
         else
-            gBattleBankFunc[0] = SetControllerToPlayer;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
 
-        gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+        gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-        gBattleBankFunc[1] = SetControllerToOpponent;
-        gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+        gBattlerControllerFuncs[1] = SetControllerToOpponent;
+        gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-        gNoOfAllBanks = 2;
+        gBattlersCount = 2;
 
         if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
         {
@@ -210,32 +210,32 @@ static void SetControllersVariables(void)
                 {
                     gBattleMainFunc = BeginBattleIntro;
 
-                    gBattleBankFunc[0] = SetControllerToRecordedPlayer;
-                    gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+                    gBattlerControllerFuncs[0] = SetControllerToRecordedPlayer;
+                    gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-                    gBattleBankFunc[1] = SetControllerToRecordedOpponent;
-                    gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+                    gBattlerControllerFuncs[1] = SetControllerToRecordedOpponent;
+                    gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-                    gNoOfAllBanks = 2;
+                    gBattlersCount = 2;
                 }
                 else // see how the banks are switched
                 {
-                    gBattleBankFunc[1] = SetControllerToRecordedPlayer;
-                    gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+                    gBattlerControllerFuncs[1] = SetControllerToRecordedPlayer;
+                    gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
 
-                    gBattleBankFunc[0] = SetControllerToRecordedOpponent;
-                    gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+                    gBattlerControllerFuncs[0] = SetControllerToRecordedOpponent;
+                    gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
 
-                    gNoOfAllBanks = 2;
+                    gBattlersCount = 2;
                 }
             }
             else
             {
-                gBattleBankFunc[0] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+                gBattlerControllerFuncs[0] = SetControllerToRecordedPlayer;
+                gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-                gBattleBankFunc[1] = SetControllerToOpponent;
-                gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+                gBattlerControllerFuncs[1] = SetControllerToOpponent;
+                gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
             }
         }
     }
@@ -243,19 +243,19 @@ static void SetControllersVariables(void)
     {
         gBattleMainFunc = BeginBattleIntro;
 
-        gBattleBankFunc[0] = SetControllerToPlayer;
-        gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+        gBattlerControllerFuncs[0] = SetControllerToPlayer;
+        gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-        gBattleBankFunc[1] = SetControllerToOpponent;
-        gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+        gBattlerControllerFuncs[1] = SetControllerToOpponent;
+        gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-        gBattleBankFunc[2] = SetControllerToPlayer;
-        gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+        gBattlerControllerFuncs[2] = SetControllerToPlayer;
+        gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-        gBattleBankFunc[3] = SetControllerToOpponent;
-        gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+        gBattlerControllerFuncs[3] = SetControllerToOpponent;
+        gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
 
-        gNoOfAllBanks = 4;
+        gBattlersCount = 4;
 
         if (gBattleTypeFlags & BATTLE_TYPE_RECORDED)
         {
@@ -263,35 +263,35 @@ static void SetControllersVariables(void)
             {
                 gBattleMainFunc = BeginBattleIntro;
 
-                gBattleBankFunc[0] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[0] = 0;
+                gBattlerControllerFuncs[0] = SetControllerToRecordedPlayer;
+                gBattlerPositions[0] = 0;
 
-                gBattleBankFunc[1] = SetControllerToOpponent;
-                gBanksByIdentity[1] = 1;
+                gBattlerControllerFuncs[1] = SetControllerToOpponent;
+                gBattlerPositions[1] = 1;
 
-                gBattleBankFunc[2] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[2] = 2;
+                gBattlerControllerFuncs[2] = SetControllerToRecordedPlayer;
+                gBattlerPositions[2] = 2;
 
-                gBattleBankFunc[3] = SetControllerToOpponent;
-                gBanksByIdentity[3] = 3;
+                gBattlerControllerFuncs[3] = SetControllerToOpponent;
+                gBattlerPositions[3] = 3;
 
-                gNoOfAllBanks = 4;
+                gBattlersCount = 4;
 
                 sub_81B8D64(0, 0);
                 sub_81B8D64(1, 0);
                 sub_81B8D64(2, 1);
                 sub_81B8D64(3, 1);
 
-                gBattlePartyID[0] = 0;
-                gBattlePartyID[1] = 0;
-                gBattlePartyID[2] = 3;
-                gBattlePartyID[3] = 3;
+                gBattlerPartyIndexes[0] = 0;
+                gBattlerPartyIndexes[1] = 0;
+                gBattlerPartyIndexes[2] = 3;
+                gBattlerPartyIndexes[3] = 3;
             }
             else if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
             {
                 u8 var; // multiplayer Id in a recorded battle?
 
-                for (var = gUnknown_0203C7B4, i = 0; i < BATTLE_BANKS_COUNT; i++)
+                for (var = gUnknown_0203C7B4, i = 0; i < MAX_BATTLERS_COUNT; i++)
                 {
                     switch (gLinkPlayers[i].lp_field_18)
                     {
@@ -307,53 +307,53 @@ static void SetControllersVariables(void)
 
                     if (i == var)
                     {
-                        gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer;
+                        gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer;
                         switch (gLinkPlayers[i].lp_field_18)
                         {
                         case 0:
                         case 3:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON1;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_PLAYER_LEFT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                             break;
                         case 1:
                         case 2:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON2;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_PLAYER_RIGHT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                             break;
                         }
                     }
                     else if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[var].lp_field_18 & 1))
                             || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[var].lp_field_18 & 1)))
                     {
-                        gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer;
+                        gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedPlayer;
                         switch (gLinkPlayers[i].lp_field_18)
                         {
                         case 0:
                         case 3:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON1;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_PLAYER_LEFT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                             break;
                         case 1:
                         case 2:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_PLAYER_MON2;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_PLAYER_RIGHT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                             break;
                         }
                     }
                     else
                     {
-                        gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedOpponent;
+                        gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToRecordedOpponent;
                         switch (gLinkPlayers[i].lp_field_18)
                         {
                         case 0:
                         case 3:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_OPPONENT_MON1;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_OPPONENT_LEFT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                             break;
                         case 1:
                         case 2:
-                            gBanksByIdentity[gLinkPlayers[i].lp_field_18] = IDENTITY_OPPONENT_MON2;
-                            gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                            gBattlerPositions[gLinkPlayers[i].lp_field_18] = B_POSITION_OPPONENT_RIGHT;
+                            gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                             break;
                         }
                     }
@@ -361,59 +361,59 @@ static void SetControllersVariables(void)
             }
             else if (gBattleTypeFlags & BATTLE_TYPE_WILD)
             {
-                gBattleBankFunc[0] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+                gBattlerControllerFuncs[0] = SetControllerToRecordedPlayer;
+                gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-                gBattleBankFunc[2] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+                gBattlerControllerFuncs[2] = SetControllerToRecordedPlayer;
+                gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
                 if (gBattleTypeFlags & BATTLE_TYPE_x2000000)
                 {
-                  gBattleBankFunc[1] = SetControllerToRecordedOpponent;
-                  gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+                  gBattlerControllerFuncs[1] = SetControllerToRecordedOpponent;
+                  gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-                  gBattleBankFunc[3] = SetControllerToRecordedOpponent;
-                  gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+                  gBattlerControllerFuncs[3] = SetControllerToRecordedOpponent;
+                  gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
                 }
                 else
                 {
-                  gBattleBankFunc[1] = SetControllerToOpponent;
-                  gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+                  gBattlerControllerFuncs[1] = SetControllerToOpponent;
+                  gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-                  gBattleBankFunc[3] = SetControllerToOpponent;
-                  gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+                  gBattlerControllerFuncs[3] = SetControllerToOpponent;
+                  gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
                 }
             }
             else
             {
-                gBattleBankFunc[1] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+                gBattlerControllerFuncs[1] = SetControllerToRecordedPlayer;
+                gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
 
-                gBattleBankFunc[3] = SetControllerToRecordedPlayer;
-                gBanksByIdentity[3] = IDENTITY_PLAYER_MON2;
+                gBattlerControllerFuncs[3] = SetControllerToRecordedPlayer;
+                gBattlerPositions[3] = B_POSITION_PLAYER_RIGHT;
 
                 if (gBattleTypeFlags & BATTLE_TYPE_x2000000)
                 {
-                    gBattleBankFunc[0] = SetControllerToRecordedOpponent;
-                    gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+                    gBattlerControllerFuncs[0] = SetControllerToRecordedOpponent;
+                    gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
 
-                    gBattleBankFunc[2] = SetControllerToRecordedOpponent;
-                    gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+                    gBattlerControllerFuncs[2] = SetControllerToRecordedOpponent;
+                    gBattlerPositions[2] = B_POSITION_OPPONENT_RIGHT;
                 }
                 else
                 {
-                    gBattleBankFunc[0] = SetControllerToOpponent;
-                    gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+                    gBattlerControllerFuncs[0] = SetControllerToOpponent;
+                    gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
 
-                    gBattleBankFunc[2] = SetControllerToOpponent;
-                    gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+                    gBattlerControllerFuncs[2] = SetControllerToOpponent;
+                    gBattlerPositions[2] = B_POSITION_OPPONENT_RIGHT;
                 }
             }
         }
     }
 }
 
-static void SetControllersVariablesInLinkBattle(void)
+static void InitLinkBtlControllers(void)
 {
     s32 i;
     u8 multiplayerId;
@@ -424,23 +424,23 @@ static void SetControllersVariablesInLinkBattle(void)
         {
             gBattleMainFunc = BeginBattleIntro;
 
-            gBattleBankFunc[0] = SetControllerToPlayer;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToLinkOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gNoOfAllBanks = 2;
+            gBattlersCount = 2;
         }
         else
         {
-            gBattleBankFunc[1] = SetControllerToPlayer;
-            gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToPlayer;
+            gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[0] = SetControllerToLinkOpponent;
-            gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+            gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
 
-            gNoOfAllBanks = 2;
+            gBattlersCount = 2;
         }
     }
     else if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
@@ -449,35 +449,35 @@ static void SetControllersVariablesInLinkBattle(void)
         {
             gBattleMainFunc = BeginBattleIntro;
 
-            gBattleBankFunc[0] = SetControllerToPlayer;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToLinkOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[2] = SetControllerToPlayer;
-            gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToPlayer;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[3] = SetControllerToLinkOpponent;
-            gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToLinkOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
 
-            gNoOfAllBanks = 4;
+            gBattlersCount = 4;
         }
         else
         {
-            gBattleBankFunc[1] = SetControllerToPlayer;
-            gBanksByIdentity[1] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToPlayer;
+            gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[0] = SetControllerToLinkOpponent;
-            gBanksByIdentity[0] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+            gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[3] = SetControllerToPlayer;
-            gBanksByIdentity[3] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToPlayer;
+            gBattlerPositions[3] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[2] = SetControllerToLinkOpponent;
-            gBanksByIdentity[2] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToLinkOpponent;
+            gBattlerPositions[2] = B_POSITION_OPPONENT_RIGHT;
 
-            gNoOfAllBanks = 4;
+            gBattlersCount = 4;
         }
     }
     else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER)
@@ -486,45 +486,45 @@ static void SetControllersVariablesInLinkBattle(void)
         {
             gBattleMainFunc = BeginBattleIntro;
 
-            gBattleBankFunc[0] = SetControllerToPlayer;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[2] = SetControllerToLinkPartner;
-            gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToLinkPartner;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[3] = SetControllerToOpponent;
-            gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
 
-            gNoOfAllBanks = 4;
+            gBattlersCount = 4;
         }
         else
         {
-            gBattleBankFunc[0] = SetControllerToLinkPartner;
-            gBanksByIdentity[0] = IDENTITY_PLAYER_MON1;
+            gBattlerControllerFuncs[0] = SetControllerToLinkPartner;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
 
-            gBattleBankFunc[1] = SetControllerToLinkOpponent;
-            gBanksByIdentity[1] = IDENTITY_OPPONENT_MON1;
+            gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
 
-            gBattleBankFunc[2] = SetControllerToPlayer;
-            gBanksByIdentity[2] = IDENTITY_PLAYER_MON2;
+            gBattlerControllerFuncs[2] = SetControllerToPlayer;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
 
-            gBattleBankFunc[3] = SetControllerToLinkOpponent;
-            gBanksByIdentity[3] = IDENTITY_OPPONENT_MON2;
+            gBattlerControllerFuncs[3] = SetControllerToLinkOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
 
-            gNoOfAllBanks = 4;
+            gBattlersCount = 4;
         }
 
         sub_81B8D64(0, 0);
         sub_81B8D64(1, 0);
         sub_81B8D64(2, 1);
         sub_81B8D64(3, 1);
-        gBattlePartyID[0] = 0;
-        gBattlePartyID[1] = 0;
-        gBattlePartyID[2] = 3;
-        gBattlePartyID[3] = 3;
+        gBattlerPartyIndexes[0] = 0;
+        gBattlerPartyIndexes[1] = 0;
+        gBattlerPartyIndexes[2] = 3;
+        gBattlerPartyIndexes[3] = 3;
     }
     else
     {
@@ -533,7 +533,7 @@ static void SetControllersVariablesInLinkBattle(void)
         if (gBattleTypeFlags & BATTLE_TYPE_WILD)
             gBattleMainFunc = BeginBattleIntro;
 
-        for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+        for (i = 0; i < MAX_BATTLERS_COUNT; i++)
         {
             switch (gLinkPlayers[i].lp_field_18)
             {
@@ -549,18 +549,18 @@ static void SetControllersVariablesInLinkBattle(void)
 
             if (i == multiplayerId)
             {
-                gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToPlayer;
+                gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToPlayer;
                 switch (gLinkPlayers[i].lp_field_18)
                 {
                 case 0:
                 case 3:
-                    gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 0;
-                    gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                    gBattlerPositions[gLinkPlayers[i].lp_field_18] = 0;
+                    gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                     break;
                 case 1:
                 case 2:
-                    gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 2;
-                    gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                    gBattlerPositions[gLinkPlayers[i].lp_field_18] = 2;
+                    gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                     break;
                 }
             }
@@ -569,42 +569,42 @@ static void SetControllersVariablesInLinkBattle(void)
                 if ((!(gLinkPlayers[i].lp_field_18 & 1) && !(gLinkPlayers[multiplayerId].lp_field_18 & 1))
                  || ((gLinkPlayers[i].lp_field_18 & 1) && (gLinkPlayers[multiplayerId].lp_field_18 & 1)))
                 {
-                    gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToLinkPartner;
+                    gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToLinkPartner;
                     switch (gLinkPlayers[i].lp_field_18)
                     {
                     case 0:
                     case 3:
-                        gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 0;
-                        gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                        gBattlerPositions[gLinkPlayers[i].lp_field_18] = 0;
+                        gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                         break;
                     case 1:
                     case 2:
-                        gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 2;
-                        gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                        gBattlerPositions[gLinkPlayers[i].lp_field_18] = 2;
+                        gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                         break;
                     }
                 }
                 else
                 {
-                    gBattleBankFunc[gLinkPlayers[i].lp_field_18] = SetControllerToLinkOpponent;
+                    gBattlerControllerFuncs[gLinkPlayers[i].lp_field_18] = SetControllerToLinkOpponent;
                     switch (gLinkPlayers[i].lp_field_18)
                     {
                     case 0:
                     case 3:
-                        gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 1;
-                        gBattlePartyID[gLinkPlayers[i].lp_field_18] = 0;
+                        gBattlerPositions[gLinkPlayers[i].lp_field_18] = 1;
+                        gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 0;
                         break;
                     case 1:
                     case 2:
-                        gBanksByIdentity[gLinkPlayers[i].lp_field_18] = 3;
-                        gBattlePartyID[gLinkPlayers[i].lp_field_18] = 3;
+                        gBattlerPositions[gLinkPlayers[i].lp_field_18] = 3;
+                        gBattlerPartyIndexes[gLinkPlayers[i].lp_field_18] = 3;
                         break;
                     }
                 }
             }
         }
 
-        gNoOfAllBanks = 4;
+        gBattlersCount = 4;
     }
 }
 
@@ -614,20 +614,20 @@ static void SetBattlePartyIds(void)
 
     if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
     {
-        for (i = 0; i < gNoOfAllBanks; i++)
+        for (i = 0; i < gBattlersCount; i++)
         {
             for (j = 0; j < 6; j++)
             {
                 if (i < 2)
                 {
-                    if (GET_BANK_SIDE2(i) == SIDE_PLAYER)
+                    if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
                     {
                         if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
                          && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
                          && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG) == 0)
                         {
-                            gBattlePartyID[i] = j;
+                            gBattlerPartyIndexes[i] = j;
                             break;
                         }
                     }
@@ -638,22 +638,22 @@ static void SetBattlePartyIds(void)
                          && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0)
                         {
-                            gBattlePartyID[i] = j;
+                            gBattlerPartyIndexes[i] = j;
                             break;
                         }
                     }
                 }
                 else
                 {
-                    if (GET_BANK_SIDE2(i) == SIDE_PLAYER)
+                    if (GET_BATTLER_SIDE2(i) == B_SIDE_PLAYER)
                     {
                         if (GetMonData(&gPlayerParty[j], MON_DATA_HP) != 0
                          && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES) != SPECIES_NONE  // Probably a typo by Game Freak. The rest use SPECIES2.
                          && GetMonData(&gPlayerParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gPlayerParty[j], MON_DATA_IS_EGG) == 0
-                         && gBattlePartyID[i - 2] != j)
+                         && gBattlerPartyIndexes[i - 2] != j)
                         {
-                            gBattlePartyID[i] = j;
+                            gBattlerPartyIndexes[i] = j;
                             break;
                         }
                     }
@@ -663,9 +663,9 @@ static void SetBattlePartyIds(void)
                          && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
                          && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
                          && GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG) == 0
-                         && gBattlePartyID[i - 2] != j)
+                         && gBattlerPartyIndexes[i - 2] != j)
                         {
-                            gBattlePartyID[i] = j;
+                            gBattlerPartyIndexes[i] = j;
                             break;
                         }
                     }
@@ -674,7 +674,7 @@ static void SetBattlePartyIds(void)
         }
 
         if (gBattleTypeFlags & BATTLE_TYPE_TWO_OPPONENTS)
-            gBattlePartyID[1] = 0, gBattlePartyID[3] = 3;
+            gBattlerPartyIndexes[1] = 0, gBattlerPartyIndexes[3] = 3;
     }
 }
 
@@ -693,14 +693,14 @@ static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size)
         case 0:
             for (i = 0; i < size; i++)
             {
-                gBattleBufferA[gActiveBank][i] = *data;
+                gBattleBufferA[gActiveBattler][i] = *data;
                 data++;
             }
             break;
         case 1:
             for (i = 0; i < size; i++)
             {
-                gBattleBufferB[gActiveBank][i] = *data;
+                gBattleBufferB[gActiveBattler][i] = *data;
                 data++;
             }
             break;
@@ -751,12 +751,12 @@ void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data)
         gTasks[gUnknown_02022D08].data[14] = 0;
     }
     gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_BUFFER_ID] = bufferId;
-    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ACTIVE_BANK] = gActiveBank;
-    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ATTACKER] = gBankAttacker;
-    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_TARGET] = gBankTarget;
+    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ACTIVE_BANK] = gActiveBattler;
+    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ATTACKER] = gBattlerAttacker;
+    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_TARGET] = gBattlerTarget;
     gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_SIZE_LO] = alignedSize;
     gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_SIZE_HI] = (alignedSize & 0x0000FF00) >> 8;
-    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ABSENT_BANK_FLAGS] = gAbsentBankFlags;
+    gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_ABSENT_BANK_FLAGS] = gAbsentBattlerFlags;
     gLinkBattleSendBuffer[gTasks[gUnknown_02022D08].data[14] + LINK_BUFF_EFFECT_BANK] = gEffectBank;
 
     for (i = 0; i < size; i++)
@@ -793,9 +793,9 @@ static void Task_HandleSendLinkBuffersData(u8 taskId)
             else
                 var = (gBattleTypeFlags & BATTLE_TYPE_MULTI) ? 4 : 2;
 
-            if (sub_800ABAC() >= var)
+            if (GetLinkPlayerCount_2() >= var)
             {
-                if (sub_800ABBC())
+                if (IsLinkMaster())
                 {
                     sub_800A620();
                     gTasks[taskId].data[11]++;
@@ -912,7 +912,7 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
         switch (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 0])
         {
         case 0:
-            if (gBattleExecBuffer & gBitTable[bank])
+            if (gBattleControllerExecFlags & gBitTable[bank])
                 return;
 
             memcpy(gBattleBufferA[bank], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 8], blockSize);
@@ -920,9 +920,9 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
 
             if (!(gBattleTypeFlags & BATTLE_TYPE_WILD))
             {
-                gBankAttacker = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 2];
-                gBankTarget = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 3];
-                gAbsentBankFlags = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 6];
+                gBattlerAttacker = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 2];
+                gBattlerTarget = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 3];
+                gAbsentBattlerFlags = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 6];
                 gEffectBank = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 7];
             }
             break;
@@ -931,7 +931,7 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
             break;
         case 2:
             var = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA];
-            gBattleExecBuffer &= ~(gBitTable[bank] << (var * 4));
+            gBattleControllerExecFlags &= ~(gBitTable[bank] << (var * 4));
             break;
         }
 
@@ -939,7 +939,7 @@ static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
     }
 }
 
-void EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
+void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA;
     gBattleBuffersTransferData[1] = requestId;
@@ -948,7 +948,7 @@ void EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
+void BtlController_EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA;
     gBattleBuffersTransferData[1] = monId;
@@ -957,7 +957,7 @@ void EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data)
+void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data)
 {
     s32 i;
 
@@ -969,7 +969,7 @@ void EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *da
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 3 + bytes);
 }
 
-void EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
+void BtlController_EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
 {
     s32 i;
 
@@ -981,7 +981,7 @@ void EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, bytes + 3);
 }
 
-void EmitLoadMonSprite(u8 bufferId)
+void BtlController_EmitLoadMonSprite(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE;
     gBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE;
@@ -990,7 +990,7 @@ void EmitLoadMonSprite(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
+void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM;
     gBattleBuffersTransferData[1] = partyId;
@@ -999,14 +999,14 @@ void EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitReturnMonToBall(u8 bufferId, u8 arg1)
+void BtlController_EmitReturnMonToBall(u8 bufferId, u8 arg1)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL;
     gBattleBuffersTransferData[1] = arg1;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitDrawTrainerPic(u8 bufferId)
+void BtlController_EmitDrawTrainerPic(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC;
     gBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC;
@@ -1015,7 +1015,7 @@ void EmitDrawTrainerPic(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitTrainerSlide(u8 bufferId)
+void BtlController_EmitTrainerSlide(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE;
     gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE;
@@ -1024,7 +1024,7 @@ void EmitTrainerSlide(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitTrainerSlideBack(u8 bufferId)
+void BtlController_EmitTrainerSlideBack(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK;
     gBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK;
@@ -1033,7 +1033,7 @@ void EmitTrainerSlideBack(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitFaintAnimation(u8 bufferId)
+void BtlController_EmitFaintAnimation(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION;
     gBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION;
@@ -1042,7 +1042,7 @@ void EmitFaintAnimation(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitPaletteFade(u8 bufferId)
+void BtlController_EmitPaletteFade(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE;
     gBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE;
@@ -1051,7 +1051,7 @@ void EmitPaletteFade(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitSuccessBallThrowAnim(u8 bufferId)
+void BtlController_EmitSuccessBallThrowAnim(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM;
     gBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM;
@@ -1060,14 +1060,14 @@ void EmitSuccessBallThrowAnim(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitBallThrowAnim(u8 bufferId, u8 caseId)
+void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM;
     gBattleBuffersTransferData[1] = caseId;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitPause(u8 bufferId, u8 toWait, void *data)
+void BtlController_EmitPause(u8 bufferId, u8 toWait, void *data)
 {
     s32 i;
 
@@ -1078,7 +1078,7 @@ void EmitPause(u8 bufferId, u8 toWait, void *data)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, toWait * 3 + 2);
 }
 
-void EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit)
+void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr, u8 multihit)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION;
     gBattleBuffersTransferData[1] = move;
@@ -1108,7 +1108,7 @@ void EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 16 + sizeof(struct DisableStruct));
 }
 
-void EmitPrintString(u8 bufferId, u16 stringID)
+void BtlController_EmitPrintString(u8 bufferId, u16 stringID)
 {
     s32 i;
     struct StringInfoBattle* stringInfo;
@@ -1123,13 +1123,13 @@ void EmitPrintString(u8 bufferId, u16 stringID)
     stringInfo->originallyUsedMove = gChosenMove;
     stringInfo->lastItem = gLastUsedItem;
     stringInfo->lastAbility = gLastUsedAbility;
-    stringInfo->scrActive = gBattleScripting.bank;
+    stringInfo->scrActive = gBattleScripting.battler;
     stringInfo->unk1605E = gBattleStruct->field_52;
     stringInfo->hpScale = gBattleStruct->hpScale;
-    stringInfo->StringBank = gStringBank;
+    stringInfo->StringBank = gStringBattler;
     stringInfo->moveType = gBattleMoves[gCurrentMove].type;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
         stringInfo->abilities[i] = gBattleMons[i].ability;
     for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++)
     {
@@ -1140,7 +1140,7 @@ void EmitPrintString(u8 bufferId, u16 stringID)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4);
 }
 
-void EmitPrintSelectionString(u8 bufferId, u16 stringID)
+void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringID)
 {
     s32 i;
     struct StringInfoBattle *stringInfo;
@@ -1155,10 +1155,10 @@ void EmitPrintSelectionString(u8 bufferId, u16 stringID)
     stringInfo->originallyUsedMove = gChosenMove;
     stringInfo->lastItem = gLastUsedItem;
     stringInfo->lastAbility = gLastUsedAbility;
-    stringInfo->scrActive = gBattleScripting.bank;
+    stringInfo->scrActive = gBattleScripting.battler;
     stringInfo->unk1605E = gBattleStruct->field_52;
 
-    for (i = 0; i < BATTLE_BANKS_COUNT; i++)
+    for (i = 0; i < MAX_BATTLERS_COUNT; i++)
         stringInfo->abilities[i] = gBattleMons[i].ability;
     for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; i++)
     {
@@ -1169,7 +1169,7 @@ void EmitPrintSelectionString(u8 bufferId, u16 stringID)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4);
 }
 
-void EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
+void BtlController_EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_CHOOSEACTION;
     gBattleBuffersTransferData[1] = arg1;
@@ -1178,7 +1178,7 @@ void EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitUnknownYesNoBox(u8 bufferId)
+void BtlController_EmitUnknownYesNoBox(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_UNKNOWNYESNOBOX;
     gBattleBuffersTransferData[1] = CONTROLLER_UNKNOWNYESNOBOX;
@@ -1187,7 +1187,7 @@ void EmitUnknownYesNoBox(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData)
+void BtlController_EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData)
 {
     s32 i;
 
@@ -1200,7 +1200,7 @@ void EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(*movePpData) + 4);
 }
 
-void EmitChooseItem(u8 bufferId, u8 *arg1)
+void BtlController_EmitChooseItem(u8 bufferId, u8 *arg1)
 {
     s32 i;
 
@@ -1210,7 +1210,7 @@ void EmitChooseItem(u8 bufferId, u8 *arg1)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8* arg4)
+void BtlController_EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8* arg4)
 {
     s32 i;
 
@@ -1223,7 +1223,7 @@ void EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8* arg4)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 8);  // but only 7 bytes were written
 }
 
-void EmitCmd23(u8 bufferId)
+void BtlController_EmitCmd23(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_23;
     gBattleBuffersTransferData[1] = CONTROLLER_23;
@@ -1233,7 +1233,7 @@ void EmitCmd23(u8 bufferId)
 }
 
 // why is the argument u16 if it's being cast to s16 anyway?
-void EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
+void BtlController_EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_HEALTHBARUPDATE;
     gBattleBuffersTransferData[1] = 0;
@@ -1243,7 +1243,7 @@ void EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
 }
 
 // why is the argument u16 if it's being cast to s16 anyway?
-void EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
+void BtlController_EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_EXPUPDATE;
     gBattleBuffersTransferData[1] = partyId;
@@ -1252,7 +1252,7 @@ void EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
+void BtlController_EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_STATUSICONUPDATE;
     gBattleBuffersTransferData[1] = status1;
@@ -1266,7 +1266,7 @@ void EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 9);
 }
 
-void EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
+void BtlController_EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_STATUSANIMATION;
     gBattleBuffersTransferData[1] = status2;
@@ -1277,14 +1277,14 @@ void EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 6);
 }
 
-void EmitStatusXor(u8 bufferId, u8 b)
+void BtlController_EmitStatusXor(u8 bufferId, u8 b)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_STATUSXOR;
     gBattleBuffersTransferData[1] = b;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitDataTransfer(u8 bufferId, u16 size, void *data)
+void BtlController_EmitDataTransfer(u8 bufferId, u16 size, void *data)
 {
     s32 i;
 
@@ -1297,7 +1297,7 @@ void EmitDataTransfer(u8 bufferId, u16 size, void *data)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 4);
 }
 
-void EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
+void BtlController_EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
 {
     s32 i;
 
@@ -1313,7 +1313,7 @@ void EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 7);
 }
 
-void EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
+void BtlController_EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
 {
     s32 i;
 
@@ -1325,7 +1325,7 @@ void EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, songId + 3);
 }
 
-void EmitCmd32(u8 bufferId, u16 size, void *data)
+void BtlController_EmitCmd32(u8 bufferId, u16 size, void *data)
 {
     s32 i;
 
@@ -1337,7 +1337,7 @@ void EmitCmd32(u8 bufferId, u16 size, void *data)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, size + 3);
 }
 
-void EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2)
+void BtlController_EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_TWORETURNVALUES;
     gBattleBuffersTransferData[1] = arg1;
@@ -1346,7 +1346,7 @@ void EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c)
+void BtlController_EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c)
 {
     s32 i;
 
@@ -1357,7 +1357,7 @@ void EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 5);
 }
 
-void EmitOneReturnValue(u8 bufferId, u16 arg1)
+void BtlController_EmitOneReturnValue(u8 bufferId, u16 arg1)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE;
     gBattleBuffersTransferData[1] = arg1;
@@ -1366,7 +1366,7 @@ void EmitOneReturnValue(u8 bufferId, u16 arg1)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitOneReturnValue_Duplicate(u8 bufferId, u16 b)
+void BtlController_EmitOneReturnValue_Duplicate(u8 bufferId, u16 b)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE;
     gBattleBuffersTransferData[1] = b;
@@ -1375,7 +1375,7 @@ void EmitOneReturnValue_Duplicate(u8 bufferId, u16 b)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitCmd37(u8 bufferId)
+void BtlController_EmitCmd37(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_37;
     gBattleBuffersTransferData[1] = CONTROLLER_37;
@@ -1384,14 +1384,14 @@ void EmitCmd37(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitCmd38(u8 bufferId, u8 b)
+void BtlController_EmitCmd38(u8 bufferId, u8 b)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_38;
     gBattleBuffersTransferData[1] = b;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitCmd39(u8 bufferId)
+void BtlController_EmitCmd39(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_39;
     gBattleBuffersTransferData[1] = CONTROLLER_39;
@@ -1400,7 +1400,7 @@ void EmitCmd39(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitCmd40(u8 bufferId)
+void BtlController_EmitCmd40(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_40;
     gBattleBuffersTransferData[1] = CONTROLLER_40;
@@ -1409,7 +1409,7 @@ void EmitCmd40(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitHitAnimation(u8 bufferId)
+void BtlController_EmitHitAnimation(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION;
     gBattleBuffersTransferData[1] = CONTROLLER_HITANIMATION;
@@ -1418,7 +1418,7 @@ void EmitHitAnimation(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitCmd42(u8 bufferId)
+void BtlController_EmitCmd42(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_42;
     gBattleBuffersTransferData[1] = CONTROLLER_42;
@@ -1427,7 +1427,7 @@ void EmitCmd42(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitPlaySE(u8 bufferId, u16 songId)
+void BtlController_EmitPlaySE(u8 bufferId, u16 songId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_EFFECTIVENESSSOUND;
     gBattleBuffersTransferData[1] = songId;
@@ -1436,7 +1436,7 @@ void EmitPlaySE(u8 bufferId, u16 songId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM)
+void BtlController_EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_PLAYFANFAREORBGM;
     gBattleBuffersTransferData[1] = songId;
@@ -1445,7 +1445,7 @@ void EmitPlayFanfareOrBGM(u8 bufferId, u16 songId, bool8 playBGM)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitFaintingCry(u8 bufferId)
+void BtlController_EmitFaintingCry(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY;
     gBattleBuffersTransferData[1] = CONTROLLER_FAINTINGCRY;
@@ -1454,14 +1454,14 @@ void EmitFaintingCry(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitIntroSlide(u8 bufferId, u8 terrainId)
+void BtlController_EmitIntroSlide(u8 bufferId, u8 terrainId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_INTROSLIDE;
     gBattleBuffersTransferData[1] = terrainId;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitIntroTrainerBallThrow(u8 bufferId)
+void BtlController_EmitIntroTrainerBallThrow(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW;
     gBattleBuffersTransferData[1] = CONTROLLER_INTROTRAINERBALLTHROW;
@@ -1470,7 +1470,7 @@ void EmitIntroTrainerBallThrow(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 arg2)
+void BtlController_EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 arg2)
 {
     s32 i;
 
@@ -1483,7 +1483,7 @@ void EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, sizeof(struct HpAndStatus) * 6 + 4);
 }
 
-void EmitCmd49(u8 bufferId)
+void BtlController_EmitCmd49(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_49;
     gBattleBuffersTransferData[1] = CONTROLLER_49;
@@ -1492,7 +1492,7 @@ void EmitCmd49(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitCmd50(u8 bufferId)
+void BtlController_EmitCmd50(u8 bufferId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_50;
     gBattleBuffersTransferData[1] = CONTROLLER_50;
@@ -1501,7 +1501,7 @@ void EmitCmd50(u8 bufferId)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
+void BtlController_EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY;
     gBattleBuffersTransferData[1] = isInvisible;
@@ -1510,7 +1510,7 @@ void EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
+void BtlController_EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_BATTLEANIMATION;
     gBattleBuffersTransferData[1] = animationId;
@@ -1519,7 +1519,7 @@ void EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 4);
 }
 
-void EmitLinkStandbyMsg(u8 bufferId, u8 arg1, bool32 arg2)
+void BtlController_EmitLinkStandbyMsg(u8 bufferId, u8 arg1, bool32 arg2)
 {
     bool8 arg2_ = arg2;
     gBattleBuffersTransferData[0] = CONTROLLER_LINKSTANDBYMSG;
@@ -1533,14 +1533,14 @@ void EmitLinkStandbyMsg(u8 bufferId, u8 arg1, bool32 arg2)
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, gBattleBuffersTransferData[2] + 4);
 }
 
-void EmitResetActionMoveSelection(u8 bufferId, u8 caseId)
+void BtlController_EmitResetActionMoveSelection(u8 bufferId, u8 caseId)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_RESETACTIONMOVESELECTION;
     gBattleBuffersTransferData[1] = caseId;
     PrepareBufferDataTransfer(bufferId, gBattleBuffersTransferData, 2);
 }
 
-void EmitCmd55(u8 bufferId, u8 arg1)
+void BtlController_EmitCmd55(u8 bufferId, u8 arg1)
 {
     gBattleBuffersTransferData[0] = CONTROLLER_55;
     gBattleBuffersTransferData[1] = arg1;