ported battle_controllers from pokeem

9 files changed, 1254 insertions, 89 deletions

diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c
index 1650f1056..86e7d3143 100644
--- a/src/battle_ai_script_commands.c
+++ b/src/battle_ai_script_commands.c
@@ -249,7 +249,7 @@ static const u16 sDiscouragedPowerfulMoveEffects[] =
 };
 
 // TODO: move these
-extern u8 sBattler_AI;
+extern u8 gBattlerAttacker;
 extern const u32 gBitTable[]; // util.h
 extern u32 gStatuses3[]; // battle_2.h
 extern u16 gSideAffecting[2];
@@ -318,7 +318,7 @@ void BattleAI_SetupAIData(void)
     }
 
     gBattleResources->AI_ScriptsStack->size = 0;
-    sBattler_AI = gActiveBattler;
+    gBattlerAttacker = gActiveBattler;
 
     // Decide a random target battlerId in doubles.
     if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE)
@@ -331,7 +331,7 @@ void BattleAI_SetupAIData(void)
     // There's only one choice in single battles.
     else
     {
-        gBattlerTarget = sBattler_AI ^ BIT_SIDE;
+        gBattlerTarget = gBattlerAttacker ^ BIT_SIDE;
     }
 
     // Choose proper trainer ai scripts.
@@ -425,13 +425,13 @@ void BattleAI_DoAIProcessing(void)
             break;
         case AIState_SettingUp:
             gAIScriptPtr = BattleAIs[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr.
-            if (gBattleMons[sBattler_AI].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
+            if (gBattleMons[gBattlerAttacker].pp[AI_THINKING_STRUCT->movesetIndex] == 0)
             {
                 AI_THINKING_STRUCT->moveConsidered = 0; // don't consider a move you have 0 PP for, idiot.
             }
             else
             {
-                AI_THINKING_STRUCT->moveConsidered = gBattleMons[sBattler_AI].moves[AI_THINKING_STRUCT->movesetIndex];
+                AI_THINKING_STRUCT->moveConsidered = gBattleMons[gBattlerAttacker].moves[AI_THINKING_STRUCT->movesetIndex];
             }
             AI_THINKING_STRUCT->aiState++;
             break;
@@ -544,7 +544,7 @@ static void BattleAICmd_if_hp_less_than(void)
     u16 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -559,7 +559,7 @@ static void BattleAICmd_if_hp_more_than(void)
     u16 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -574,7 +574,7 @@ static void BattleAICmd_if_hp_equal(void)
     u16 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -589,7 +589,7 @@ static void BattleAICmd_if_hp_not_equal(void)
     u16 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -605,7 +605,7 @@ static void BattleAICmd_if_status(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -623,7 +623,7 @@ static void BattleAICmd_if_not_status(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -641,7 +641,7 @@ static void BattleAICmd_if_status2(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -659,7 +659,7 @@ static void BattleAICmd_if_not_status2(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -677,7 +677,7 @@ static void BattleAICmd_if_status3(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -695,7 +695,7 @@ static void BattleAICmd_if_not_status3(void)
     u32 arg;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -713,7 +713,7 @@ static void BattleAICmd_if_status4(void)
     u32 arg1, arg2;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -732,7 +732,7 @@ static void BattleAICmd_if_not_status4(void)
     u32 arg1, arg2;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -907,8 +907,8 @@ static void BattleAICmd_if_user_can_damage(void)
 
     for (i = 0; i < MAX_MON_MOVES; i++)
     {
-        if (gBattleMons[sBattler_AI].moves[i] != 0
-            && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+        if (gBattleMons[gBattlerAttacker].moves[i] != 0
+            && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].power != 0)
             break;
     }
     if (i == MAX_MON_MOVES)
@@ -923,8 +923,8 @@ static void BattleAICmd_if_user_cant_damage(void)
 
     for (i = 0; i < MAX_MON_MOVES; i++)
     {
-        if (gBattleMons[sBattler_AI].moves[i] != 0
-         && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].power != 0)
+        if (gBattleMons[gBattlerAttacker].moves[i] != 0
+         && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].power != 0)
             break;
     }
     if (i != MAX_MON_MOVES)
@@ -944,13 +944,13 @@ static void BattleAICmd_get_type(void)
     switch (gAIScriptPtr[1])
     {
     case 1: // player primary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type1;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerAttacker].type1;
         break;
     case 0: // enemy primary type
         AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type1;
         break;
     case 3: // player secondary type
-        AI_THINKING_STRUCT->funcResult = gBattleMons[sBattler_AI].type2;
+        AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerAttacker].type2;
         break;
     case 2: // enemy secondary type
         AI_THINKING_STRUCT->funcResult = gBattleMons[gBattlerTarget].type2;
@@ -992,17 +992,17 @@ static void BattleAICmd_is_most_powerful_move(void)
         {
             for (i = 0; sDiscouragedPowerfulMoveEffects[i] != 0xFFFF; i++)
             {
-                if (gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
+                if (gBattleMoves[gBattleMons[gBattlerAttacker].moves[checkedMove]].effect == sDiscouragedPowerfulMoveEffects[i])
                     break;
             }
 
-            if (gBattleMons[sBattler_AI].moves[checkedMove] != MOVE_NONE
+            if (gBattleMons[gBattlerAttacker].moves[checkedMove] != MOVE_NONE
                 && sDiscouragedPowerfulMoveEffects[i] == 0xFFFF
-                && gBattleMoves[gBattleMons[sBattler_AI].moves[checkedMove]].power > 1)
+                && gBattleMoves[gBattleMons[gBattlerAttacker].moves[checkedMove]].power > 1)
             {
-                gCurrentMove = gBattleMons[sBattler_AI].moves[checkedMove];
-                AI_CalcDmg(sBattler_AI, gBattlerTarget);
-                TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+                gCurrentMove = gBattleMons[gBattlerAttacker].moves[checkedMove];
+                AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+                TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
                 moveDmgs[checkedMove] = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[checkedMove] / 100;
                 if (moveDmgs[checkedMove] == 0)
                     moveDmgs[checkedMove] = 1;
@@ -1035,7 +1035,7 @@ static void BattleAICmd_is_most_powerful_move(void)
 static void BattleAICmd_get_move(void)
 {
     if (gAIScriptPtr[1] == USER)
-        AI_THINKING_STRUCT->funcResult = gLastUsedMove[sBattler_AI];
+        AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerAttacker];
     else
         AI_THINKING_STRUCT->funcResult = gLastUsedMove[gBattlerTarget];
 
@@ -1060,7 +1060,7 @@ static void BattleAICmd_if_arg_not_equal(void)
 
 static void BattleAICmd_if_would_go_first(void)
 {
-    if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) == gAIScriptPtr[1])
+    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) == gAIScriptPtr[1])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -1068,7 +1068,7 @@ static void BattleAICmd_if_would_go_first(void)
 
 static void BattleAICmd_if_would_not_go_first(void)
 {
-    if (GetWhoStrikesFirst(sBattler_AI, gBattlerTarget, TRUE) != gAIScriptPtr[1])
+    if (GetWhoStrikesFirst(gBattlerAttacker, gBattlerTarget, TRUE) != gAIScriptPtr[1])
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
     else
         gAIScriptPtr += 6;
@@ -1092,7 +1092,7 @@ static void BattleAICmd_count_alive_pokemon(void)
     AI_THINKING_STRUCT->funcResult = 0;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1145,7 +1145,7 @@ static void BattleAICmd_get_ability(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1218,11 +1218,11 @@ static void BattleAICmd_get_highest_possible_damage(void)
     for (i = 0; i < 4; i++)
     {
         gBattleMoveDamage = 40;
-        gCurrentMove = gBattleMons[sBattler_AI].moves[i];
+        gCurrentMove = gBattleMons[gBattlerAttacker].moves[i];
 
         if (gCurrentMove != 0)
         {
-            TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+            TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
 
             if (gBattleMoveDamage == 120) // Super effective STAB.
                 gBattleMoveDamage = AI_EFFECTIVENESS_x2;
@@ -1257,7 +1257,7 @@ static void BattleAICmd_if_type_effectiveness(void)
     gBattleMoveDamage = AI_EFFECTIVENESS_x1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
 
-    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+    TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
 
     if (gBattleMoveDamage == 120) // Super effective STAB.
         gBattleMoveDamage = AI_EFFECTIVENESS_x2;
@@ -1402,7 +1402,7 @@ static void BattleAICmd_if_stat_level_less_than(void)
     u32 party;
 
     if (gAIScriptPtr[1] == USER)
-        party = sBattler_AI;
+        party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
@@ -1417,7 +1417,7 @@ static void BattleAICmd_if_stat_level_more_than(void)
     u32 party;
 
     if (gAIScriptPtr[1] == USER)
-        party = sBattler_AI;
+        party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
@@ -1432,7 +1432,7 @@ static void BattleAICmd_if_stat_level_equal(void)
     u32 party;
 
     if (gAIScriptPtr[1] == USER)
-        party = sBattler_AI;
+        party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
@@ -1447,7 +1447,7 @@ static void BattleAICmd_if_stat_level_not_equal(void)
     u32 party;
 
     if (gAIScriptPtr[1] == USER)
-        party = sBattler_AI;
+        party = gBattlerAttacker;
     else
         party = gBattlerTarget;
 
@@ -1471,8 +1471,8 @@ static void BattleAICmd_if_can_faint(void)
     gMoveResultFlags = 0;
     gCritMultiplier = 1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
-    AI_CalcDmg(sBattler_AI, gBattlerTarget);
-    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+    AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+    TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
 
     gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
 
@@ -1500,8 +1500,8 @@ static void BattleAICmd_if_cant_faint(void)
     gMoveResultFlags = 0;
     gCritMultiplier = 1;
     gCurrentMove = AI_THINKING_STRUCT->moveConsidered;
-    AI_CalcDmg(sBattler_AI, gBattlerTarget);
-    TypeCalc(gCurrentMove, sBattler_AI, gBattlerTarget);
+    AI_CalcDmg(gBattlerAttacker, gBattlerTarget);
+    TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
 
     gBattleMoveDamage = gBattleMoveDamage * AI_THINKING_STRUCT->simulatedRNG[AI_THINKING_STRUCT->movesetIndex] / 100;
 
@@ -1524,7 +1524,7 @@ static void BattleAICmd_if_has_move(void)
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+            if (gBattleMons[gBattlerAttacker].moves[i] == *temp_ptr)
                 break;
         }
         if (i == MAX_MON_MOVES)
@@ -1558,7 +1558,7 @@ static void BattleAICmd_if_dont_have_move(void)
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[sBattler_AI].moves[i] == *temp_ptr)
+            if (gBattleMons[gBattlerAttacker].moves[i] == *temp_ptr)
                 break;
         }
         if (i != MAX_MON_MOVES)
@@ -1591,7 +1591,7 @@ static void BattleAICmd_if_move_effect(void)
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i != MAX_MON_MOVES)
@@ -1603,7 +1603,7 @@ static void BattleAICmd_if_move_effect(void)
     case 2:
         for (i = 0; i < 8; i++)
         {
-            if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[BATTLE_HISTORY->usedMoves[gBattlerTarget >> 1][i]].effect == gAIScriptPtr[2])
                 break;
         }
         gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3);
@@ -1620,7 +1620,7 @@ static void BattleAICmd_if_not_move_effect(void)
     case 3:
         for (i = 0; i < MAX_MON_MOVES; i++)
         {
-            if (gBattleMons[sBattler_AI].moves[i] != 0 && gBattleMoves[gBattleMons[sBattler_AI].moves[i]].effect == gAIScriptPtr[2])
+            if (gBattleMons[gBattlerAttacker].moves[i] != 0 && gBattleMoves[gBattleMons[gBattlerAttacker].moves[i]].effect == gAIScriptPtr[2])
                 break;
         }
         if (i != MAX_MON_MOVES)
@@ -1644,7 +1644,7 @@ static void BattleAICmd_if_last_move_did_damage(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1739,7 +1739,7 @@ static void BattleAICmd_get_hold_effect(void)
     u16 side;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1759,7 +1759,7 @@ static void BattleAICmd_get_gender(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1773,7 +1773,7 @@ static void BattleAICmd_is_first_turn(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1787,7 +1787,7 @@ static void BattleAICmd_get_stockpile_count(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1808,7 +1808,7 @@ static void BattleAICmd_get_used_held_item(void)
     u8 battlerId;
 
     if (gAIScriptPtr[1] == AI_USER)
-        battlerId = sBattler_AI;
+        battlerId = gBattlerAttacker;
     else
         battlerId = gBattlerTarget;
 
@@ -1848,7 +1848,7 @@ static void BattleAICmd_get_protect_count(void)
     u8 index;
 
     if (gAIScriptPtr[1] == USER)
-        index = sBattler_AI;
+        index = gBattlerAttacker;
     else
         index = gBattlerTarget;
 
@@ -1903,7 +1903,7 @@ static void BattleAICmd_if_level_compare(void)
     switch (gAIScriptPtr[1])
     {
     case 0: // greater than
-        if (gBattleMons[sBattler_AI].level > gBattleMons[gBattlerTarget].level)
+        if (gBattleMons[gBattlerAttacker].level > gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
             return;
@@ -1911,7 +1911,7 @@ static void BattleAICmd_if_level_compare(void)
         gAIScriptPtr += 6;
         return;
     case 1: // less than
-        if (gBattleMons[sBattler_AI].level < gBattleMons[gBattlerTarget].level)
+        if (gBattleMons[gBattlerAttacker].level < gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
             return;
@@ -1919,7 +1919,7 @@ static void BattleAICmd_if_level_compare(void)
         gAIScriptPtr += 6;
         return;
     case 2: // equal
-        if (gBattleMons[sBattler_AI].level == gBattleMons[gBattlerTarget].level)
+        if (gBattleMons[gBattlerAttacker].level == gBattleMons[gBattlerTarget].level)
         {
             gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2);
             return;
diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c
index 5a2f20ef4..b3c6ab2e5 100644
--- a/src/battle_controller_safari.c
+++ b/src/battle_controller_safari.c
@@ -176,16 +176,16 @@ static void HandleInputChooseAction(void)
         switch (gActionSelectionCursor[gActiveBattler])
         {
         case 0:
-            EmitTwoReturnValues(1, B_ACTION_SAFARI_BALL, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_BALL, 0);
             break;
         case 1:
-            EmitTwoReturnValues(1, B_ACTION_SAFARI_POKEBLOCK, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_POKEBLOCK, 0);
             break;
         case 2:
-            EmitTwoReturnValues(1, B_ACTION_SAFARI_GO_NEAR, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_GO_NEAR, 0);
             break;
         case 3:
-            EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
+            BtlController_EmitTwoReturnValues(1, B_ACTION_SAFARI_RUN, 0);
             break;
         }
         SafariBufferExecCompleted();
@@ -276,7 +276,7 @@ static void CompleteWhenChosePokeblock(void)
 {
     if (gMain.callback2 == BattleMainCB2 && !gPaletteFade.active)
     {
-        EmitOneReturnValue(1, gSpecialVar_ItemId);
+        BtlController_EmitOneReturnValue(1, gSpecialVar_ItemId);
         SafariBufferExecCompleted();
     }
 }
diff --git a/src/battle_controllers.c b/src/battle_controllers.c
new file mode 100644
index 000000000..20c934a0c
--- /dev/null
+++ b/src/battle_controllers.c
@@ -0,0 +1,1171 @@
+#include "global.h"
+#include "battle.h"
+#include "battle_2.h"
+#include "battle_ai_script_commands.h"
+#include "battle_anim.h"
+#include "battle_util.h"
+#include "battle_controllers.h"
+#include "battle_message.h"
+#include "link.h"
+#include "link_rfu.h"
+#include "cable_club.h"
+#include "party_menu.h"
+#include "pokemon.h"
+#include "task.h"
+#include "util.h"
+#include "constants/abilities.h"
+#include "constants/species.h"
+#include "constants/battle.h"
+
+static EWRAM_DATA u8 sLinkSendTaskId = 0;
+static EWRAM_DATA u8 sLinkReceiveTaskId = 0;
+static EWRAM_DATA u8 gUnknown_202286E = 0;
+EWRAM_DATA struct UnusedControllerStruct gUnknown_2022870 = {0};
+static EWRAM_DATA u8 sBattleBuffersTransferData[0x100] = {0};
+
+static void CreateTasksForSendRecvLinkBuffers(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);
+
+void HandleLinkBattleSetup(void)
+{
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        if (gWirelessCommType)
+            sub_800B1F4();
+        if (!gReceivedRemoteLinkPlayers)
+            OpenLink();
+        CreateTask(sub_8081A90, 0);
+        CreateTasksForSendRecvLinkBuffers();
+    }
+}
+
+void SetUpBattleVars(void)
+{
+    s32 i;
+
+    gBattleMainFunc = nullsub_12;
+    for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+    {
+        gBattlerControllerFuncs[i] = nullsub_13;
+        gBattlerPositions[i] = 0xFF;
+        gActionSelectionCursor[i] = 0;
+        gMoveSelectionCursor[i] = 0;
+    }
+    HandleLinkBattleSetup();
+    gBattleControllerExecFlags = 0;
+    ClearBattleAnimationVars();
+    ClearBattleMonForms();
+    BattleAI_HandleItemUseBeforeAISetup();
+    gUnknown_2022B54 = 0;
+    gUnknown_2023DDC = 0;
+}
+
+void sub_800D30C(void)
+{
+    s32 i;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+        InitLinkBtlControllers();
+    else
+        InitSinglePlayerBtlControllers();
+    SetBattlePartyIds();
+    if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+        for (i = 0; i < gBattlersCount; ++i)
+            sub_8127DA8(i, 0);
+}
+
+static void InitSinglePlayerBtlControllers(void)
+{
+    if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+    {
+        gBattleMainFunc = BeginBattleIntro;
+        if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+        {
+            gBattlerControllerFuncs[0] = SetControllerToPokedude;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToPokedude;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlersCount = 2;
+        }
+        else
+        {
+            if (gBattleTypeFlags & BATTLE_TYPE_SAFARI)
+                gBattlerControllerFuncs[0] = SetControllerToSafari;
+            else if (gBattleTypeFlags & (BATTLE_TYPE_OLDMAN_TUTORIAL | BATTLE_TYPE_FIRST_BATTLE))
+                gBattlerControllerFuncs[0] = SetControllerToOakOrOldman;
+            else
+                gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlersCount = 2;
+        }
+    }
+    else
+    {
+        gBattleMainFunc = BeginBattleIntro;
+        if (gBattleTypeFlags & BATTLE_TYPE_POKEDUDE)
+        {
+            gBattlerControllerFuncs[0] = SetControllerToPokedude;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToPokedude;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlerControllerFuncs[2] = SetControllerToPokedude;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+            gBattlerControllerFuncs[3] = SetControllerToPokedude;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+            gBattlersCount = MAX_BATTLERS_COUNT;
+        }
+        else
+        {
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlerControllerFuncs[2] = SetControllerToPlayer;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+            gBattlerControllerFuncs[3] = SetControllerToOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+            gBattlersCount = MAX_BATTLERS_COUNT;
+        }
+    }
+}
+
+static void InitLinkBtlControllers(void)
+{
+    s32 i;
+    u8 multiplayerId;
+
+    if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+        {
+            gBattleMainFunc = BeginBattleIntro;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlersCount = 2;
+        }
+        else
+        {
+            gBattlerControllerFuncs[1] = SetControllerToPlayer;
+            gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+            gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
+            gBattlersCount = 2;
+        }
+    }
+    else if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && (gBattleTypeFlags & BATTLE_TYPE_DOUBLE))
+    {
+        if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+        {
+            gBattleMainFunc = BeginBattleIntro;
+            gBattlerControllerFuncs[0] = SetControllerToPlayer;
+            gBattlerPositions[0] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[1] = SetControllerToLinkOpponent;
+            gBattlerPositions[1] = B_POSITION_OPPONENT_LEFT;
+            gBattlerControllerFuncs[2] = SetControllerToPlayer;
+            gBattlerPositions[2] = B_POSITION_PLAYER_RIGHT;
+            gBattlerControllerFuncs[3] = SetControllerToLinkOpponent;
+            gBattlerPositions[3] = B_POSITION_OPPONENT_RIGHT;
+            gBattlersCount = MAX_BATTLERS_COUNT;
+        }
+        else
+        {
+            gBattlerControllerFuncs[1] = SetControllerToPlayer;
+            gBattlerPositions[1] = B_POSITION_PLAYER_LEFT;
+            gBattlerControllerFuncs[0] = SetControllerToLinkOpponent;
+            gBattlerPositions[0] = B_POSITION_OPPONENT_LEFT;
+            gBattlerControllerFuncs[3] = SetControllerToPlayer;
+            gBattlerPositions[3] = B_POSITION_PLAYER_RIGHT;
+            gBattlerControllerFuncs[2] = SetControllerToLinkOpponent;
+            gBattlerPositions[2] = B_POSITION_OPPONENT_RIGHT;
+            gBattlersCount = MAX_BATTLERS_COUNT;
+        }
+    }
+    else
+    {
+        multiplayerId = GetMultiplayerId();
+        if (gBattleTypeFlags & BATTLE_TYPE_IS_MASTER)
+            gBattleMainFunc = BeginBattleIntro;
+
+        for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+        {
+            switch (gLinkPlayers[i].id)
+            {
+            case 0:
+            case 3:
+                sub_8127DA8(gLinkPlayers[i].id, 0);
+                break;
+            case 1:
+            case 2:
+                sub_8127DA8(gLinkPlayers[i].id, 1);
+                break;
+            }
+            if (i == multiplayerId)
+            {
+                gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToPlayer;
+                switch (gLinkPlayers[i].id)
+                {
+                case 0:
+                case 3:
+                    gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+                    gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+                    break;
+                case 1:
+                case 2:
+                    gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_RIGHT;
+                    gBattlerPartyIndexes[gLinkPlayers[i].id] = 3;
+                    break;
+                }
+            }
+            else
+            {
+                if ((!(gLinkPlayers[i].id & 1) && !(gLinkPlayers[multiplayerId].id & 1)) || ((gLinkPlayers[i].id & 1) && (gLinkPlayers[multiplayerId].id & 1)))
+                {
+                    gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToLinkPartner;
+                    switch (gLinkPlayers[i].id)
+                    {
+                    case 0:
+                    case 3:
+                        gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+                        gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+                        break;
+                    case 1:
+                    case 2:
+                        gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_PLAYER_RIGHT;
+                        gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+                        break;
+                    }
+                }
+                else
+                {
+                    gBattlerControllerFuncs[gLinkPlayers[i].id] = SetControllerToLinkOpponent;
+                    switch (gLinkPlayers[i].id)
+                    {
+                    case 0:
+                    case 3:
+                        gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_OPPONENT_LEFT;
+                        gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_PLAYER_LEFT;
+                        break;
+                    case 1:
+                    case 2:
+                        gBattlerPositions[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+                        gBattlerPartyIndexes[gLinkPlayers[i].id] = B_POSITION_OPPONENT_RIGHT;
+                        break;
+                    }
+                }
+            }
+        }
+        gBattlersCount = MAX_BATTLERS_COUNT;
+    }
+}
+
+static void SetBattlePartyIds(void)
+{
+    s32 i, j;
+
+    if (!(gBattleTypeFlags & BATTLE_TYPE_MULTI))
+    {
+        for (i = 0; i < gBattlersCount; ++i)
+        {
+            for (j = 0; j < PARTY_SIZE; ++j)
+            {
+                if (i < 2)
+                {
+                    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))
+                        {
+                            gBattlerPartyIndexes[i] = j;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+                         && !GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG))
+                        {
+                            gBattlerPartyIndexes[i] = j;
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    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)
+                         && gBattlerPartyIndexes[i - 2] != j)
+                        {
+                            gBattlerPartyIndexes[i] = j;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (GetMonData(&gEnemyParty[j], MON_DATA_HP) != 0
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_NONE
+                         && GetMonData(&gEnemyParty[j], MON_DATA_SPECIES2) != SPECIES_EGG
+                         && !GetMonData(&gEnemyParty[j], MON_DATA_IS_EGG)
+                         && gBattlerPartyIndexes[i - 2] != j)
+                        {
+                            gBattlerPartyIndexes[i] = j;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void PrepareBufferDataTransfer(u8 bufferId, u8 *data, u16 size)
+{
+    s32 i;
+
+    if (gBattleTypeFlags & BATTLE_TYPE_LINK)
+    {
+        PrepareBufferDataTransferLink(bufferId, size, data);
+    }
+    else
+    {
+        switch (bufferId)
+        {
+        case 0:
+            for (i = 0; i < size; ++data, ++i)
+                gBattleBufferA[gActiveBattler][i] = *data;
+            break;
+        case 1:
+            for (i = 0; i < size; ++data, ++i)
+                gBattleBufferB[gActiveBattler][i] = *data;
+            break;
+        }
+    }
+}
+
+static void CreateTasksForSendRecvLinkBuffers(void)
+{
+    sLinkSendTaskId = CreateTask(Task_HandleSendLinkBuffersData, 0);
+    gTasks[sLinkSendTaskId].data[11] = 0;
+    gTasks[sLinkSendTaskId].data[12] = 0;
+    gTasks[sLinkSendTaskId].data[13] = 0;
+    gTasks[sLinkSendTaskId].data[14] = 0;
+    gTasks[sLinkSendTaskId].data[15] = 0;
+    sLinkReceiveTaskId = CreateTask(Task_HandleCopyReceivedLinkBuffersData, 0);
+    gTasks[sLinkReceiveTaskId].data[12] = 0;
+    gTasks[sLinkReceiveTaskId].data[13] = 0;
+    gTasks[sLinkReceiveTaskId].data[14] = 0;
+    gTasks[sLinkReceiveTaskId].data[15] = 0;
+    gUnknown_202286E = 0;
+}
+
+enum
+{
+    LINK_BUFF_BUFFER_ID,
+    LINK_BUFF_ACTIVE_BATTLER,
+    LINK_BUFF_ATTACKER,
+    LINK_BUFF_TARGET,
+    LINK_BUFF_SIZE_LO,
+    LINK_BUFF_SIZE_HI,
+    LINK_BUFF_ABSENT_BATTLER_FLAGS,
+    LINK_BUFF_EFFECT_BATTLER,
+    LINK_BUFF_DATA,
+};
+
+void PrepareBufferDataTransferLink(u8 bufferId, u16 size, u8 *data)
+{
+    s32 alignedSize, i;
+
+    alignedSize = size - size % 4 + 4;
+    if (gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA + 1 > BATTLE_BUFFER_LINK_SIZE)
+    {
+        gTasks[sLinkSendTaskId].data[12] = gTasks[sLinkSendTaskId].data[14];
+        gTasks[sLinkSendTaskId].data[14] = 0;
+    }
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_BUFFER_ID] = bufferId;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ACTIVE_BATTLER] = gActiveBattler;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ATTACKER] = gBattlerAttacker;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_TARGET] = gBattlerTarget;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_SIZE_LO] = alignedSize;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_SIZE_HI] = (alignedSize & 0x0000FF00) >> 8;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_ABSENT_BATTLER_FLAGS] = gAbsentBattlerFlags;
+    gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_EFFECT_BATTLER] = gEffectBattler;
+    for (i = 0; i < size; ++i)
+        gLinkBattleSendBuffer[gTasks[sLinkSendTaskId].data[14] + LINK_BUFF_DATA + i] = data[i];
+    gTasks[sLinkSendTaskId].data[14] = gTasks[sLinkSendTaskId].data[14] + alignedSize + LINK_BUFF_DATA;
+}
+
+static void Task_HandleSendLinkBuffersData(u8 taskId)
+{
+    u16 blockSize;
+    s32 playerCount;
+
+    switch (gTasks[taskId].data[11])
+    {
+    case 0:
+        gTasks[taskId].data[10] = 100;
+        ++gTasks[taskId].data[11];
+        break;
+    case 1:
+        if (!--gTasks[taskId].data[10])
+        {
+            ++gTasks[taskId].data[11];
+            if (gReceivedRemoteLinkPlayers)
+                gTasks[taskId].data[11] = 3;
+        }
+        break;
+    case 2:
+        playerCount = GetLinkPlayerCount_2();
+        if ((gBattleTypeFlags & BATTLE_TYPE_MULTI && playerCount > 3) || (!(gBattleTypeFlags & BATTLE_TYPE_MULTI) && playerCount > 1))
+        {
+            if (IsLinkMaster())
+            {
+                CheckShouldAdvanceLinkState();
+                ++gTasks[taskId].data[11];
+            }
+            else
+            {
+                ++gTasks[taskId].data[11];
+            }
+        }
+        break;
+    case 3:
+        if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+        {
+            if (!gTasks[taskId].data[13])
+            {
+                if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+                 && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+                {
+                    gTasks[taskId].data[12] = 0;
+                    gTasks[taskId].data[15] = 0;
+                }
+                blockSize = (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8)) + LINK_BUFF_DATA;
+                SendBlock(bitmask_all_link_players_but_self(), &gLinkBattleSendBuffer[gTasks[taskId].data[15]], blockSize);
+                ++gTasks[taskId].data[11];
+            }
+            else
+            {
+                --gTasks[taskId].data[13];
+                break;
+            }
+        }
+        break;
+    case 4:
+        if (IsLinkTaskFinished())
+        {
+            blockSize = gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleSendBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+            gTasks[taskId].data[13] = 5;
+            gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+            gTasks[taskId].data[11] = 3;
+        }
+        break;
+    case 5:
+        if (!--gTasks[taskId].data[13])
+        {
+            gTasks[taskId].data[13] = 5;
+            gTasks[taskId].data[11] = 3;
+        }
+        break;
+    }
+}
+
+void sub_800DD28(void)
+{
+    u8 i;
+    s32 j;
+    u16 r6;
+    u8 *recvBuffer, *dest, *src;
+
+    if (gReceivedRemoteLinkPlayers && (gBattleTypeFlags & BATTLE_TYPE_20) && (gLinkPlayers[0].linkType == 0x2211))
+    {
+        sub_80FBB4C();
+        for (i = 0; i < GetLinkPlayerCount(); ++i)
+        {
+            if (GetBlockReceivedStatus() & gBitTable[i])
+            {
+                ResetBlockReceivedFlag(i);
+                recvBuffer = (u8 *)gBlockRecvBuffer[i];
+                {
+                    r6 = gBlockRecvBuffer[i][2];
+                    if (gTasks[sLinkReceiveTaskId].data[14] + 9 + r6 > 0x1000)
+                    {
+                        gTasks[sLinkReceiveTaskId].data[12] = gTasks[sLinkReceiveTaskId].data[14];
+                        gTasks[sLinkReceiveTaskId].data[14] = 0;
+                    }
+                    dest = &gLinkBattleRecvBuffer[gTasks[sLinkReceiveTaskId].data[14]];
+                    src = recvBuffer;
+                    for (j = 0; j < r6 + 8; ++j)
+                        dest[j] = src[j];
+                }
+                gTasks[sLinkReceiveTaskId].data[14] = gTasks[sLinkReceiveTaskId].data[14] + r6 + 8;
+            }
+        }
+    }
+}
+
+static void Task_HandleCopyReceivedLinkBuffersData(u8 taskId)
+{
+    u16 blockSize;
+    u8 battlerId;
+    u8 var;
+
+    if (gTasks[taskId].data[15] != gTasks[taskId].data[14])
+    {
+        if (gTasks[taskId].data[15] > gTasks[taskId].data[14]
+         && gTasks[taskId].data[15] == gTasks[taskId].data[12])
+        {
+            gTasks[taskId].data[12] = 0;
+            gTasks[taskId].data[15] = 0;
+        }
+        battlerId = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ACTIVE_BATTLER];
+        blockSize = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_LO] | (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_SIZE_HI] << 8);
+        switch (gLinkBattleRecvBuffer[gTasks[taskId].data[15] + 0])
+        {
+        case 0:
+            if (gBattleControllerExecFlags & gBitTable[battlerId])
+                return;
+            memcpy(gBattleBufferA[battlerId], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
+            sub_8017298(battlerId);
+            if (!(gBattleTypeFlags & BATTLE_TYPE_IS_MASTER))
+            {
+                gBattlerAttacker = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ATTACKER];
+                gBattlerTarget = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_TARGET];
+                gAbsentBattlerFlags = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_ABSENT_BATTLER_FLAGS];
+                gEffectBattler = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_EFFECT_BATTLER];
+            }
+            break;
+        case 1:
+            memcpy(gBattleBufferB[battlerId], &gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA], blockSize);
+            break;
+        case 2:
+            var = gLinkBattleRecvBuffer[gTasks[taskId].data[15] + LINK_BUFF_DATA];
+            gBattleControllerExecFlags &= ~(gBitTable[battlerId] << (var * 4));
+            break;
+        }
+        gTasks[taskId].data[15] = gTasks[taskId].data[15] + blockSize + LINK_BUFF_DATA;
+    }
+}
+
+void BtlController_EmitGetMonData(u8 bufferId, u8 requestId, u8 monToCheck)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_GETMONDATA;
+    sBattleBuffersTransferData[1] = requestId;
+    sBattleBuffersTransferData[2] = monToCheck;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitGetRawMonData(u8 bufferId, u8 monId, u8 bytes)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_GETRAWMONDATA;
+    sBattleBuffersTransferData[1] = monId;
+    sBattleBuffersTransferData[2] = bytes;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSetMonData(u8 bufferId, u8 requestId, u8 monToCheck, u8 bytes, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_SETMONDATA;
+    sBattleBuffersTransferData[1] = requestId;
+    sBattleBuffersTransferData[2] = monToCheck;
+    for (i = 0; i < bytes; ++i)
+        sBattleBuffersTransferData[3 + i] = *(u8 *)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 3 + bytes);
+}
+
+// not used
+static void BtlController_EmitSetRawMonData(u8 bufferId, u8 monId, u8 bytes, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_SETRAWMONDATA;
+    sBattleBuffersTransferData[1] = monId;
+    sBattleBuffersTransferData[2] = bytes;
+    for (i = 0; i < bytes; ++i)
+        sBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, bytes + 3);
+}
+
+void BtlController_EmitLoadMonSprite(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_LOADMONSPRITE;
+    sBattleBuffersTransferData[1] = CONTROLLER_LOADMONSPRITE;
+    sBattleBuffersTransferData[2] = CONTROLLER_LOADMONSPRITE;
+    sBattleBuffersTransferData[3] = CONTROLLER_LOADMONSPRITE;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSwitchInAnim(u8 bufferId, u8 partyId, bool8 dontClearSubstituteBit)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_SWITCHINANIM;
+    sBattleBuffersTransferData[1] = partyId;
+    sBattleBuffersTransferData[2] = dontClearSubstituteBit;
+    sBattleBuffersTransferData[3] = 5;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitReturnMonToBall(u8 bufferId, u8 arg1)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_RETURNMONTOBALL;
+    sBattleBuffersTransferData[1] = arg1;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitDrawTrainerPic(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_DRAWTRAINERPIC;
+    sBattleBuffersTransferData[1] = CONTROLLER_DRAWTRAINERPIC;
+    sBattleBuffersTransferData[2] = CONTROLLER_DRAWTRAINERPIC;
+    sBattleBuffersTransferData[3] = CONTROLLER_DRAWTRAINERPIC;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitTrainerSlide(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDE;
+    sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDE;
+    sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDE;
+    sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDE;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitTrainerSlideBack(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_TRAINERSLIDEBACK;
+    sBattleBuffersTransferData[1] = CONTROLLER_TRAINERSLIDEBACK;
+    sBattleBuffersTransferData[2] = CONTROLLER_TRAINERSLIDEBACK;
+    sBattleBuffersTransferData[3] = CONTROLLER_TRAINERSLIDEBACK;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitFaintAnimation(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_FAINTANIMATION;
+    sBattleBuffersTransferData[1] = CONTROLLER_FAINTANIMATION;
+    sBattleBuffersTransferData[2] = CONTROLLER_FAINTANIMATION;
+    sBattleBuffersTransferData[3] = CONTROLLER_FAINTANIMATION;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitPaletteFade(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_PALETTEFADE;
+    sBattleBuffersTransferData[1] = CONTROLLER_PALETTEFADE;
+    sBattleBuffersTransferData[2] = CONTROLLER_PALETTEFADE;
+    sBattleBuffersTransferData[3] = CONTROLLER_PALETTEFADE;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitSuccessBallThrowAnim(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    sBattleBuffersTransferData[1] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    sBattleBuffersTransferData[2] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    sBattleBuffersTransferData[3] = CONTROLLER_SUCCESSBALLTHROWANIM;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitBallThrowAnim(u8 bufferId, u8 caseId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_BALLTHROWANIM;
+    sBattleBuffersTransferData[1] = caseId;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+// not used
+static void BtlController_EmitPause(u8 bufferId, u8 toWait, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_PAUSE;
+    sBattleBuffersTransferData[1] = toWait;
+    for (i = 0; i < toWait * 3; ++i)
+        sBattleBuffersTransferData[2 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, toWait * 3 + 2);
+}
+
+void BtlController_EmitMoveAnimation(u8 bufferId, u16 move, u8 turnOfMove, u16 movePower, s32 dmg, u8 friendship, struct DisableStruct *disableStructPtr)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_MOVEANIMATION;
+    sBattleBuffersTransferData[1] = move;
+    sBattleBuffersTransferData[2] = (move & 0xFF00) >> 8;
+    sBattleBuffersTransferData[3] = turnOfMove;
+    sBattleBuffersTransferData[4] = movePower;
+    sBattleBuffersTransferData[5] = (movePower & 0xFF00) >> 8;
+    sBattleBuffersTransferData[6] = dmg;
+    sBattleBuffersTransferData[7] = (dmg & 0x0000FF00) >> 8;
+    sBattleBuffersTransferData[8] = (dmg & 0x00FF0000) >> 16;
+    sBattleBuffersTransferData[9] = (dmg & 0xFF000000) >> 24;
+    sBattleBuffersTransferData[10] = friendship;
+    sBattleBuffersTransferData[11] = gUnknown_2023D72; // multihit in pokeem
+    if (WEATHER_HAS_EFFECT2)
+    {
+        sBattleBuffersTransferData[12] = gBattleWeather;
+        sBattleBuffersTransferData[13] = (gBattleWeather & 0xFF00) >> 8;
+    }
+    else
+    {
+        sBattleBuffersTransferData[12] = 0;
+        sBattleBuffersTransferData[13] = 0;
+    }
+    sBattleBuffersTransferData[14] = 0;
+    sBattleBuffersTransferData[15] = 0;
+    memcpy(&sBattleBuffersTransferData[16], disableStructPtr, sizeof(struct DisableStruct));
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 16 + sizeof(struct DisableStruct));
+}
+
+void BtlController_EmitPrintString(u8 bufferId, u16 stringID)
+{
+    s32 i;
+    struct BattleMsgData *stringInfo;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRING;
+    sBattleBuffersTransferData[1] = gBattleOutcome;
+    sBattleBuffersTransferData[2] = stringID;
+    sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+    stringInfo = (struct BattleMsgData *)(&sBattleBuffersTransferData[4]);
+    stringInfo->currentMove = gCurrentMove;
+    stringInfo->originallyUsedMove = gChosenMove;
+    stringInfo->lastItem = gLastUsedItem;
+    stringInfo->lastAbility = gLastUsedAbility;
+    stringInfo->scrActive = gBattleScripting.battler;
+    stringInfo->unk1605E = gBattleStruct->field_52;
+    stringInfo->hpScale = gBattleStruct->hpScale;
+    stringInfo->itemEffectBattler = gPotentialItemEffectBattler;
+    stringInfo->moveType = gBattleMoves[gCurrentMove].type;
+    for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+        stringInfo->abilities[i] = gBattleMons[i].ability;
+    for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; ++i)
+    {
+        stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+        stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+        stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+    }
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4);
+}
+
+void BtlController_EmitPrintSelectionString(u8 bufferId, u16 stringID)
+{
+    s32 i;
+    struct BattleMsgData *stringInfo;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_PRINTSTRINGPLAYERONLY;
+    sBattleBuffersTransferData[1] = CONTROLLER_PRINTSTRINGPLAYERONLY;
+    sBattleBuffersTransferData[2] = stringID;
+    sBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8;
+
+    stringInfo = (struct BattleMsgData*)(&sBattleBuffersTransferData[4]);
+    stringInfo->currentMove = gCurrentMove;
+    stringInfo->originallyUsedMove = gChosenMove;
+    stringInfo->lastItem = gLastUsedItem;
+    stringInfo->lastAbility = gLastUsedAbility;
+    stringInfo->scrActive = gBattleScripting.battler;
+    stringInfo->unk1605E = gBattleStruct->field_52;
+    for (i = 0; i < MAX_BATTLERS_COUNT; ++i)
+        stringInfo->abilities[i] = gBattleMons[i].ability;
+    for (i = 0; i < TEXT_BUFF_ARRAY_COUNT; ++i)
+    {
+        stringInfo->textBuffs[0][i] = gBattleTextBuff1[i];
+        stringInfo->textBuffs[1][i] = gBattleTextBuff2[i];
+        stringInfo->textBuffs[2][i] = gBattleTextBuff3[i];
+    }
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct BattleMsgData) + 4);
+}
+
+void BtlController_EmitChooseAction(u8 bufferId, u8 arg1, u16 arg2)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEACTION;
+    sBattleBuffersTransferData[1] = arg1;
+    sBattleBuffersTransferData[2] = arg2;
+    sBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitUnknownYesNoBox(u8 bufferId, u32 arg1) // TODO: Does the function name make sense for pokefirered? 
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_UNKNOWNYESNOBOX;
+    sBattleBuffersTransferData[1] = arg1;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitChooseMove(u8 bufferId, bool8 isDoubleBattle, bool8 NoPpNumber, struct ChooseMoveStruct *movePpData)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEMOVE;
+    sBattleBuffersTransferData[1] = isDoubleBattle;
+    sBattleBuffersTransferData[2] = NoPpNumber;
+    sBattleBuffersTransferData[3] = 0;
+    for (i = 0; i < sizeof(*movePpData); ++i)
+        sBattleBuffersTransferData[4 + i] = *((u8*)(movePpData) + i);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(*movePpData) + 4);
+}
+
+void BtlController_EmitChooseItem(u8 bufferId, u8 *arg1)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_OPENBAG;
+    for (i = 0; i < 3; ++i)
+        sBattleBuffersTransferData[1 + i] = arg1[i];
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitChoosePokemon(u8 bufferId, u8 caseId, u8 arg2, u8 abilityId, u8 *arg4)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_CHOOSEPOKEMON;
+    sBattleBuffersTransferData[1] = caseId;
+    sBattleBuffersTransferData[2] = arg2;
+    sBattleBuffersTransferData[3] = abilityId;
+    for (i = 0; i < 3; ++i)
+        sBattleBuffersTransferData[4 + i] = arg4[i];
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 8);  // Only 7 bytes were written.
+}
+
+// not used
+static void BtlController_EmitCmd23(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_23;
+    sBattleBuffersTransferData[1] = CONTROLLER_23;
+    sBattleBuffersTransferData[2] = CONTROLLER_23;
+    sBattleBuffersTransferData[3] = CONTROLLER_23;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitHealthBarUpdate(u8 bufferId, u16 hpValue)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_HEALTHBARUPDATE;
+    sBattleBuffersTransferData[1] = 0;
+    sBattleBuffersTransferData[2] = (s16)hpValue;
+    sBattleBuffersTransferData[3] = ((s16)hpValue & 0xFF00) >> 8;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitExpUpdate(u8 bufferId, u8 partyId, u16 expPoints)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_EXPUPDATE;
+    sBattleBuffersTransferData[1] = partyId;
+    sBattleBuffersTransferData[2] = (s16)expPoints;
+    sBattleBuffersTransferData[3] = ((s16)expPoints & 0xFF00) >> 8;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitStatusIconUpdate(u8 bufferId, u32 status1, u32 status2)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_STATUSICONUPDATE;
+    sBattleBuffersTransferData[1] = status1;
+    sBattleBuffersTransferData[2] = (status1 & 0x0000FF00) >> 8;
+    sBattleBuffersTransferData[3] = (status1 & 0x00FF0000) >> 16;
+    sBattleBuffersTransferData[4] = (status1 & 0xFF000000) >> 24;
+    sBattleBuffersTransferData[5] = status2;
+    sBattleBuffersTransferData[6] = (status2 & 0x0000FF00) >> 8;
+    sBattleBuffersTransferData[7] = (status2 & 0x00FF0000) >> 16;
+    sBattleBuffersTransferData[8] = (status2 & 0xFF000000) >> 24;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 9);
+}
+
+void BtlController_EmitStatusAnimation(u8 bufferId, bool8 status2, u32 status)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_STATUSANIMATION;
+    sBattleBuffersTransferData[1] = status2;
+    sBattleBuffersTransferData[2] = status;
+    sBattleBuffersTransferData[3] = (status & 0x0000FF00) >> 8;
+    sBattleBuffersTransferData[4] = (status & 0x00FF0000) >> 16;
+    sBattleBuffersTransferData[5] = (status & 0xFF000000) >> 24;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 6);
+}
+
+// not used
+static void BtlController_EmitStatusXor(u8 bufferId, u8 b)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_STATUSXOR;
+    sBattleBuffersTransferData[1] = b;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitDataTransfer(u8 bufferId, u16 size, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_DATATRANSFER;
+    sBattleBuffersTransferData[1] = CONTROLLER_DATATRANSFER;
+    sBattleBuffersTransferData[2] = size;
+    sBattleBuffersTransferData[3] = (size & 0xFF00) >> 8;
+    for (i = 0; i < size; ++i)
+        sBattleBuffersTransferData[4 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 4);
+}
+
+// not used
+static void BtlController_EmitDMA3Transfer(u8 bufferId, void *dst, u16 size, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_DMA3TRANSFER;
+    sBattleBuffersTransferData[1] = (u32)(dst);
+    sBattleBuffersTransferData[2] = ((u32)(dst) & 0x0000FF00) >> 8;
+    sBattleBuffersTransferData[3] = ((u32)(dst) & 0x00FF0000) >> 16;
+    sBattleBuffersTransferData[4] = ((u32)(dst) & 0xFF000000) >> 24;
+    sBattleBuffersTransferData[5] = size;
+    sBattleBuffersTransferData[6] = (size & 0xFF00) >> 8;
+    for (i = 0; i < size; ++i)
+        sBattleBuffersTransferData[7 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 7);
+}
+
+// not used
+static void BtlController_EmitPlayBGM(u8 bufferId, u16 songId, void *unusedDumbDataParameter)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_31;
+    sBattleBuffersTransferData[1] = songId;
+    sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+    for (i = 0; i < songId; ++i)
+        sBattleBuffersTransferData[3 + i] = *(u8*)(unusedDumbDataParameter++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, songId + 3);
+}
+
+// not used
+static void BtlController_EmitCmd32(u8 bufferId, u16 size, void *data)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_32;
+    sBattleBuffersTransferData[1] = size;
+    sBattleBuffersTransferData[2] = (size & 0xFF00) >> 8;
+    for (i = 0; i < size; ++i)
+        sBattleBuffersTransferData[3 + i] = *(u8*)(data++);
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, size + 3);
+}
+
+void BtlController_EmitTwoReturnValues(u8 bufferId, u8 arg1, u16 arg2)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_TWORETURNVALUES;
+    sBattleBuffersTransferData[1] = arg1;
+    sBattleBuffersTransferData[2] = arg2;
+    sBattleBuffersTransferData[3] = (arg2 & 0xFF00) >> 8;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitChosenMonReturnValue(u8 bufferId, u8 b, u8 *c)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_CHOSENMONRETURNVALUE;
+    sBattleBuffersTransferData[1] = b;
+    for (i = 0; i < 3; ++i)
+        sBattleBuffersTransferData[2 + i] = c[i];
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 5);
+}
+
+void BtlController_EmitOneReturnValue(u8 bufferId, u16 arg1)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE;
+    sBattleBuffersTransferData[1] = arg1;
+    sBattleBuffersTransferData[2] = (arg1 & 0xFF00) >> 8;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitOneReturnValue_Duplicate(u8 bufferId, u16 b)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_ONERETURNVALUE_DUPLICATE;
+    sBattleBuffersTransferData[1] = b;
+    sBattleBuffersTransferData[2] = (b & 0xFF00) >> 8;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd37(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_37;
+    sBattleBuffersTransferData[1] = CONTROLLER_37;
+    sBattleBuffersTransferData[2] = CONTROLLER_37;
+    sBattleBuffersTransferData[3] = CONTROLLER_37;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd38(u8 bufferId, u8 b)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_38;
+    sBattleBuffersTransferData[1] = b;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+// not used
+static void BtlController_EmitCmd39(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_39;
+    sBattleBuffersTransferData[1] = CONTROLLER_39;
+    sBattleBuffersTransferData[2] = CONTROLLER_39;
+    sBattleBuffersTransferData[3] = CONTROLLER_39;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+// not used
+static void BtlController_EmitCmd40(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_40;
+    sBattleBuffersTransferData[1] = CONTROLLER_40;
+    sBattleBuffersTransferData[2] = CONTROLLER_40;
+    sBattleBuffersTransferData[3] = CONTROLLER_40;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitHitAnimation(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_HITANIMATION;
+    sBattleBuffersTransferData[1] = CONTROLLER_HITANIMATION;
+    sBattleBuffersTransferData[2] = CONTROLLER_HITANIMATION;
+    sBattleBuffersTransferData[3] = CONTROLLER_HITANIMATION;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitCmd42(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_42;
+    sBattleBuffersTransferData[1] = CONTROLLER_42;
+    sBattleBuffersTransferData[2] = CONTROLLER_42;
+    sBattleBuffersTransferData[3] = CONTROLLER_42;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitPlaySE(u8 bufferId, u16 songId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_EFFECTIVENESSSOUND;
+    sBattleBuffersTransferData[1] = songId;
+    sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitPlayFanfare(u8 bufferId, u16 songId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_PLAYFANFAREORBGM;
+    sBattleBuffersTransferData[1] = songId;
+    sBattleBuffersTransferData[2] = (songId & 0xFF00) >> 8;
+    sBattleBuffersTransferData[3] = 0;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitFaintingCry(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_FAINTINGCRY;
+    sBattleBuffersTransferData[1] = CONTROLLER_FAINTINGCRY;
+    sBattleBuffersTransferData[2] = CONTROLLER_FAINTINGCRY;
+    sBattleBuffersTransferData[3] = CONTROLLER_FAINTINGCRY;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitIntroSlide(u8 bufferId, u8 terrainId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_INTROSLIDE;
+    sBattleBuffersTransferData[1] = terrainId;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitIntroTrainerBallThrow(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_INTROTRAINERBALLTHROW;
+    sBattleBuffersTransferData[1] = CONTROLLER_INTROTRAINERBALLTHROW;
+    sBattleBuffersTransferData[2] = CONTROLLER_INTROTRAINERBALLTHROW;
+    sBattleBuffersTransferData[3] = CONTROLLER_INTROTRAINERBALLTHROW;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitDrawPartyStatusSummary(u8 bufferId, struct HpAndStatus* hpAndStatus, u8 arg2)
+{
+    s32 i;
+
+    sBattleBuffersTransferData[0] = CONTROLLER_DRAWPARTYSTATUSSUMMARY;
+    sBattleBuffersTransferData[1] = arg2 & 0x7F;
+    sBattleBuffersTransferData[2] = (arg2 & 0x80) >> 7;
+    sBattleBuffersTransferData[3] = CONTROLLER_DRAWPARTYSTATUSSUMMARY;
+    for (i = 0; i < (s32)(sizeof(struct HpAndStatus) * PARTY_SIZE); ++i)
+        sBattleBuffersTransferData[4 + i] = *(i + (u8*)(hpAndStatus));
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, sizeof(struct HpAndStatus) * PARTY_SIZE + 4);
+}
+
+void BtlController_EmitHidePartyStatusSummary(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+    sBattleBuffersTransferData[1] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+    sBattleBuffersTransferData[2] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+    sBattleBuffersTransferData[3] = CONTROLLER_HIDEPARTYSTATUSSUMMARY;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitEndBounceEffect(u8 bufferId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_ENDBOUNCE;
+    sBattleBuffersTransferData[1] = CONTROLLER_ENDBOUNCE;
+    sBattleBuffersTransferData[2] = CONTROLLER_ENDBOUNCE;
+    sBattleBuffersTransferData[3] = CONTROLLER_ENDBOUNCE;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitSpriteInvisibility(u8 bufferId, bool8 isInvisible)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_SPRITEINVISIBILITY;
+    sBattleBuffersTransferData[1] = isInvisible;
+    sBattleBuffersTransferData[2] = CONTROLLER_SPRITEINVISIBILITY;
+    sBattleBuffersTransferData[3] = CONTROLLER_SPRITEINVISIBILITY;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitBattleAnimation(u8 bufferId, u8 animationId, u16 argument)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_BATTLEANIMATION;
+    sBattleBuffersTransferData[1] = animationId;
+    sBattleBuffersTransferData[2] = argument;
+    sBattleBuffersTransferData[3] = (argument & 0xFF00) >> 8;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 4);
+}
+
+void BtlController_EmitLinkStandbyMsg(u8 bufferId, u8 arg1)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_LINKSTANDBYMSG;
+    sBattleBuffersTransferData[1] = arg1;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitResetActionMoveSelection(u8 bufferId, u8 caseId)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_RESETACTIONMOVESELECTION;
+    sBattleBuffersTransferData[1] = caseId;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
+
+void BtlController_EmitCmd55(u8 bufferId, u8 battleOutcome)
+{
+    sBattleBuffersTransferData[0] = CONTROLLER_55;
+    sBattleBuffersTransferData[1] = battleOutcome;
+    PrepareBufferDataTransfer(bufferId, sBattleBuffersTransferData, 2);
+}
diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c
index bea4406bc..f0a724fe6 100644
--- a/src/battle_gfx_sfx_util.c
+++ b/src/battle_gfx_sfx_util.c
@@ -758,6 +758,7 @@ void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, u8 notTransform)
 void BattleLoadSubstituteOrMonSpriteGfx(u8 battlerId, bool8 loadMonSprite)
 {
     u8 position;
+    // variable i is actually u8, but needs to be 32-bit to make the inline ASM match. 
     s32 i;
     u32 palOffset;
     const void *substitutePal;
diff --git a/src/mevent.c b/src/mevent.c
index fc0c1f2d4..d0d7f59aa 100644
--- a/src/mevent.c
+++ b/src/mevent.c
@@ -134,7 +134,7 @@ static void ResetTTDataBuffer(void)
 {
     memset(gDecompressionBuffer, 0, 0x2000);
     gLinkType = 0x5502;
-    sub_8009804();
+    OpenLink();
     SetSuppressLinkErrorMessage(TRUE);
 }
 
@@ -156,7 +156,7 @@ bool32 sub_81436EC(void)
 
 static bool32 IsEReaderConnectionSane(void)
 {
-    if (sub_800AA48() && GetLinkPlayerCount_2() == 2)
+    if (IsLinkMaster() && GetLinkPlayerCount_2() == 2)
         return TRUE;
     return FALSE;
 }
@@ -171,7 +171,7 @@ u32 sub_8143770(u8 * r4, u16 * r5)
     switch (*r4)
     {
         case 0:
-            if (sub_800AA48() && GetLinkPlayerCount_2() > 1)
+            if (IsLinkMaster() && GetLinkPlayerCount_2() > 1)
             {
                 *r4 = 1;
                 ;
@@ -193,7 +193,7 @@ u32 sub_8143770(u8 * r4, u16 * r5)
             if (GetLinkPlayerCount_2() == 2)
             {
                 PlaySE(SE_TOY_G);
-                sub_800A5BC();
+                CheckShouldAdvanceLinkState();
                 *r5 = 0;
                 *r4 = 3;
             }
diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c
index 35efa68c8..6df5207f0 100644
--- a/src/mevent_server_helpers.c
+++ b/src/mevent_server_helpers.c
@@ -155,7 +155,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
     switch (svr->seqno)
     {
         case 0:
-            if (sub_800A4BC())
+            if (IsLinkTaskFinished())
             {
                 header.ident = svr->sendIdent;
                 header.size = svr->sendSize;
@@ -167,7 +167,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
             }
             break;
         case 1:
-            if (sub_800A4BC())
+            if (IsLinkTaskFinished())
             {
                 if (mevent_has_received(svr->sendPlayerNo))
                 {
@@ -189,7 +189,7 @@ static bool32 mevent_send_func(struct mevent_srv_sub * svr)
             }
             break;
         case 2:
-            if (sub_800A4BC())
+            if (IsLinkTaskFinished())
             {
                 if (CalcCRC16WithTable(svr->sendBfr, svr->sendSize) != svr->sendCRC)
                     sub_80FA190();
diff --git a/src/pokemon.c b/src/pokemon.c
index 848f258be..ffe407daf 100644
--- a/src/pokemon.c
+++ b/src/pokemon.c
@@ -19,7 +19,6 @@
 #include "evolution_scene.h"
 #include "battle_message.h"
 #include "battle_util.h"
-#include "battle_ai_script_commands.h"
 #include "link.h"
 #include "m4a.h"
 #include "sound.h"
@@ -2592,7 +2591,7 @@ u8 CountAliveMonsInBattle(u8 caseId)
     case BATTLE_ALIVE_ATK_SIDE:
         for (i = 0; i < 4; i++)
         {
-            if (GetBattlerSide(i) == GetBattlerSide(sBattler_AI) && !(gAbsentBattlerFlags & gBitTable[i]))
+            if (GetBattlerSide(i) == GetBattlerSide(gBattlerAttacker) && !(gAbsentBattlerFlags & gBitTable[i]))
                 retVal++;
         }
         break;
@@ -6106,7 +6105,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId)
             }
             else
             {
-                sBattler_AI = gBattlerInMenuId;
+                gBattlerAttacker = gBattlerInMenuId;
                 BattleStringExpandPlaceholdersToDisplayedString(BattleText_GetPumped);
             }
         }
@@ -6114,7 +6113,7 @@ const u8 *Battle_PrintStatBoosterEffectMessage(u16 itemId)
 
     if (itemEffect[3] & 0x80)
     {
-        sBattler_AI = gBattlerInMenuId;
+        gBattlerAttacker = gBattlerInMenuId;
         BattleStringExpandPlaceholdersToDisplayedString(BattleText_MistShroud);
     }
 
@@ -7075,15 +7074,9 @@ void BoxMonRestorePP(struct BoxPokemon *boxMon)
     }
 }
 
-// SetMonPreventsSwitchingString
-void sub_8044348(void)
+void SetMonPreventsSwitchingString(void)
 {
-#ifdef NONMATCHING
-    gLastUsedAbility = gBattleStruct -> abilityPreventingSwitchout; // fixed from the original
-#else
-    gLastUsedAbility = ((u8 *) gBattleStruct)[0xac]; // huh? why is this wrong?
-#endif
-
+    gLastUsedAbility = gBattleStruct -> abilityPreventingSwitchout;
     gBattleTextBuff1[0] = B_BUFF_PLACEHOLDER_BEGIN;
     gBattleTextBuff1[1] = B_BUFF_MON_NICK_WITH_PREFIX;
     gBattleTextBuff1[2] = gBattleStruct->battlerPreventingSwitchout;
diff --git a/src/quest_log_battle.c b/src/quest_log_battle.c
index 3dfc2eb57..2687e4ea5 100644
--- a/src/quest_log_battle.c
+++ b/src/quest_log_battle.c
@@ -26,7 +26,7 @@ void sub_812C334(s32 *, s32 *);
 
 void sub_812BFDC(void)
 {
-    if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_WALLY_TUTORIAL | BATTLE_TYPE_POKEDUDE)) && (gBattleOutcome == B_OUTCOME_WON || gBattleOutcome == B_OUTCOME_CAUGHT))
+    if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_OLDMAN_TUTORIAL | BATTLE_TYPE_POKEDUDE)) && (gBattleOutcome == B_OUTCOME_WON || gBattleOutcome == B_OUTCOME_CAUGHT))
     {
         struct QuestLogStruct_TrainerBattleRecord * questLogTrainerBattleRecord = Alloc(sizeof(struct QuestLogStruct_TrainerBattleRecord));
         struct QuestLogStruct_WildBattleRecord * questLogWildBattleRecord = Alloc(sizeof(struct QuestLogStruct_WildBattleRecord));
diff --git a/src/save.c b/src/save.c
index d3d31a22e..9f580477b 100644
--- a/src/save.c
+++ b/src/save.c
@@ -68,7 +68,7 @@ const struct SaveSectionOffsets gSaveSectionOffsets[] =
 
 extern void DoSaveFailedScreen(u8 saveType); // save_failed_screen
 extern void sub_800AB9C(void); // link
-extern bool8 sub_800A4BC(void); // link
+extern bool8 IsLinkTaskFinished(void); // link
 extern void save_serialize_map(void); // fieldmap
 extern void sub_804C1C0(void); // load_save
 extern void sav2_gender2_inplace_and_xFE(void); // load_save
@@ -865,7 +865,7 @@ void sub_80DA634(u8 taskId)
         gTasks[taskId].data[0] = 2;
         break;
     case 2:
-        if (sub_800A4BC())
+        if (IsLinkTaskFinished())
         {
             save_serialize_map();
             gTasks[taskId].data[0] = 3;
@@ -899,7 +899,7 @@ void sub_80DA634(u8 taskId)
         gTasks[taskId].data[0] = 8;
         break;
     case 8:
-        if (sub_800A4BC())
+        if (IsLinkTaskFinished())
         {
             sub_80DA434();
             gTasks[taskId].data[0] = 9;
@@ -910,7 +910,7 @@ void sub_80DA634(u8 taskId)
         gTasks[taskId].data[0] = 10;
         break;
     case 10:
-        if (sub_800A4BC())
+        if (IsLinkTaskFinished())
             gTasks[taskId].data[0]++;
         break;
     case 11: